001    package org.apache.maven.repository.legacy;
002    
003    /*
004     * Licensed to the Apache Software Foundation (ASF) under one
005     * or more contributor license agreements.  See the NOTICE file
006     * distributed with this work for additional information
007     * regarding copyright ownership.  The ASF licenses this file
008     * to you under the Apache License, Version 2.0 (the
009     * "License"); you may not use this file except in compliance
010     * with the License.  You may obtain a copy of the License at
011     *
012     *   http://www.apache.org/licenses/LICENSE-2.0
013     *
014     * Unless required by applicable law or agreed to in writing,
015     * software distributed under the License is distributed on an
016     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017     * KIND, either express or implied.  See the License for the
018     * specific language governing permissions and limitations
019     * under the License.
020     */
021    
022    import java.util.IdentityHashMap;
023    import java.util.Map;
024    
025    import org.apache.maven.repository.ArtifactTransferEvent;
026    import org.apache.maven.repository.ArtifactTransferListener;
027    import org.apache.maven.repository.ArtifactTransferResource;
028    import org.apache.maven.wagon.events.TransferEvent;
029    import org.apache.maven.wagon.events.TransferListener;
030    import org.apache.maven.wagon.repository.Repository;
031    import org.apache.maven.wagon.resource.Resource;
032    
033    public class TransferListenerAdapter
034        implements TransferListener
035    {
036    
037        private final ArtifactTransferListener listener;
038    
039        private final Map<Resource, ArtifactTransferResource> artifacts;
040    
041        private final Map<Resource, Long> transfers;
042    
043        public static TransferListener newAdapter( ArtifactTransferListener listener )
044        {
045            if ( listener == null )
046            {
047                return null;
048            }
049            else
050            {
051                return new TransferListenerAdapter( listener );
052            }
053        }
054    
055        private TransferListenerAdapter( ArtifactTransferListener listener )
056        {
057            this.listener = listener;
058            this.artifacts = new IdentityHashMap<Resource, ArtifactTransferResource>();
059            this.transfers = new IdentityHashMap<Resource, Long>();
060        }
061    
062        public void debug( String message )
063        {
064        }
065    
066        public void transferCompleted( TransferEvent transferEvent )
067        {
068            ArtifactTransferEvent event = wrap( transferEvent );
069    
070            Long transferred = null;
071            synchronized ( transfers )
072            {
073                transferred = transfers.remove( transferEvent.getResource() );
074            }
075            if ( transferred != null )
076            {
077                event.setTransferredBytes( transferred.longValue() );
078            }
079    
080            synchronized ( artifacts )
081            {
082                artifacts.remove( transferEvent.getResource() );
083            }
084    
085            listener.transferCompleted( event );
086        }
087    
088        public void transferError( TransferEvent transferEvent )
089        {
090            synchronized ( transfers )
091            {
092                transfers.remove( transferEvent.getResource() );
093            }
094            synchronized ( artifacts )
095            {
096                artifacts.remove( transferEvent.getResource() );
097            }
098        }
099    
100        public void transferInitiated( TransferEvent transferEvent )
101        {
102            listener.transferInitiated( wrap( transferEvent ) );
103        }
104    
105        public void transferProgress( TransferEvent transferEvent, byte[] buffer, int length )
106        {
107            Long transferred;
108            synchronized ( transfers )
109            {
110                transferred = transfers.get( transferEvent.getResource() );
111                if ( transferred == null )
112                {
113                    transferred = Long.valueOf( length );
114                }
115                else
116                {
117                    transferred = Long.valueOf( transferred.longValue() + length );
118                }
119                transfers.put( transferEvent.getResource(), transferred );
120            }
121    
122            ArtifactTransferEvent event = wrap( transferEvent );
123            event.setDataBuffer( buffer );
124            event.setDataOffset( 0 );
125            event.setDataLength( length );
126            event.setTransferredBytes( transferred.longValue() );
127    
128            listener.transferProgress( event );
129        }
130    
131        public void transferStarted( TransferEvent transferEvent )
132        {
133            listener.transferStarted( wrap( transferEvent ) );
134        }
135    
136        private ArtifactTransferEvent wrap( TransferEvent event )
137        {
138            if ( event == null )
139            {
140                return null;
141            }
142            else
143            {
144                String wagon = event.getWagon().getClass().getName();
145    
146                ArtifactTransferResource artifact = wrap( event.getWagon().getRepository(), event.getResource() );
147    
148                ArtifactTransferEvent evt;
149                if ( event.getException() != null )
150                {
151                    evt = new ArtifactTransferEvent( wagon, event.getException(), event.getRequestType(), artifact );
152                }
153                else
154                {
155                    evt = new ArtifactTransferEvent( wagon, event.getEventType(), event.getRequestType(), artifact );
156                }
157    
158                evt.setLocalFile( event.getLocalFile() );
159    
160                return evt;
161            }
162        }
163    
164        private ArtifactTransferResource wrap( Repository repository, Resource resource )
165        {
166            if ( resource == null )
167            {
168                return null;
169            }
170            else
171            {
172                synchronized ( artifacts )
173                {
174                    ArtifactTransferResource artifact = artifacts.get( resource );
175    
176                    if ( artifact == null )
177                    {
178                        artifact = new MavenArtifact( repository.getUrl(), resource );
179                        artifacts.put( resource, artifact );
180                    }
181    
182                    return artifact;
183                }
184            }
185        }
186    
187    }