| /** |
| * 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. |
| */ |
| |
| package org.apache.maven.mercury.spi.http.client.retrieve; |
| |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.apache.maven.mercury.crypto.api.StreamObserver; |
| import org.apache.maven.mercury.crypto.api.StreamVerifier; |
| import org.apache.maven.mercury.crypto.api.StreamVerifierException; |
| import org.apache.maven.mercury.logging.IMercuryLogger; |
| import org.apache.maven.mercury.logging.MercuryLoggerManager; |
| import org.apache.maven.mercury.spi.http.client.FileExchange; |
| import org.apache.maven.mercury.spi.http.client.HttpClientException; |
| import org.apache.maven.mercury.spi.http.client.HttpServletResponse; |
| import org.apache.maven.mercury.spi.http.client.SecureSender; |
| import org.apache.maven.mercury.spi.http.validate.Validator; |
| import org.apache.maven.mercury.transport.api.Binding; |
| import org.apache.maven.mercury.transport.api.Server; |
| import org.mortbay.jetty.HttpHeaders; |
| import org.mortbay.jetty.client.HttpExchange; |
| |
| |
| |
| /** |
| * RetrievalTarget |
| * <p/> |
| * A RetrievalTarget is a remote file that must be downloaded locally, checksummed |
| * and then atomically moved to its final location. The RetrievalTarget encapsulates |
| * the temporary local file to which the remote file is downloaded, and also the |
| * retrieval of the checksum file(s) and the checksum calculation(s). |
| */ |
| public abstract class RetrievalTarget |
| { |
| private static final IMercuryLogger log = MercuryLoggerManager.getLogger( RetrievalTarget.class ); |
| public static final String __PREFIX = "JTY_"; |
| public static final String __TEMP_SUFFIX = ".tmp"; |
| public static final int __START_STATE = 1; |
| public static final int __REQUESTED_STATE = 2; |
| public static final int __READY_STATE = 3; |
| |
| protected int _checksumState; |
| protected int _targetState; |
| |
| protected Server _server; |
| protected HttpClientException _exception; |
| protected Binding _binding; |
| protected File _tempFile; |
| protected DefaultRetriever _retriever; |
| protected boolean _complete; |
| protected HttpExchange _exchange; |
| protected Set<Validator> _validators; |
| protected Set<StreamObserver> _observers = new HashSet<StreamObserver>(); |
| protected List<StreamVerifier> _verifiers = new ArrayList<StreamVerifier>(); |
| protected Map<StreamVerifier, String> _verifierMap = new HashMap<StreamVerifier, String>(); |
| |
| |
| public abstract void onComplete(); |
| |
| public abstract void onError( HttpClientException exception ); |
| |
| /** |
| * Constructor |
| * |
| * @param binding |
| * @param callback |
| */ |
| public RetrievalTarget( Server server, DefaultRetriever retriever, Binding binding, Set<Validator> validators, Set<StreamObserver> observers ) |
| { |
| if ( binding == null || |
| (binding.getRemoteResource() == null) || |
| (binding.isFile() && (binding.getLocalFile() == null)) || |
| (binding.isInMemory() && (binding.getLocalOutputStream() == null))) |
| { |
| throw new IllegalArgumentException( "Nothing to retrieve" ); |
| } |
| _server = server; |
| _retriever = retriever; |
| _binding = binding; |
| _validators = validators; |
| |
| //sift out the potential checksum verifiers |
| for (StreamObserver o: observers) |
| { |
| if (StreamVerifier.class.isAssignableFrom(o.getClass())) |
| _verifiers.add((StreamVerifier)o); |
| else |
| _observers.add(o); |
| } |
| |
| if (_binding.isFile()) |
| { |
| _tempFile = new File( _binding.getLocalFile().getParentFile(), |
| __PREFIX + _binding.getLocalFile().getName() + __TEMP_SUFFIX ); |
| _tempFile.deleteOnExit(); |
| if ( !_tempFile.getParentFile().exists() ) |
| { |
| _tempFile.getParentFile().mkdirs(); |
| } |
| |
| if ( _tempFile.exists() ) |
| { |
| onError( new HttpClientException( binding, "File exists " + _tempFile.getAbsolutePath() ) ); |
| } |
| else if ( !_tempFile.getParentFile().canWrite() ) |
| { |
| onError( new HttpClientException( binding, |
| "Unable to write to dir " + _tempFile.getParentFile().getAbsolutePath() ) ); |
| } |
| } |
| } |
| |
| |
| |
| public File getTempFile() |
| { |
| return _tempFile; |
| } |
| |
| public String getUrl() |
| { |
| return _binding.getRemoteResource().toExternalForm(); |
| } |
| |
| |
| /** Start by getting the appropriate checksums */ |
| public void retrieve() |
| { |
| //if there are no checksum verifiers configured, proceed directly to get the file |
| if (_verifiers.size() == 0) |
| { |
| _checksumState = __READY_STATE; |
| updateTargetState(__START_STATE, null); |
| } |
| else |
| { |
| _checksumState = __START_STATE; |
| updateChecksumState(-1, null); |
| } |
| } |
| |
| |
| /** Move the temporary file to its final location */ |
| public boolean move() |
| { |
| if (_binding.isFile()) |
| { |
| boolean ok = _tempFile.renameTo( _binding.getLocalFile() ); |
| if (log.isDebugEnabled()) |
| log.debug("Renaming "+_tempFile.getAbsolutePath()+" to "+_binding.getLocalFile().getAbsolutePath()+": "+ok); |
| return ok; |
| } |
| else |
| return true; |
| } |
| |
| /** Cleanup temp files */ |
| public synchronized void cleanup() |
| { |
| deleteTempFile(); |
| if ( _exchange != null ) |
| { |
| _exchange.cancel(); |
| } |
| } |
| |
| public synchronized boolean isComplete() |
| { |
| return _complete; |
| } |
| |
| public String toString() |
| { |
| return "T:" + _binding.getRemoteResource() + ":" + _targetState + ":" + _checksumState + ":" + _complete; |
| } |
| |
| private void updateChecksumState (int index, Throwable ex) |
| { |
| if ( _exception == null && ex != null ) |
| { |
| if ( ex instanceof HttpClientException ) |
| { |
| _exception = (HttpClientException) ex; |
| } |
| else |
| { |
| _exception = new HttpClientException( _binding, ex ); |
| } |
| } |
| |
| if (ex != null) |
| { |
| _checksumState = __READY_STATE; |
| onError(_exception); |
| } |
| else |
| { |
| boolean proceedWithTargetFile = false; |
| if (index >= 0) |
| { |
| //check if the just-completed retrieval means that we can stop trying to download checksums |
| StreamVerifier v = _verifiers.get(index); |
| if (_verifierMap.containsKey(v) && v.getAttributes().isSufficient()) |
| proceedWithTargetFile = true; |
| } |
| |
| index++; |
| |
| if ((index < _verifiers.size()) && !proceedWithTargetFile) |
| { |
| retrieveChecksum(index); |
| } |
| else |
| { |
| _checksumState = __READY_STATE; |
| |
| //finished retrieving all possible checksums. Add all verifiers |
| //that had matching checksums into the observers list |
| _observers.addAll(_verifierMap.keySet()); |
| |
| //now get the file now we have the checksum sorted out |
| updateTargetState( __START_STATE, null ); |
| } |
| } |
| } |
| |
| |
| |
| |
| |
| /** |
| * Check the actual checksum against the expected checksum |
| * |
| * @return |
| * @throws StreamVerifierException |
| */ |
| public boolean verifyChecksum() |
| throws StreamVerifierException |
| { |
| boolean ok = true; |
| |
| synchronized (_verifierMap) |
| { |
| Iterator<Map.Entry<StreamVerifier, String>> itor = _verifierMap.entrySet().iterator(); |
| while (itor.hasNext() && ok) |
| { |
| Map.Entry<StreamVerifier, String> e = itor.next(); |
| ok = e.getKey().verifySignature(); |
| } |
| } |
| |
| return ok; |
| } |
| |
| |
| |
| public boolean validate( List<String> errors ) |
| { |
| if ( _validators == null || _validators.isEmpty() ) |
| { |
| return true; |
| } |
| |
| String ext = _binding.getRemoteResource().toString(); |
| if (ext.endsWith("/")) |
| ext = ext.substring(0, ext.length()-1); |
| |
| int i = ext.lastIndexOf( "." ); |
| ext = ( i > 0 ? ext.substring( i + 1 ) : "" ); |
| |
| for ( Validator v : _validators ) |
| { |
| String vExt = v.getFileExtension(); |
| if ( vExt.equalsIgnoreCase( ext ) ) |
| { |
| try |
| { |
| if (_binding.isFile()) |
| { |
| if ( !v.validate( _tempFile.getCanonicalPath(), errors ) ) |
| { |
| return false; |
| } |
| } |
| else if (_binding.isInMemory()) |
| { |
| //TODO Validation on in memory content? |
| //v.validate(_binding.getInboundContent()) |
| } |
| } |
| catch ( IOException e ) |
| { |
| errors.add( e.getMessage() ); |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| |
| |
| protected synchronized void updateTargetState( int state, Throwable ex ) |
| { |
| _targetState = state; |
| if ( _exception == null && ex != null ) |
| { |
| if ( ex instanceof HttpClientException ) |
| { |
| _exception = (HttpClientException) ex; |
| } |
| else |
| { |
| _exception = new HttpClientException( _binding, ex ); |
| } |
| } |
| |
| if ( _targetState == __START_STATE ) |
| { |
| _exchange = retrieveTargetFile(); |
| } |
| //if both checksum and target file are ready, we're ready to return callback |
| else if (_targetState == __READY_STATE ) |
| { |
| _complete = true; |
| if ( _exception == null ) |
| { |
| onComplete(); |
| } |
| else |
| { |
| onError( _exception ); |
| } |
| } |
| } |
| |
| /** Asynchronously fetch the checksum for the target file. */ |
| private HttpExchange retrieveChecksum(final int index) |
| { |
| HttpExchange exchange = new HttpExchange.ContentExchange() |
| { |
| protected void onException( Throwable ex ) |
| { |
| //if the checksum is mandatory, then propagate the exception and stop processing |
| if (!_verifiers.get(index).getAttributes().isLenient()) |
| { |
| updateChecksumState(index, ex); |
| } |
| else |
| updateChecksumState(index, null); |
| |
| } |
| |
| protected void onResponseComplete() throws IOException |
| { |
| super.onResponseComplete(); |
| StreamVerifier v = _verifiers.get(index); |
| |
| if ( getResponseStatus() == HttpServletResponse.SC_OK ) |
| { |
| //We got a checksum so match it up with the verifier it is for |
| synchronized (_verifierMap) |
| { |
| if( v.getAttributes().isSufficient() ) |
| _verifierMap.clear(); //remove all other entries, we only need one checksum |
| |
| String actualSignature = getResponseContent().trim(); |
| try |
| { // Oleg: verifier need to be loaded upfront |
| v.initSignature( actualSignature ); |
| } |
| catch( StreamVerifierException e ) |
| { |
| throw new IOException(e.getMessage()); |
| } |
| _verifierMap.put( v, actualSignature ); |
| } |
| updateChecksumState(index, null); |
| } |
| else |
| { |
| if (!v.getAttributes().isLenient()) |
| { |
| //checksum file MUST be present, fail |
| updateChecksumState(index, new Exception ("Mandatory checksum file not found "+this.getURI())); |
| } |
| else |
| updateChecksumState(index, null); |
| } |
| } |
| }; |
| |
| exchange.setURL( getChecksumFileURLAsString( _verifiers.get(index)) ); |
| |
| try |
| { |
| SecureSender.send(_server, _retriever.getHttpClient(), exchange); |
| } |
| catch ( Exception ex ) |
| { |
| updateChecksumState(index, ex); |
| } |
| return exchange; |
| } |
| |
| |
| /** Asynchronously fetch the target file. */ |
| private HttpExchange retrieveTargetFile() |
| { |
| updateTargetState( __REQUESTED_STATE, null ); |
| |
| //get the file, calculating the digest for it on the fly |
| FileExchange exchange = new FileGetExchange( _server, _binding, getTempFile(), _observers, _retriever.getHttpClient() ) |
| { |
| public void onFileComplete( String url, File localFile ) |
| { |
| //we got the target file ok, so tell our main callback |
| _targetState = __READY_STATE; |
| updateTargetState( __READY_STATE, null ); |
| } |
| |
| public void onFileError( String url, Exception e ) |
| { |
| //an error occurred whilst fetching the file, return an error |
| _targetState = __READY_STATE; |
| updateTargetState( __READY_STATE, e ); |
| } |
| }; |
| |
| if( _server != null && _server.hasUserAgent() ) |
| exchange.setRequestHeader( HttpHeaders.USER_AGENT, _server.getUserAgent() ); |
| |
| exchange.send(); |
| return exchange; |
| } |
| |
| private String getChecksumFileURLAsString (StreamVerifier verifier) |
| { |
| String extension = verifier.getAttributes().getExtension(); |
| if (extension.charAt(0) != '.') |
| extension = "."+extension; |
| return _binding.getRemoteResource().toString() + extension; |
| } |
| |
| private boolean deleteTempFile() |
| { |
| if ( _tempFile != null && _tempFile.exists() ) |
| { |
| boolean ok = _tempFile.delete(); |
| if (log.isDebugEnabled()) |
| log.debug("Deleting file "+_tempFile.getAbsolutePath()+" : "+ok); |
| return ok; |
| } |
| return false; |
| } |
| |
| } |
