Coverage Report

Coverage Report - org.apache.maven.wagon.observers.ChecksumObserver

Classes in this File

Line Coverage

Branch Coverage

Complexity

ChecksumObserver

93 %

27/29

75 %

6/8

1,5

 package org.apache.maven.wagon.observers;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import org.apache.maven.wagon.events.TransferEvent;
 import org.apache.maven.wagon.events.TransferListener;
 
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 
 /**
  * TransferListeners which computes MD5 checksum on the fly when files are transfered.
  *
  * @author <a href="michal.maczka@dimatics.com">Michal Maczka</a>
  * @version $Id: ChecksumObserver.java 1173669 2011-09-21 14:25:26Z olamy $
  */
 public class ChecksumObserver
     implements TransferListener
 {
     private MessageDigest digester = null;
 
     private String actualChecksum;
 
     public ChecksumObserver()
         throws NoSuchAlgorithmException
     {
         this( "MD5" );
     }
 
     /**
      * @param algorithm One of the algorithms supported by JDK: MD5, MD2 or SHA-1
      */
     public ChecksumObserver( String algorithm )
         throws NoSuchAlgorithmException
     {
         digester = MessageDigest.getInstance( algorithm );
     }
 
     public void transferInitiated( TransferEvent transferEvent )
     {
         // This space left intentionally blank
     }
 
     /**
      * @see org.apache.maven.wagon.events.TransferListener#transferStarted(org.apache.maven.wagon.events.TransferEvent)
      */
     public void transferStarted( TransferEvent transferEvent )
     {
         actualChecksum = null;
 
         digester.reset();
     }
 
     /**
      * @see org.apache.maven.wagon.events.TransferListener#transferProgress(org.apache.maven.wagon.events.TransferEvent, byte[], int)
      */
     public void transferProgress( TransferEvent transferEvent, byte[] buffer, int length )
     {
         digester.update( buffer, 0, length );
     }
 
     public void transferCompleted( TransferEvent transferEvent )
     {
         actualChecksum = encode( digester.digest() );
     }
 
     public void transferError( TransferEvent transferEvent )
     {
         digester.reset();
 
         actualChecksum = null;
     }
 
     public void debug( String message )
     {
         // left intentionally blank
     }
 
     /**
      * Returns md5 checksum which was computed during transfer
      *
      * @return
      */
     public String getActualChecksum()
     {
         return actualChecksum;
     }
 
     /**
      * Encodes a 128 bit or 160-bit byte array into a String.
      *
      * @param binaryData Array containing the digest
      * @return Encoded hex string, or null if encoding failed
      */
     protected String encode( byte[] binaryData )
     {
         if ( binaryData.length != 16 && binaryData.length != 20 )
         {
             int bitLength = binaryData.length * 8;
             throw new IllegalArgumentException( "Unrecognised length for binary data: " + bitLength + " bits" );
         }
 
         StringBuilder retValue = new StringBuilder();
 
         for ( int i = 0; i < binaryData.length; i++ )
         {
             String t = Integer.toHexString( binaryData[i] & 0xff );
 
             if ( t.length() == 1 )
             {
                 retValue.append( '0' ).append( t );
             }
             else
             {
                 retValue.append( t );
             }
         }
 
         return retValue.toString().trim();
     }
 
 
 }

1		package org.apache.maven.wagon.observers;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import org.apache.maven.wagon.events.TransferEvent;
23		import org.apache.maven.wagon.events.TransferListener;
24
25		import java.security.MessageDigest;
26		import java.security.NoSuchAlgorithmException;
27
28		/**
29		* TransferListeners which computes MD5 checksum on the fly when files are transfered.
30		*
31		* @author <a href="michal.maczka@dimatics.com">Michal Maczka</a>
32		* @version $Id: ChecksumObserver.java 1173669 2011-09-21 14:25:26Z olamy $
33		*/
34		public class ChecksumObserver
35		implements TransferListener
36		{
37	2	private MessageDigest digester = null;
38
39		private String actualChecksum;
40
41		public ChecksumObserver()
42		throws NoSuchAlgorithmException
43		{
44	1	this( "MD5" );
45	1	}
46
47		/**
48		* @param algorithm One of the algorithms supported by JDK: MD5, MD2 or SHA-1
49		*/
50		public ChecksumObserver( String algorithm )
51		throws NoSuchAlgorithmException
52	2	{
53	2	digester = MessageDigest.getInstance( algorithm );
54	2	}
55
56		public void transferInitiated( TransferEvent transferEvent )
57		{
58		// This space left intentionally blank
59	3	}
60
61		/**
62		* @see org.apache.maven.wagon.events.TransferListener#transferStarted(org.apache.maven.wagon.events.TransferEvent)
63		*/
64		public void transferStarted( TransferEvent transferEvent )
65		{
66	3	actualChecksum = null;
67
68	3	digester.reset();
69	3	}
70
71		/**
72		* @see org.apache.maven.wagon.events.TransferListener#transferProgress(org.apache.maven.wagon.events.TransferEvent, byte[], int)
73		*/
74		public void transferProgress( TransferEvent transferEvent, byte[] buffer, int length )
75		{
76	1	digester.update( buffer, 0, length );
77	1	}
78
79		public void transferCompleted( TransferEvent transferEvent )
80		{
81	1	actualChecksum = encode( digester.digest() );
82	1	}
83
84		public void transferError( TransferEvent transferEvent )
85		{
86	2	digester.reset();
87
88	2	actualChecksum = null;
89	2	}
90
91		public void debug( String message )
92		{
93		// left intentionally blank
94	2	}
95
96		/**
97		* Returns md5 checksum which was computed during transfer
98		*
99		* @return
100		*/
101		public String getActualChecksum()
102		{
103	1	return actualChecksum;
104		}
105
106		/**
107		* Encodes a 128 bit or 160-bit byte array into a String.
108		*
109		* @param binaryData Array containing the digest
110		* @return Encoded hex string, or null if encoding failed
111		*/
112		protected String encode( byte[] binaryData )
113		{
114	1	if ( binaryData.length != 16 && binaryData.length != 20 )
115		{
116	0	int bitLength = binaryData.length * 8;
117	0	throw new IllegalArgumentException( "Unrecognised length for binary data: " + bitLength + " bits" );
118		}
119
120	1	StringBuilder retValue = new StringBuilder();
121
122	21	for ( int i = 0; i < binaryData.length; i++ )
123		{
124	20	String t = Integer.toHexString( binaryData[i] & 0xff );
125
126	20	if ( t.length() == 1 )
127		{
128	3	retValue.append( '0' ).append( t );
129		}
130		else
131		{
132	17	retValue.append( t );
133		}
134		}
135
136	1	return retValue.toString().trim();
137		}
138
139
140		}