Project

General

Profile

« Previous | Next » 

Revision 9833

Added by Jing Tao over 8 years ago

Replaced the JiBXException by MarshallingException.

View differences:

src/edu/ucsb/nceas/metacat/dataone/CNodeService.java
44 44
import org.dataone.client.v2.CNode;
45 45
import org.dataone.client.v2.MNode;
46 46
import org.dataone.client.v2.itk.D1Client;
47
import org.dataone.exceptions.MarshallingException;
47 48
import org.dataone.service.cn.v2.CNAuthorization;
48 49
import org.dataone.service.cn.v2.CNCore;
49 50
import org.dataone.service.cn.v2.CNRead;
......
84 85
import org.dataone.service.types.v2.ObjectFormat;
85 86
import org.dataone.service.types.v2.ObjectFormatList;
86 87
import org.dataone.service.types.v2.SystemMetadata;
87
import org.dataone.service.types.v2.util.ServiceMethodRestrictionUtil;
88 88
import org.dataone.service.util.TypeMarshaller;
89
import org.jibx.runtime.JiBXException;
90 89

  
90

  
91 91
import edu.ucsb.nceas.metacat.DBUtil;
92 92
import edu.ucsb.nceas.metacat.EventLog;
93 93
import edu.ucsb.nceas.metacat.IdentifierManager;
......
1251 1251
        try {
1252 1252
            os = new PipedOutputStream(is);
1253 1253
            TypeMarshaller.marshalTypeToOutputStream(objectFormatList, os);
1254
        } catch (JiBXException | IOException e) {
1254
        } catch (MarshallingException | IOException e) {
1255 1255
            throw new ServiceFailure("0000", "Unable to marshal object format list.\n" + e.getMessage());
1256 1256
        } finally {
1257 1257
            try {
src/edu/ucsb/nceas/metacat/dataone/ObjectFormatService.java
28 28
import java.util.HashMap;
29 29

  
30 30
import org.apache.log4j.Logger;
31
import org.dataone.exceptions.MarshallingException;
31 32
import org.dataone.service.util.TypeMarshaller;
32 33
import org.dataone.service.exceptions.NotFound;
33 34
import org.dataone.service.exceptions.NotImplemented;
......
35 36
import org.dataone.service.types.v2.ObjectFormat;
36 37
import org.dataone.service.types.v1.ObjectFormatIdentifier;
37 38
import org.dataone.service.types.v2.ObjectFormatList;
38
import org.jibx.runtime.JiBXException;
39 39

  
40 40
import edu.ucsb.nceas.metacat.DBUtil;
41 41
import edu.ucsb.nceas.metacat.DocumentImpl;
......
205 205
							"Unexpected exception from the service - "
206 206
									+ e.getClass() + ": " + e.getMessage());
207 207

  
208
				} catch (JiBXException e) {
208
				} catch (MarshallingException e) {
209 209
					throw new ServiceFailure("4841",
210 210
							"Unexpected exception from the service - "
211 211
									+ e.getClass() + ": " + e.getMessage());
src/edu/ucsb/nceas/metacat/dataone/SystemMetadataFactory.java
53 53
import org.dataone.eml.DataoneEMLParser;
54 54
import org.dataone.eml.EMLDocument;
55 55
import org.dataone.eml.EMLDocument.DistributionMetadata;
56
import org.dataone.exceptions.MarshallingException;
56 57
import org.dataone.ore.ResourceMapFactory;
57 58
import org.dataone.service.exceptions.BaseException;
58 59
import org.dataone.service.exceptions.NotFound;
......
69 70
import org.dataone.service.types.v1.util.ChecksumUtil;
70 71
import org.dataone.service.util.DateTimeMarshaller;
71 72
import org.dspace.foresite.ResourceMap;
72
import org.jibx.runtime.JiBXException;
73 73
import org.xml.sax.SAXException;
74 74

  
75 75
import java.util.Calendar;
......
123 123
	 * @throws PropertyNotFoundException
124 124
	 * @throws BaseException
125 125
	 * @throws NoSuchAlgorithmException
126
	 * @throws JiBXException
126
	 * @throws MarshallingException
127 127
	 * @throws AccessControlException
128 128
	 * @throws HandlerException
129 129
	 * @throws SAXException
......
134 134
            IOException, AccessionNumberException, ClassNotFoundException,
135 135
            InsufficientKarmaException, ParseLSIDException,
136 136
            PropertyNotFoundException, BaseException, NoSuchAlgorithmException,
137
            JiBXException, AccessControlException, HandlerException, SAXException, AccessException {
137
            MarshallingException, AccessControlException, HandlerException, SAXException, AccessException {
138 138
	        boolean indexDataFile = false;
139 139
	        return createSystemMetadata(indexDataFile, localId, includeORE, downloadData);
140 140
	}
......
161 161
			IOException, AccessionNumberException, ClassNotFoundException,
162 162
			InsufficientKarmaException, ParseLSIDException,
163 163
			PropertyNotFoundException, BaseException, NoSuchAlgorithmException,
164
			JiBXException, AccessControlException, HandlerException, SAXException, AccessException {
164
			MarshallingException, AccessControlException, HandlerException, SAXException, AccessException {
165 165
		
166 166
		logMetacat.debug("createSystemMetadata() called for localId " + localId);
167 167

  
......
702 702
     * @throws SQLException
703 703
	 * @throws SAXException 
704 704
	 * @throws HandlerException 
705
	 * @throws JiBXException 
705
	 * @throws MarshallingException 
706 706
	 * @throws BaseException 
707 707
	 * @throws ParseLSIDException 
708 708
	 * @throws InsufficientKarmaException 
......
713 713
	 * @throws AccessControlException 
714 714
     */
715 715
    public static void generateSystemMetadata(List<String> idList, boolean includeOre, boolean downloadData) 
716
    throws PropertyNotFoundException, NoSuchAlgorithmException, AccessionNumberException, SQLException, AccessControlException, AccessException, McdbException, IOException, ClassNotFoundException, InsufficientKarmaException, ParseLSIDException, BaseException, JiBXException, HandlerException, SAXException 
716
    throws PropertyNotFoundException, NoSuchAlgorithmException, AccessionNumberException, SQLException, AccessControlException, AccessException, McdbException, IOException, ClassNotFoundException, InsufficientKarmaException, ParseLSIDException, BaseException, MarshallingException, HandlerException, SAXException 
717 717
    {
718 718
        
719 719
        for (String localId : idList) { 
src/edu/ucsb/nceas/metacat/dataone/convert/LogV2toV1Converter.java
25 25

  
26 26
import java.io.IOException;
27 27
import java.lang.reflect.InvocationTargetException;
28

  
28
import org.dataone.exceptions.MarshallingException;
29 29
import org.dataone.service.types.v1.Event;
30 30
import org.dataone.service.types.v2.Log;
31 31
import org.dataone.service.types.v2.LogEntry;
32
import org.jibx.runtime.JiBXException;
32

  
33 33
/**
34 34
 * This class represents a converter to convert an DataONE v2 Log object to a v1 Log object.
35 35
 * It probably will be removed to d1_common_java in the future. 
......
56 56
     * @throws InstantiationException 
57 57
     */
58 58
    public org.dataone.service.types.v1.Log convert(Log logV2) 
59
            throws InstantiationException, IllegalAccessException, InvocationTargetException, JiBXException, IOException {
59
            throws InstantiationException, IllegalAccessException, InvocationTargetException, MarshallingException, IOException {
60 60
        org.dataone.service.types.v1.Log logV1 = null;
61 61
        int removedLogCount =0;
62 62
        if(logV2 != null) {
......
104 104
         * @throws InstantiationException 
105 105
         */
106 106
        public org.dataone.service.types.v1.LogEntry convert(LogEntry logEntryV2) 
107
                throws InstantiationException, IllegalAccessException, InvocationTargetException, JiBXException, IOException {
107
                throws InstantiationException, IllegalAccessException, InvocationTargetException, MarshallingException, IOException {
108 108
            org.dataone.service.types.v1.LogEntry logEntryV1 = null;;
109 109
            if(logEntryV2 != null) {
110 110
                logEntryV1 = new org.dataone.service.types.v1.LogEntry();
src/edu/ucsb/nceas/metacat/dataone/hazelcast/ObjectPathMap.java
10 10
import java.util.Set;
11 11

  
12 12
import org.apache.log4j.Logger;
13
import org.dataone.exceptions.MarshallingException;
13 14
import org.dataone.service.types.v1.Identifier;
14
import org.jibx.runtime.JiBXException;
15 15
import org.xml.sax.SAXException;
16 16

  
17 17
import com.hazelcast.core.MapLoader;
......
71 71
	 * the data.  The doctype value for metadata can vary, but for data
72 72
	 * is always 'BIN', so using a simple if-then-else to separate
73 73
	 */
74
	private String pathToDocid(String localid) throws AccessControlException, HandlerException, JiBXException, IOException, McdbException, SAXException  
74
	private String pathToDocid(String localid) throws AccessControlException, HandlerException, MarshallingException, IOException, McdbException, SAXException  
75 75
	{	
76 76
		Hashtable<String, String> ht = ReplicationService.getDocumentInfoMap(localid);
77 77
		if (ht.get("doctype").equals("BIN")) {
src/edu/ucsb/nceas/metacat/replication/ReplicationService.java
75 75
import org.dataone.client.rest.RestClient;
76 76
import org.dataone.client.types.AutoCloseHttpClientInputStream;
77 77
import org.dataone.client.utils.HttpUtils;
78
import org.dataone.exceptions.MarshallingException;
78 79
import org.dataone.service.types.v1.Identifier;
79 80
import org.dataone.service.types.v2.SystemMetadata;
80 81
import org.dataone.service.util.DateTimeMarshaller;
81 82
import org.dataone.service.util.TypeMarshaller;
82
import org.jibx.runtime.JiBXException;
83 83
import org.xml.sax.InputSource;
84 84
import org.xml.sax.SAXException;
85 85
import org.xml.sax.XMLReader;
......
1146 1146
	}
1147 1147
	
1148 1148
	public static Hashtable<String, String> getDocumentInfoMap(String docid)
1149
			throws HandlerException, AccessControlException, JiBXException,
1149
			throws HandlerException, AccessControlException, MarshallingException,
1150 1150
			IOException, McdbException, SAXException {
1151 1151
		
1152 1152
		// Try get docid info from remote server
......
1174 1174
	 * @throws IOException
1175 1175
	 * @throws McdbException
1176 1176
	 */
1177
	public static String getDocumentInfo(String docid) throws AccessControlException, JiBXException, IOException, McdbException {
1177
	public static String getDocumentInfo(String docid) throws AccessControlException, MarshallingException, IOException, McdbException {
1178 1178
		StringBuffer sb = new StringBuffer();
1179 1179

  
1180 1180
		DocumentImpl doc = new DocumentImpl(docid);
src/edu/ucsb/nceas/metacat/restservice/v1/CNResourceHandler.java
40 40
import org.apache.commons.io.IOUtils;
41 41
import org.apache.log4j.Logger;
42 42
import org.dataone.client.v2.formats.ObjectFormatInfo;
43
import org.dataone.exceptions.MarshallingException;
43 44
import org.dataone.service.exceptions.BaseException;
44 45
import org.dataone.service.exceptions.IdentifierNotUnique;
45 46
import org.dataone.service.exceptions.InsufficientResources;
......
76 77
import org.dataone.service.util.EncodingUtilities;
77 78
import org.dataone.service.util.ExceptionHandler;
78 79
import org.dataone.service.util.TypeMarshaller;
79
import org.jibx.runtime.JiBXException;
80 80
import org.xml.sax.SAXException;
81 81

  
82 82
import edu.ucsb.nceas.metacat.dataone.v1.CNodeService;
......
432 432
     * @throws ServiceFailure
433 433
     * @throws InvalidToken
434 434
     * @throws IOException
435
     * @throws JiBXException
435
     * @throws MarshallingException
436 436
     */
437 437
    private void checksum(String guid) throws InvalidToken, ServiceFailure,
438 438
            NotAuthorized, NotFound, InvalidRequest, NotImplemented,
439
            JiBXException, IOException {
439
            MarshallingException, IOException {
440 440
        Identifier guidid = new Identifier();
441 441
        guidid.setValue(guid);
442 442
        logMetacat.debug("getting checksum for object " + guid);
......
462 462
     * @throws ServiceFailure
463 463
     * @throws InvalidToken
464 464
     * @throws IOException
465
     * @throws JiBXException
465
     * @throws MarshallingException
466 466
     * @throws InsufficientResources 
467 467
     */
468 468
    private void getLog() throws InvalidToken, ServiceFailure, NotAuthorized,
469
            InvalidRequest, NotImplemented, IOException, JiBXException, InsufficientResources {
469
            InvalidRequest, NotImplemented, IOException, MarshallingException, InsufficientResources {
470 470

  
471 471
        Date fromDate = null;
472 472
        Date toDate = null;
......
582 582
     * @throws ServiceFailure
583 583
     * @throws InvalidToken
584 584
     * @throws IOException
585
     * @throws JiBXException
585
     * @throws MarshallingException
586 586
     */
587 587
    protected void getSystemMetadataObject(String guid) throws InvalidToken,
588 588
            ServiceFailure, NotAuthorized, NotFound, InvalidRequest,
589
            NotImplemented, IOException, JiBXException {
589
            NotImplemented, IOException, MarshallingException {
590 590

  
591 591
        Identifier id = new Identifier();
592 592
        id.setValue(guid);
......
612 612
     * @throws InvalidRequest
613 613
     * @throws ServiceFailure
614 614
     * @throws IdentifierNotUnique
615
     * @throws JiBXException
615
     * @throws MarshallingException
616 616
     * @throws NotImplemented
617 617
     * @throws InvalidSystemMetadata
618 618
     * @throws InsufficientResources
......
624 624
     * @throws InstantiationException
625 625
     */
626 626
    protected void putObject(String action) throws ServiceFailure,
627
            InvalidRequest, IdentifierNotUnique, JiBXException, InvalidToken,
627
            InvalidRequest, IdentifierNotUnique, MarshallingException, InvalidToken,
628 628
            NotAuthorized, UnsupportedType, InsufficientResources,
629 629
            InvalidSystemMetadata, NotImplemented, IOException,
630 630
            InstantiationException, IllegalAccessException {
......
677 677
     * @throws ServiceFailure
678 678
     * @throws InvalidRequest
679 679
     * @throws IOException
680
     * @throws JiBXException
680
     * @throws MarshallingException
681 681
     */
682 682
    private void listFormats() throws InvalidRequest, ServiceFailure, NotFound,
683
            InsufficientResources, NotImplemented, IOException, JiBXException {
683
            InsufficientResources, NotImplemented, IOException, MarshallingException {
684 684
        logMetacat.debug("Entering listFormats()");
685 685

  
686 686
        ObjectFormatList objectFormatList = CNodeService.getInstance(request)
......
705 705
    }
706 706
    
707 707
    private void listChecksumAlgorithms() throws IOException, ServiceFailure,
708
			NotImplemented, JiBXException {
708
			NotImplemented, MarshallingException {
709 709
		logMetacat.debug("Entering listFormats()");
710 710

  
711 711
		ChecksumAlgorithmList result = CNodeService.getInstance(request).listChecksumAlgorithms();
......
768 768
     * @throws NotAuthorized 
769 769
     * @throws ServiceFailure 
770 770
     * @throws InvalidToken 
771
     * @throws JiBXException 
771
     * @throws MarshallingException 
772 772
     */
773
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, JiBXException 
773
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, MarshallingException 
774 774
    {
775 775

  
776 776
        OutputStream out = response.getOutputStream();
......
795 795
     * @throws NotFound
796 796
     * @throws NotImplemented
797 797
     * @throws IOException
798
     * @throws JiBXException
798
     * @throws MarshallingException
799 799
     * @throws InvalidRequest 
800 800
     */
801
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, JiBXException, InvalidRequest {
801
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, MarshallingException, InvalidRequest {
802 802

  
803 803
        OutputStream out = response.getOutputStream();
804 804
        response.setStatus(200);
......
825 825
     * @throws ServiceFailure
826 826
     * @throws InvalidRequest
827 827
     * @throws IOException
828
     * @throws JiBXException
828
     * @throws MarshallingException
829 829
     */
830 830
    private void getFormat(String fmtidStr) throws InvalidRequest,
831 831
            ServiceFailure, NotFound, InsufficientResources, NotImplemented,
832
            IOException, JiBXException {
832
            IOException, MarshallingException {
833 833
        logMetacat.debug("Entering listFormats()");
834 834

  
835 835
        ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
......
917 917
            logMetacat.debug(msg);
918 918
            throw new ServiceFailure("4210", msg);
919 919
        
920
        } catch (JiBXException e) {
920
        } catch (MarshallingException e) {
921 921
            String msg = "Couldn't marshall the identifier to the response output stream: " +
922 922
            e.getMessage();
923 923
            logMetacat.debug(msg);
......
936 936
     * @throws NotFound
937 937
     * @throws NotImplemented
938 938
     * @throws IOException
939
     * @throws JiBXException
939
     * @throws MarshallingException
940 940
     */
941 941
    private void resolve(String id) throws InvalidRequest, InvalidToken,
942 942
            ServiceFailure, NotAuthorized, NotFound, NotImplemented,
943
            IOException, JiBXException {
943
            IOException, MarshallingException {
944 944
        Identifier pid = new Identifier();
945 945
        pid.setValue(id);
946 946
        ObjectLocationList locationList = CNodeService.getInstance(request)
......
1050 1050
            logMetacat.debug(msg);
1051 1051
            throw new ServiceFailure("4490", msg);
1052 1052
        
1053
        } catch (JiBXException e) {
1053
        } catch (MarshallingException e) {
1054 1054
            String msg = "Couldn't marshall the identifier to the response output stream: " +
1055 1055
            e.getMessage();
1056 1056
            logMetacat.debug(msg);
......
1089 1089
     * 
1090 1090
     * @param pid
1091 1091
     *            identifier for System Metadata entry
1092
     * @throws JiBXException
1092
     * @throws MarshallingException
1093 1093
     * @throws FileUploadException
1094 1094
     * @throws IOException
1095 1095
     * @throws InvalidRequest
......
1103 1103
     */
1104 1104
    protected void registerSystemMetadata()
1105 1105
            throws ServiceFailure, InvalidRequest, IOException,
1106
            FileUploadException, JiBXException, NotImplemented, NotAuthorized,
1106
            FileUploadException, MarshallingException, NotImplemented, NotAuthorized,
1107 1107
            InvalidSystemMetadata, InstantiationException,
1108 1108
            IllegalAccessException, InvalidToken {
1109 1109
    	
......
1136 1136
    /**
1137 1137
     * set the access perms on a document
1138 1138
     * 
1139
     * @throws JiBXException
1139
     * @throws MarshallingException
1140 1140
     * @throws InvalidRequest
1141 1141
     * @throws NotImplemented
1142 1142
     * @throws NotAuthorized
......
1150 1150
     * @throws ParserConfigurationException
1151 1151
     * @throws VersionMismatch 
1152 1152
     */
1153
    protected void setAccess(String pid) throws JiBXException, InvalidToken,
1153
    protected void setAccess(String pid) throws MarshallingException, InvalidToken,
1154 1154
            ServiceFailure, NotFound, NotAuthorized, NotImplemented,
1155 1155
            InvalidRequest, IOException, InstantiationException,
1156 1156
            IllegalAccessException, ParserConfigurationException, SAXException, VersionMismatch {
......
1197 1197
     * @throws InvalidToken
1198 1198
     * @throws NotFound
1199 1199
     * @throws IOException
1200
     * @throws JiBXException
1200
     * @throws MarshallingException
1201 1201
     * @throws Exception
1202 1202
     */
1203 1203
    private void listObjects() throws InvalidToken, ServiceFailure,
1204 1204
            NotAuthorized, InvalidRequest, NotImplemented, NotFound,
1205
            IOException, JiBXException {
1205
            IOException, MarshallingException {
1206 1206

  
1207 1207
        Date startTime = null;
1208 1208
        Date endTime = null;
......
1337 1337
     * @throws IOException
1338 1338
     * @throws InstantiationException
1339 1339
     * @throws IllegalAccessException
1340
     * @throws JiBXException
1340
     * @throws MarshallingException
1341 1341
     * @throws VersionMismatch 
1342 1342
     */
1343 1343
    public boolean setReplicationPolicy(String pid) throws NotImplemented,
1344 1344
            NotFound, NotAuthorized, ServiceFailure, InvalidRequest,
1345 1345
            InvalidToken, IOException, InstantiationException,
1346
            IllegalAccessException, JiBXException, VersionMismatch {
1346
            IllegalAccessException, MarshallingException, VersionMismatch {
1347 1347

  
1348 1348
        boolean result = false;
1349 1349
        long serialVersion = 0L;
......
1569 1569
     * @throws NotAuthorized
1570 1570
     * @throws InvalidRequest
1571 1571
     * @throws NotFound
1572
     * @throws JiBXException 
1572
     * @throws MarshallingException 
1573 1573
     * @throws IllegalAccessException 
1574 1574
     * @throws InstantiationException 
1575 1575
     * @throws IOException 
......
1675 1675
     * @throws InvalidRequest
1676 1676
     * @throws NotFound
1677 1677
     * @throws VersionMismatch 
1678
     * @throws JiBXException 
1678
     * @throws MarshallingException 
1679 1679
     * @throws IOException 
1680 1680
     * @throws IllegalAccessException 
1681 1681
     * @throws InstantiationException 
1682 1682
     */
1683 1683
    public boolean updateReplicationMetadata(String pid) throws ServiceFailure,
1684 1684
            NotImplemented, InvalidToken, NotAuthorized, InvalidRequest,
1685
            NotFound, VersionMismatch, InstantiationException, IllegalAccessException, IOException, JiBXException {
1685
            NotFound, VersionMismatch, InstantiationException, IllegalAccessException, IOException, MarshallingException {
1686 1686

  
1687 1687
        boolean result = false;
1688 1688
        long serialVersion = 0L;
src/edu/ucsb/nceas/metacat/restservice/v1/MNResourceHandler.java
42 42
import org.apache.commons.io.IOUtils;
43 43
import org.apache.log4j.Logger;
44 44
import org.dataone.client.v2.formats.ObjectFormatInfo;
45
import org.dataone.exceptions.MarshallingException;
45 46
import org.dataone.mimemultipart.MultipartRequest;
46 47
import org.dataone.mimemultipart.MultipartRequestResolver;
47 48
import org.dataone.portal.TokenGenerator;
......
75 76
import org.dataone.service.util.DateTimeMarshaller;
76 77
import org.dataone.service.util.ExceptionHandler;
77 78
import org.dataone.service.util.TypeMarshaller;
78
import org.jibx.runtime.JiBXException;
79 79
import org.xml.sax.SAXException;
80 80

  
81 81
import edu.ucsb.nceas.metacat.common.query.stream.ContentTypeInputStream;
......
712 712
     * @throws ServiceFailure 
713 713
     * @throws InvalidToken 
714 714
     * @throws IOException 
715
     * @throws JiBXException 
715
     * @throws MarshallingException 
716 716
     */
717
    private void generateIdentifier() throws InvalidToken, ServiceFailure, NotAuthorized, NotImplemented, InvalidRequest, IOException, JiBXException {
717
    private void generateIdentifier() throws InvalidToken, ServiceFailure, NotAuthorized, NotImplemented, InvalidRequest, IOException, MarshallingException {
718 718
        
719 719
        // make sure we have the multipart params
720 720
        try {
......
782 782
     * @throws ServiceFailure
783 783
     * @throws NotAuthorized
784 784
     * @throws InvalidRequest
785
     * @throws JiBXException
785
     * @throws MarshallingException
786 786
     * @throws IllegalAccessException 
787 787
     * @throws InstantiationException 
788 788
     * @throws IOException 
789 789
     * @throws InvalidToken 
790 790
     */
791
    private void syncError() throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, JiBXException, IOException, InstantiationException, IllegalAccessException, InvalidToken {
791
    private void syncError() throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, MarshallingException, IOException, InstantiationException, IllegalAccessException, InvalidToken {
792 792
    	SynchronizationFailed syncFailed = null;
793 793
		try {
794 794
			syncFailed = collectSynchronizationFailed();
......
804 804
	/**
805 805
     * Calculate the checksum 
806 806
     * @throws NotImplemented
807
     * @throws JiBXException
807
     * @throws MarshallingException
808 808
     * @throws IOException
809 809
     * @throws InvalidToken
810 810
     * @throws ServiceFailure
......
812 812
     * @throws NotFound
813 813
     * @throws InvalidRequest
814 814
     */
815
    private void checksum(String pid) throws NotImplemented, JiBXException, IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest {
815
    private void checksum(String pid) throws NotImplemented, MarshallingException, IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest {
816 816
    	String checksumAlgorithm = "MD5";
817 817
    	try {
818 818
    		checksumAlgorithm = PropertyService.getProperty("dataone.checksumAlgorithm.default");
......
841 841
    
842 842
	/**
843 843
     * handle the replicate action for MN
844
	 * @throws JiBXException 
844
	 * @throws MarshallingException 
845 845
	 * @throws FileUploadException 
846 846
	 * @throws IOException 
847 847
	 * @throws InvalidRequest 
......
856 856
     */
857 857
    private void replicate() 
858 858
        throws ServiceFailure, InvalidRequest, IOException, FileUploadException, 
859
        JiBXException, NotImplemented, NotAuthorized, InsufficientResources, 
859
        MarshallingException, NotImplemented, NotAuthorized, InsufficientResources, 
860 860
        UnsupportedType, InstantiationException, IllegalAccessException, InvalidToken {
861 861

  
862 862
        logMetacat.debug("in POST replicate()");
......
952 952
    /**
953 953
     * Get the Node information
954 954
     * 
955
     * @throws JiBXException
955
     * @throws MarshallingException
956 956
     * @throws IOException
957 957
     * @throws InvalidRequest 
958 958
     * @throws ServiceFailure 
......
960 960
     * @throws NotImplemented 
961 961
     */
962 962
    private void node() 
963
        throws JiBXException, IOException, NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest {
963
        throws MarshallingException, IOException, NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest {
964 964
        
965 965
        Node n = MNodeService.getInstance(request).getCapabilities();
966 966
        
......
1023 1023
     * @throws ServiceFailure 
1024 1024
     * @throws InvalidToken 
1025 1025
     * @throws IOException 
1026
     * @throws JiBXException 
1026
     * @throws MarshallingException 
1027 1027
     */
1028
    private void getLog() throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented, IOException, JiBXException
1028
    private void getLog() throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented, IOException, MarshallingException
1029 1029
    {
1030 1030
            
1031 1031
        Date fromDate = null;
......
1097 1097
     * @throws ServiceFailure 
1098 1098
     * @throws InvalidToken 
1099 1099
     * @throws IOException 
1100
     * @throws JiBXException 
1100
     * @throws MarshallingException 
1101 1101
     * @throws InsufficientResources 
1102 1102
     */
1103
    protected void getObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, JiBXException, InsufficientResources {
1103
    protected void getObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, MarshallingException, InsufficientResources {
1104 1104
        OutputStream out = null;
1105 1105
        
1106 1106
        if (pid != null) { //get a specific document                
......
1245 1245
    
1246 1246
	protected void publish(String pid) throws InvalidToken, ServiceFailure,
1247 1247
			NotAuthorized, NotFound, NotImplemented, IOException,
1248
			JiBXException, InvalidRequest, IdentifierNotUnique,
1248
			MarshallingException, InvalidRequest, IdentifierNotUnique,
1249 1249
			UnsupportedType, InsufficientResources, InvalidSystemMetadata {
1250 1250

  
1251 1251
		// publish the object
......
1271 1271
     * @throws InvalidRequest
1272 1272
     * @throws NotImplemented
1273 1273
     * @throws IOException
1274
     * @throws JiBXException
1274
     * @throws MarshallingException
1275 1275
     */
1276
    protected void getSystemMetadataObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, JiBXException {
1276
    protected void getSystemMetadataObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, MarshallingException {
1277 1277

  
1278 1278
        Identifier id = new Identifier();
1279 1279
        id.setValue(pid);
......
1295 1295
     *               is the existing pid.  If insert, the pid is the new one
1296 1296
     * @throws InvalidRequest 
1297 1297
     * @throws ServiceFailure 
1298
     * @throws JiBXException 
1298
     * @throws MarshallingException 
1299 1299
     * @throws NotImplemented 
1300 1300
     * @throws InvalidSystemMetadata 
1301 1301
     * @throws InsufficientResources 
......
1308 1308
     * @throws IllegalAccessException 
1309 1309
     * @throws InstantiationException 
1310 1310
     */
1311
    protected void putObject(String trailingPid, String action) throws ServiceFailure, InvalidRequest, JiBXException, InvalidToken, NotAuthorized, IdentifierNotUnique, UnsupportedType, InsufficientResources, InvalidSystemMetadata, NotImplemented, NotFound, IOException, InstantiationException, IllegalAccessException {
1311
    protected void putObject(String trailingPid, String action) throws ServiceFailure, InvalidRequest, MarshallingException, InvalidToken, NotAuthorized, IdentifierNotUnique, UnsupportedType, InsufficientResources, InvalidSystemMetadata, NotImplemented, NotFound, IOException, InstantiationException, IllegalAccessException {
1312 1312
       
1313 1313
    	// Read the incoming data from its Mime Multipart encoding
1314 1314
    	Map<String, File> files = collectMultipartFiles();
......
1398 1398
     * @throws NotAuthorized 
1399 1399
     * @throws ServiceFailure 
1400 1400
     * @throws InvalidToken 
1401
     * @throws JiBXException 
1401
     * @throws MarshallingException 
1402 1402
     */
1403
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, JiBXException 
1403
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, MarshallingException 
1404 1404
    {
1405 1405

  
1406 1406
        OutputStream out = response.getOutputStream();
......
1425 1425
     * @throws NotFound
1426 1426
     * @throws NotImplemented
1427 1427
     * @throws IOException
1428
     * @throws JiBXException
1428
     * @throws MarshallingException
1429 1429
     */
1430
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, JiBXException {
1430
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, MarshallingException {
1431 1431

  
1432 1432
        OutputStream out = response.getOutputStream();
1433 1433
        response.setStatus(200);
......
1443 1443
        
1444 1444
    }
1445 1445

  
1446
	protected SynchronizationFailed collectSynchronizationFailed() throws IOException, ServiceFailure, InvalidRequest, JiBXException, InstantiationException, IllegalAccessException, ParserConfigurationException, SAXException  {
1446
	protected SynchronizationFailed collectSynchronizationFailed() throws IOException, ServiceFailure, InvalidRequest, MarshallingException, InstantiationException, IllegalAccessException, ParserConfigurationException, SAXException  {
1447 1447
		
1448 1448
		// Read the incoming data from its Mime Multipart encoding
1449 1449
		logMetacat.debug("Disassembling MIME multipart form");
src/edu/ucsb/nceas/metacat/restservice/v2/CNResourceHandler.java
41 41
import org.apache.commons.io.IOUtils;
42 42
import org.apache.log4j.Logger;
43 43
import org.dataone.client.v2.formats.ObjectFormatInfo;
44
import org.dataone.exceptions.MarshallingException;
44 45
import org.dataone.service.exceptions.BaseException;
45 46
import org.dataone.service.exceptions.IdentifierNotUnique;
46 47
import org.dataone.service.exceptions.InsufficientResources;
......
78 79
import org.dataone.service.util.EncodingUtilities;
79 80
import org.dataone.service.util.ExceptionHandler;
80 81
import org.dataone.service.util.TypeMarshaller;
81
import org.jibx.runtime.JiBXException;
82 82
import org.xml.sax.SAXException;
83 83

  
84 84
import edu.ucsb.nceas.metacat.common.query.stream.ContentTypeInputStream;
......
480 480
     * @throws ServiceFailure
481 481
     * @throws InvalidToken
482 482
     * @throws IOException
483
     * @throws JiBXException
483
     * @throws MarshallingException
484 484
     */
485 485
    private void checksum(String guid) throws InvalidToken, ServiceFailure,
486 486
            NotAuthorized, NotFound, InvalidRequest, NotImplemented,
487
            JiBXException, IOException {
487
            MarshallingException, IOException {
488 488
        Identifier guidid = new Identifier();
489 489
        guidid.setValue(guid);
490 490
        logMetacat.debug("getting checksum for object " + guid);
......
510 510
     * @throws ServiceFailure
511 511
     * @throws InvalidToken
512 512
     * @throws IOException
513
     * @throws JiBXException
513
     * @throws MarshallingException
514 514
     */
515 515
    private void getLog() throws InvalidToken, ServiceFailure, NotAuthorized,
516
            InvalidRequest, NotImplemented, IOException, JiBXException {
516
            InvalidRequest, NotImplemented, IOException, MarshallingException {
517 517

  
518 518
        Date fromDate = null;
519 519
        Date toDate = null;
......
628 628
     * @throws ServiceFailure
629 629
     * @throws InvalidToken
630 630
     * @throws IOException
631
     * @throws JiBXException
631
     * @throws MarshallingException
632 632
     */
633 633
    protected void getSystemMetadataObject(String guid) throws InvalidToken,
634 634
            ServiceFailure, NotAuthorized, NotFound, InvalidRequest,
635
            NotImplemented, IOException, JiBXException {
635
            NotImplemented, IOException, MarshallingException {
636 636

  
637 637
        Identifier id = new Identifier();
638 638
        id.setValue(guid);
......
658 658
     * @throws InvalidRequest
659 659
     * @throws ServiceFailure
660 660
     * @throws IdentifierNotUnique
661
     * @throws JiBXException
661
     * @throws MarshallingException
662 662
     * @throws NotImplemented
663 663
     * @throws InvalidSystemMetadata
664 664
     * @throws InsufficientResources
......
670 670
     * @throws InstantiationException
671 671
     */
672 672
    protected void putObject(String action) throws ServiceFailure,
673
            InvalidRequest, IdentifierNotUnique, JiBXException, InvalidToken,
673
            InvalidRequest, IdentifierNotUnique, MarshallingException, InvalidToken,
674 674
            NotAuthorized, UnsupportedType, InsufficientResources,
675 675
            InvalidSystemMetadata, NotImplemented, IOException,
676 676
            InstantiationException, IllegalAccessException {
......
723 723
     * @throws ServiceFailure
724 724
     * @throws InvalidRequest
725 725
     * @throws IOException
726
     * @throws JiBXException
726
     * @throws MarshallingException
727 727
     */
728 728
    private void listFormats() throws InvalidRequest, ServiceFailure, NotFound,
729
            InsufficientResources, NotImplemented, IOException, JiBXException {
729
            InsufficientResources, NotImplemented, IOException, MarshallingException {
730 730
        logMetacat.debug("Entering listFormats()");
731 731

  
732 732
        ObjectFormatList objectFormatList = CNodeService.getInstance(request)
......
751 751
    }
752 752
    
753 753
    private void listChecksumAlgorithms() throws IOException, ServiceFailure,
754
			NotImplemented, JiBXException {
754
			NotImplemented, MarshallingException {
755 755
		logMetacat.debug("Entering listFormats()");
756 756

  
757 757
		ChecksumAlgorithmList result = CNodeService.getInstance(request).listChecksumAlgorithms();
......
814 814
     * @throws NotAuthorized 
815 815
     * @throws ServiceFailure 
816 816
     * @throws InvalidToken 
817
     * @throws JiBXException 
817
     * @throws MarshallingException 
818 818
     */
819
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, JiBXException 
819
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, MarshallingException 
820 820
    {
821 821

  
822 822
        OutputStream out = response.getOutputStream();
......
841 841
     * @throws NotFound
842 842
     * @throws NotImplemented
843 843
     * @throws IOException
844
     * @throws JiBXException
844
     * @throws MarshallingException
845 845
     */
846
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, JiBXException {
846
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, MarshallingException {
847 847

  
848 848
        OutputStream out = response.getOutputStream();
849 849
        response.setStatus(200);
......
870 870
     * @throws ServiceFailure
871 871
     * @throws InvalidRequest
872 872
     * @throws IOException
873
     * @throws JiBXException
873
     * @throws MarshallingException
874 874
     */
875 875
    private void getFormat(String fmtidStr) throws InvalidRequest,
876 876
            ServiceFailure, NotFound, InsufficientResources, NotImplemented,
877
            IOException, JiBXException {
877
            IOException, MarshallingException {
878 878
        logMetacat.debug("Entering listFormats()");
879 879

  
880 880
        ObjectFormatIdentifier fmtid = new ObjectFormatIdentifier();
......
900 900
     * @throws NotImplemented 
901 901
     * @throws InvalidRequest 
902 902
     * @throws ServiceFailure 
903
     * @throws JiBXException 
903
     * @throws MarshallingException 
904 904
     * @throws IOException 
905 905
     * @throws IllegalAccessException 
906 906
     * @throws InstantiationException 
......
910 910
     */
911 911
    private void addFormat(String formatIdStr) 
912 912
            throws NotImplemented, ServiceFailure, InvalidRequest, InstantiationException, 
913
            IllegalAccessException, IOException, JiBXException, NotFound, NotAuthorized, InvalidToken {
913
            IllegalAccessException, IOException, MarshallingException, NotFound, NotAuthorized, InvalidToken {
914 914
        
915 915
        logMetacat.debug("addFormat: " + formatIdStr);
916 916
        
......
999 999
            logMetacat.debug(msg);
1000 1000
            throw new ServiceFailure("4210", msg);
1001 1001
        
1002
        } catch (JiBXException e) {
1002
        } catch (MarshallingException e) {
1003 1003
            String msg = "Couldn't marshall the identifier to the response output stream: " +
1004 1004
            e.getMessage();
1005 1005
            logMetacat.debug(msg);
......
1018 1018
     * @throws NotFound
1019 1019
     * @throws NotImplemented
1020 1020
     * @throws IOException
1021
     * @throws JiBXException
1021
     * @throws MarshallingException
1022 1022
     */
1023 1023
    private void resolve(String id) throws InvalidRequest, InvalidToken,
1024 1024
            ServiceFailure, NotAuthorized, NotFound, NotImplemented,
1025
            IOException, JiBXException {
1025
            IOException, MarshallingException {
1026 1026
        Identifier pid = new Identifier();
1027 1027
        pid.setValue(id);
1028 1028
        ObjectLocationList locationList = CNodeService.getInstance(request)
......
1132 1132
            logMetacat.debug(msg);
1133 1133
            throw new ServiceFailure("4490", msg);
1134 1134
        
1135
        } catch (JiBXException e) {
1135
        } catch (MarshallingException e) {
1136 1136
            String msg = "Couldn't marshall the identifier to the response output stream: " +
1137 1137
            e.getMessage();
1138 1138
            logMetacat.debug(msg);
......
1171 1171
     * 
1172 1172
     * @param pid
1173 1173
     *            identifier for System Metadata entry
1174
     * @throws JiBXException
1174
     * @throws MarshallingException
1175 1175
     * @throws FileUploadException
1176 1176
     * @throws IOException
1177 1177
     * @throws InvalidRequest
......
1184 1184
     */
1185 1185
    protected void registerSystemMetadata()
1186 1186
            throws ServiceFailure, InvalidRequest, IOException,
1187
            FileUploadException, JiBXException, NotImplemented, NotAuthorized,
1187
            FileUploadException, MarshallingException, NotImplemented, NotAuthorized,
1188 1188
            InvalidSystemMetadata, InstantiationException,
1189 1189
            IllegalAccessException {
1190 1190
    	
......
1217 1217
    /**
1218 1218
     * set the access perms on a document
1219 1219
     * 
1220
     * @throws JiBXException
1220
     * @throws MarshallingException
1221 1221
     * @throws InvalidRequest
1222 1222
     * @throws NotImplemented
1223 1223
     * @throws NotAuthorized
......
1231 1231
     * @throws ParserConfigurationException
1232 1232
     * @throws VersionMismatch 
1233 1233
     */
1234
    protected void setAccess(String pid) throws JiBXException, InvalidToken,
1234
    protected void setAccess(String pid) throws MarshallingException, InvalidToken,
1235 1235
            ServiceFailure, NotFound, NotAuthorized, NotImplemented,
1236 1236
            InvalidRequest, IOException, InstantiationException,
1237 1237
            IllegalAccessException, ParserConfigurationException, SAXException, VersionMismatch {
......
1278 1278
     * @throws InvalidToken
1279 1279
     * @throws NotFound
1280 1280
     * @throws IOException
1281
     * @throws JiBXException
1281
     * @throws MarshallingException
1282 1282
     * @throws Exception
1283 1283
     */
1284 1284
    private void listObjects() throws InvalidToken, ServiceFailure,
1285 1285
            NotAuthorized, InvalidRequest, NotImplemented, NotFound,
1286
            IOException, JiBXException {
1286
            IOException, MarshallingException {
1287 1287

  
1288 1288
        Date startTime = null;
1289 1289
        Date endTime = null;
......
1427 1427
     * @throws IOException
1428 1428
     * @throws InstantiationException
1429 1429
     * @throws IllegalAccessException
1430
     * @throws JiBXException
1430
     * @throws MarshallingException
1431 1431
     * @throws VersionMismatch 
1432 1432
     */
1433 1433
    public boolean setReplicationPolicy(String pid) throws NotImplemented,
1434 1434
            NotFound, NotAuthorized, ServiceFailure, InvalidRequest,
1435 1435
            InvalidToken, IOException, InstantiationException,
1436
            IllegalAccessException, JiBXException, VersionMismatch {
1436
            IllegalAccessException, MarshallingException, VersionMismatch {
1437 1437

  
1438 1438
        boolean result = false;
1439 1439
        long serialVersion = 0L;
......
1659 1659
     * @throws NotAuthorized
1660 1660
     * @throws InvalidRequest
1661 1661
     * @throws NotFound
1662
     * @throws JiBXException 
1662
     * @throws MarshallingException 
1663 1663
     * @throws IllegalAccessException 
1664 1664
     * @throws InstantiationException 
1665 1665
     * @throws IOException 
......
1765 1765
     * @throws InvalidRequest
1766 1766
     * @throws NotFound
1767 1767
     * @throws VersionMismatch 
1768
     * @throws JiBXException 
1768
     * @throws MarshallingException 
1769 1769
     * @throws IOException 
1770 1770
     * @throws IllegalAccessException 
1771 1771
     * @throws InstantiationException 
1772 1772
     */
1773 1773
    public boolean updateReplicationMetadata(String pid) throws ServiceFailure,
1774 1774
            NotImplemented, InvalidToken, NotAuthorized, InvalidRequest,
1775
            NotFound, VersionMismatch, InstantiationException, IllegalAccessException, IOException, JiBXException {
1775
            NotFound, VersionMismatch, InstantiationException, IllegalAccessException, IOException, MarshallingException {
1776 1776

  
1777 1777
        boolean result = false;
1778 1778
        long serialVersion = 0L;
......
1811 1811
     * @throws InstantiationException
1812 1812
     * @throws IllegalAccessException
1813 1813
     * @throws IOException
1814
     * @throws JiBXException
1814
     * @throws MarshallingException
1815 1815
     * @throws NotImplemented
1816 1816
     * @throws NotAuthorized
1817 1817
     * @throws InvalidSystemMetadata
1818 1818
     * @throws InvalidToken
1819 1819
     */
1820 1820
    protected void updateSystemMetadata() throws ServiceFailure, InvalidRequest, InstantiationException, 
1821
                        IllegalAccessException, IOException, JiBXException, NotImplemented, NotAuthorized, InvalidSystemMetadata, InvalidToken {
1821
                        IllegalAccessException, IOException, MarshallingException, NotImplemented, NotAuthorized, InvalidSystemMetadata, InvalidToken {
1822 1822
        // Read the incoming data from its Mime Multipart encoding
1823 1823
        Map<String, File> files = collectMultipartFiles();
1824 1824
        
src/edu/ucsb/nceas/metacat/restservice/v2/MNResourceHandler.java
45 45
import org.apache.log4j.Logger;
46 46
import org.dataone.client.v2.formats.ObjectFormatCache;
47 47
import org.dataone.client.v2.formats.ObjectFormatInfo;
48
import org.dataone.exceptions.MarshallingException;
48 49
import org.dataone.mimemultipart.MultipartRequest;
49 50
import org.dataone.mimemultipart.MultipartRequestResolver;
50 51
import org.dataone.portal.TokenGenerator;
......
83 84
import org.dataone.service.util.DateTimeMarshaller;
84 85
import org.dataone.service.util.ExceptionHandler;
85 86
import org.dataone.service.util.TypeMarshaller;
86
import org.jibx.runtime.JiBXException;
87 87
import org.xml.sax.SAXException;
88 88

  
89 89
import edu.ucsb.nceas.metacat.MetaCatServlet;
......
764 764
     * @throws ServiceFailure 
765 765
     * @throws InvalidToken 
766 766
     * @throws IOException 
767
     * @throws JiBXException 
767
     * @throws MarshallingException 
768 768
     */
769
    private void generateIdentifier() throws InvalidToken, ServiceFailure, NotAuthorized, NotImplemented, InvalidRequest, IOException, JiBXException {
769
    private void generateIdentifier() throws InvalidToken, ServiceFailure, NotAuthorized, NotImplemented, InvalidRequest, IOException, MarshallingException {
770 770
        
771 771
        // make sure we have the multipart params
772 772
        try {
......
896 896
     * @throws ServiceFailure
897 897
     * @throws NotAuthorized
898 898
     * @throws InvalidRequest
899
     * @throws JiBXException
899
     * @throws MarshallingException
900 900
     * @throws IllegalAccessException 
901 901
     * @throws InstantiationException 
902 902
     * @throws IOException 
903 903
     */
904
    private void syncError() throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, JiBXException, IOException, InstantiationException, IllegalAccessException {
904
    private void syncError() throws NotImplemented, ServiceFailure, NotAuthorized, InvalidRequest, MarshallingException, IOException, InstantiationException, IllegalAccessException {
905 905
    	SynchronizationFailed syncFailed = null;
906 906
		try {
907 907
			syncFailed = collectSynchronizationFailed();
......
917 917
	/**
918 918
     * Calculate the checksum 
919 919
     * @throws NotImplemented
920
     * @throws JiBXException
920
     * @throws MarshallingException
921 921
     * @throws IOException
922 922
     * @throws InvalidToken
923 923
     * @throws ServiceFailure
......
925 925
     * @throws NotFound
926 926
     * @throws InvalidRequest
927 927
     */
928
    private void checksum(String pid) throws NotImplemented, JiBXException, IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest {
928
    private void checksum(String pid) throws NotImplemented, MarshallingException, IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest {
929 929
    	String checksumAlgorithm = "MD5";
930 930
    	try {
931 931
    		checksumAlgorithm = PropertyService.getProperty("dataone.checksumAlgorithm.default");
......
954 954
    
955 955
	/**
956 956
     * handle the replicate action for MN
957
	 * @throws JiBXException 
957
	 * @throws MarshallingException 
958 958
	 * @throws FileUploadException 
959 959
	 * @throws IOException 
960 960
	 * @throws InvalidRequest 
......
969 969
     */
970 970
    private void replicate() 
971 971
        throws ServiceFailure, InvalidRequest, IOException, FileUploadException, 
972
        JiBXException, NotImplemented, NotAuthorized, InsufficientResources, 
972
        MarshallingException, NotImplemented, NotAuthorized, InsufficientResources, 
973 973
        UnsupportedType, InstantiationException, IllegalAccessException, InvalidToken {
974 974

  
975 975
        logMetacat.debug("in POST replicate()");
......
1064 1064
    /**
1065 1065
     * Get the Node information
1066 1066
     * 
1067
     * @throws JiBXException
1067
     * @throws MarshallingException
1068 1068
     * @throws IOException
1069 1069
     * @throws InvalidRequest 
1070 1070
     * @throws ServiceFailure 
......
1072 1072
     * @throws NotImplemented 
1073 1073
     */
1074 1074
    private void node() 
1075
        throws JiBXException, IOException, NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest {
1075
        throws MarshallingException, IOException, NotImplemented, NotAuthorized, ServiceFailure, InvalidRequest {
1076 1076
        
1077 1077
        Node n = MNodeService.getInstance(request).getCapabilities();
1078 1078
        
......
1135 1135
     * @throws ServiceFailure 
1136 1136
     * @throws InvalidToken 
1137 1137
     * @throws IOException 
1138
     * @throws JiBXException 
1138
     * @throws MarshallingException 
1139 1139
     */
1140
    private void getLog() throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented, IOException, JiBXException
1140
    private void getLog() throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented, IOException, MarshallingException
1141 1141
    {
1142 1142
            
1143 1143
        Date fromDate = null;
......
1208 1208
     * @throws ServiceFailure 
1209 1209
     * @throws InvalidToken 
1210 1210
     * @throws IOException 
1211
     * @throws JiBXException 
1211
     * @throws MarshallingException 
1212 1212
     */
1213
    protected void getObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, JiBXException {
1213
    protected void getObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, MarshallingException {
1214 1214
        OutputStream out = null;
1215 1215
        
1216 1216
        if (pid != null) { //get a specific document                
......
1417 1417
    
1418 1418
	protected void publish(String pid) throws InvalidToken, ServiceFailure,
1419 1419
			NotAuthorized, NotFound, NotImplemented, IOException,
1420
			JiBXException, InvalidRequest, IdentifierNotUnique,
1420
			MarshallingException, InvalidRequest, IdentifierNotUnique,
1421 1421
			UnsupportedType, InsufficientResources, InvalidSystemMetadata {
1422 1422

  
1423 1423
		// publish the object
......
1443 1443
     * @throws InvalidRequest
1444 1444
     * @throws NotImplemented
1445 1445
     * @throws IOException
1446
     * @throws JiBXException
1446
     * @throws MarshallingException
1447 1447
     */
1448
    protected void getSystemMetadataObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, JiBXException {
1448
    protected void getSystemMetadataObject(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, InvalidRequest, NotImplemented, IOException, MarshallingException {
1449 1449

  
1450 1450
        Identifier id = new Identifier();
1451 1451
        id.setValue(pid);
......
1467 1467
     *               is the existing pid.  If insert, the pid is the new one
1468 1468
     * @throws InvalidRequest 
1469 1469
     * @throws ServiceFailure 
1470
     * @throws JiBXException 
1470
     * @throws MarshallingException 
1471 1471
     * @throws NotImplemented 
1472 1472
     * @throws InvalidSystemMetadata 
1473 1473
     * @throws InsufficientResources 
......
1480 1480
     * @throws IllegalAccessException 
1481 1481
     * @throws InstantiationException 
1482 1482
     */
1483
    protected void putObject(String trailingPid, String action) throws ServiceFailure, InvalidRequest, JiBXException, InvalidToken, NotAuthorized, IdentifierNotUnique, UnsupportedType, InsufficientResources, InvalidSystemMetadata, NotImplemented, NotFound, IOException, InstantiationException, IllegalAccessException {
1483
    protected void putObject(String trailingPid, String action) throws ServiceFailure, InvalidRequest, MarshallingException, InvalidToken, NotAuthorized, IdentifierNotUnique, UnsupportedType, InsufficientResources, InvalidSystemMetadata, NotImplemented, NotFound, IOException, InstantiationException, IllegalAccessException {
1484 1484
       
1485 1485
    	// Read the incoming data from its Mime Multipart encoding
1486 1486
    	Map<String, File> files = collectMultipartFiles();
......
1570 1570
     * @throws NotAuthorized 
1571 1571
     * @throws ServiceFailure 
1572 1572
     * @throws InvalidToken 
1573
     * @throws JiBXException 
1573
     * @throws MarshallingException 
1574 1574
     */
1575
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, JiBXException 
1575
    private void deleteObject(String pid) throws IOException, InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, InvalidRequest, MarshallingException 
1576 1576
    {
1577 1577

  
1578 1578
        OutputStream out = response.getOutputStream();
......
1597 1597
     * @throws NotFound
1598 1598
     * @throws NotImplemented
1599 1599
     * @throws IOException
1600
     * @throws JiBXException
1600
     * @throws MarshallingException
1601 1601
     */
1602
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, JiBXException {
1602
    private void archive(String pid) throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, NotImplemented, IOException, MarshallingException {
1603 1603

  
1604 1604
        OutputStream out = response.getOutputStream();
1605 1605
        response.setStatus(200);
......
1615 1615
        
1616 1616
    }
1617 1617

  
1618
	protected SynchronizationFailed collectSynchronizationFailed() throws IOException, ServiceFailure, InvalidRequest, JiBXException, InstantiationException, IllegalAccessException, ParserConfigurationException, SAXException  {
1618
	protected SynchronizationFailed collectSynchronizationFailed() throws IOException, ServiceFailure, InvalidRequest, MarshallingException, InstantiationException, IllegalAccessException, ParserConfigurationException, SAXException  {
1619 1619
		
1620 1620
		// Read the incoming data from its Mime Multipart encoding
1621 1621
		logMetacat.debug("Disassembling MIME multipart form");
......
1662 1662
	 * @throws InstantiationException
1663 1663
	 * @throws IllegalAccessException
1664 1664
	 * @throws IOException
1665
	 * @throws JiBXException
1665
	 * @throws MarshallingException
1666 1666
	 * @throws NotImplemented
1667 1667
	 * @throws NotAuthorized
1668 1668
	 * @throws InvalidSystemMetadata
1669 1669
	 * @throws InvalidToken
1670 1670
	 */
1671 1671
	protected void updateSystemMetadata() throws ServiceFailure, InvalidRequest, 
1672
	                        InstantiationException, IllegalAccessException, IOException, JiBXException, NotImplemented, 
1672
	                        InstantiationException, IllegalAccessException, IOException, MarshallingException, NotImplemented, 
1673 1673
	                        NotAuthorized, InvalidSystemMetadata, InvalidToken {
1674 1674
	    // Read the incoming data from its Mime Multipart encoding
1675 1675
        Map<String, File> files = collectMultipartFiles();

Also available in: Unified diff