1 package org.eclipse.aether.internal.impl;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.eclipse.aether.RepositorySystemSession;
23 import org.eclipse.aether.transfer.AbstractTransferListener;
24 import org.eclipse.aether.transfer.TransferCancelledException;
25 import org.eclipse.aether.transfer.TransferEvent;
26 import org.eclipse.aether.transfer.TransferListener;
27 import org.slf4j.Logger;
28 import org.slf4j.LoggerFactory;
29
30 import static java.util.Objects.requireNonNull;
31
32 class SafeTransferListener
33 extends AbstractTransferListener
34 {
35
36 private static final Logger LOGGER = LoggerFactory.getLogger( SafeTransferListener.class );
37
38 private final TransferListener listener;
39
40 public static TransferListener wrap( RepositorySystemSession session )
41 {
42 TransferListener listener = session.getTransferListener();
43 if ( listener == null )
44 {
45 return null;
46 }
47 return new SafeTransferListener( listener );
48 }
49
50 protected SafeTransferListener( RepositorySystemSession session )
51 {
52 this( session.getTransferListener() );
53 }
54
55 private SafeTransferListener( TransferListener listener )
56 {
57 this.listener = listener;
58 }
59
60 private void logError( TransferEvent event, Throwable e )
61 {
62 LOGGER.debug( "Failed to dispatch transfer event '{}' to {}", event, listener.getClass().getCanonicalName(),
63 e );
64 }
65
66 @Override
67 public void transferInitiated( TransferEvent event )
68 throws TransferCancelledException
69 {
70 requireNonNull( event, "event cannot be null" );
71 if ( listener != null )
72 {
73 try
74 {
75 listener.transferInitiated( event );
76 }
77 catch ( RuntimeException | LinkageError e )
78 {
79 logError( event, e );
80 }
81 }
82 }
83
84 @Override
85 public void transferStarted( TransferEvent event )
86 throws TransferCancelledException
87 {
88 requireNonNull( event, "event cannot be null" );
89 if ( listener != null )
90 {
91 try
92 {
93 listener.transferStarted( event );
94 }
95 catch ( RuntimeException | LinkageError e )
96 {
97 logError( event, e );
98 }
99 }
100 }
101
102 @Override
103 public void transferProgressed( TransferEvent event )
104 throws TransferCancelledException
105 {
106 requireNonNull( event, "event cannot be null" );
107 if ( listener != null )
108 {
109 try
110 {
111 listener.transferProgressed( event );
112 }
113 catch ( RuntimeException | LinkageError e )
114 {
115 logError( event, e );
116 }
117 }
118 }
119
120 @Override
121 public void transferCorrupted( TransferEvent event )
122 throws TransferCancelledException
123 {
124 requireNonNull( event, "event cannot be null" );
125 if ( listener != null )
126 {
127 try
128 {
129 listener.transferCorrupted( event );
130 }
131 catch ( RuntimeException | LinkageError e )
132 {
133 logError( event, e );
134 }
135 }
136 }
137
138 @Override
139 public void transferSucceeded( TransferEvent event )
140 {
141 requireNonNull( event, "event cannot be null" );
142 if ( listener != null )
143 {
144 try
145 {
146 listener.transferSucceeded( event );
147 }
148 catch ( RuntimeException | LinkageError e )
149 {
150 logError( event, e );
151 }
152 }
153 }
154
155 @Override
156 public void transferFailed( TransferEvent event )
157 {
158 requireNonNull( event, "event cannot be null" );
159 if ( listener != null )
160 {
161 try
162 {
163 listener.transferFailed( event );
164 }
165 catch ( RuntimeException | LinkageError e )
166 {
167 logError( event, e );
168 }
169 }
170 }
171
172 }