21314

pending completion

Build # 21314

Build Type

cron

travis-ci

Committed by

dapengzhang0

Commit Message

<a href="https://github.com/grpc/grpc-java/commit/<a class=hub.com/grpc/grpc-java/commit/<a class="double-link" href="https://git"><a class=hub.com/grpc/grpc-java/commit/<a class="double-link" href="https://git"><a class=hub.com/grpc/grpc-java/commit/<a class="double-link" href="https://git"><a class=hub.com/grpc/grpc-java/commit/0f572ae7f36de76112dace93b227eb9d9ed2642c">0f572ae7f">&lt;a href=&quot;https://github.com/grpc/grpc-java/commit/</a><a class="double-link" href="https://github.com/grpc/grpc-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/grpc/grpc-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/grpc/grpc-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/grpc/grpc-java/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/grpc/grpc-java/commit/0f572ae7f36de76112dace93b227eb9d9ed2642c">0f572ae7f</a><a href="https://github.com/grpc/grpc-java/commit/0f572ae7f36de76112dace93b227eb9d9ed2642c">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/grpc/grpc-java/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/grpc/grpc-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/grpc/grpc-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/grpc/grpc-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/grpc/grpc-java/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/grpc/grpc-java/commit/0f572ae7f36de76112dace93b227eb9d9ed2642c&quot;&gt;0f572ae7f&lt;/a&gt;&lt;a href=&quot;https://github.com/grpc/grpc-java/commit/0f572ae7f36de76112dace93b227eb9d9ed2642c&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/grpc/grpc-java/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/grpc/grpc-java/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=... (continued)

Run Details

14319 of 16440 relevant lines covered (87.1%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.71

/okhttp/src/main/java/io/grpc/okhttp/ExceptionHandlingFrameWriter.java

/*
 * Copyright 2018 The gRPC Authors
 *
 * Licensed 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 io.grpc.okhttp;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import io.grpc.okhttp.internal.framed.ErrorCode;
import io.grpc.okhttp.internal.framed.FrameWriter;
import io.grpc.okhttp.internal.framed.Header;
import io.grpc.okhttp.internal.framed.Settings;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import okio.Buffer;

final class ExceptionHandlingFrameWriter implements FrameWriter {

  private static final Logger log = Logger.getLogger(OkHttpClientTransport.class.getName());
  // Some exceptions are not very useful and add too much noise to the log
  private static final Set<String> QUIET_ERRORS =
      Collections.unmodifiableSet(new HashSet<>(Arrays.asList("Socket closed")));

  private final TransportExceptionHandler transportExceptionHandler;

  private final FrameWriter frameWriter;

  ExceptionHandlingFrameWriter(
      TransportExceptionHandler transportExceptionHandler, FrameWriter frameWriter) {
    this.transportExceptionHandler =
        checkNotNull(transportExceptionHandler, "transportExceptionHandler");
    this.frameWriter = Preconditions.checkNotNull(frameWriter, "frameWriter");
  }

  @Override
  public void connectionPreface() {
    try {
      frameWriter.connectionPreface();
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void ackSettings(Settings peerSettings) {
    try {
      frameWriter.ackSettings(peerSettings);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders) {
    try {
      frameWriter.pushPromise(streamId, promisedStreamId, requestHeaders);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void flush() {
    try {
      frameWriter.flush();
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void synStream(
      boolean outFinished,
      boolean inFinished,
      int streamId,
      int associatedStreamId,
      List<Header> headerBlock) {
    try {
      frameWriter.synStream(outFinished, inFinished, streamId, associatedStreamId, headerBlock);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void synReply(boolean outFinished, int streamId,
      List<Header> headerBlock) {
    try {
      frameWriter.synReply(outFinished, streamId, headerBlock);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void headers(int streamId, List<Header> headerBlock) {
    try {
      frameWriter.headers(streamId, headerBlock);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void rstStream(int streamId, ErrorCode errorCode) {
    try {
      frameWriter.rstStream(streamId, errorCode);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public int maxDataLength() {
    return frameWriter.maxDataLength();
  }

  @Override
  public void data(boolean outFinished, int streamId, Buffer source, int byteCount) {
    try {
      frameWriter.data(outFinished, streamId, source, byteCount);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void settings(Settings okHttpSettings) {
    try {
      frameWriter.settings(okHttpSettings);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void ping(boolean ack, int payload1, int payload2) {
    try {
      frameWriter.ping(ack, payload1, payload2);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void goAway(int lastGoodStreamId, ErrorCode errorCode,
      byte[] debugData) {
    try {
      frameWriter.goAway(lastGoodStreamId, errorCode, debugData);
      // Flush it since after goAway, we are likely to close this writer.
      frameWriter.flush();
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void windowUpdate(int streamId, long windowSizeIncrement) {
    try {
      frameWriter.windowUpdate(streamId, windowSizeIncrement);
    } catch (IOException e) {
      transportExceptionHandler.onException(e);
    }
  }

  @Override
  public void close() {
    try {
      frameWriter.close();
    } catch (IOException e) {
      log.log(getLogLevel(e), "Failed closing connection", e);
    }
  }

  /**
   * Accepts a throwable and returns the appropriate logging level. Uninteresting exceptions
   * should not clutter the log.
   */
  @VisibleForTesting
  static Level getLogLevel(Throwable t) {
    if (t instanceof IOException
        && t.getMessage() != null
        && QUIET_ERRORS.contains(t.getMessage())) {
      return Level.FINE;
    }
    return Level.INFO;
  }

  /** A class that handles transport exception. */
  interface TransportExceptionHandler {
    /** Handles exception. */
    void onException(Throwable throwable);
  }
}

1	/*
2	* Copyright 2018 The gRPC Authors
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package io.grpc.okhttp;
18
19	import static com.google.common.base.Preconditions.checkNotNull;
20
21	import com.google.common.annotations.VisibleForTesting;
22	import com.google.common.base.Preconditions;
23	import io.grpc.okhttp.internal.framed.ErrorCode;
24	import io.grpc.okhttp.internal.framed.FrameWriter;
25	import io.grpc.okhttp.internal.framed.Header;
26	import io.grpc.okhttp.internal.framed.Settings;
27	import java.io.IOException;
28	import java.util.Arrays;
29	import java.util.Collections;
30	import java.util.HashSet;
31	import java.util.List;
32	import java.util.Set;
33	import java.util.logging.Level;
34	import java.util.logging.Logger;
35	import okio.Buffer;
36
37	final class ExceptionHandlingFrameWriter implements FrameWriter {
38
39	private static final Logger log = Logger.getLogger(OkHttpClientTransport.class.getName());	1✔
40	// Some exceptions are not very useful and add too much noise to the log
41	private static final Set<String> QUIET_ERRORS =	1✔
42	Collections.unmodifiableSet(new HashSet<>(Arrays.asList("Socket closed")));	1✔
43
44	private final TransportExceptionHandler transportExceptionHandler;
45
46	private final FrameWriter frameWriter;
47
48	ExceptionHandlingFrameWriter(
49	TransportExceptionHandler transportExceptionHandler, FrameWriter frameWriter) {	1✔
50	this.transportExceptionHandler =	1✔
51	checkNotNull(transportExceptionHandler, "transportExceptionHandler");	1✔
52	this.frameWriter = Preconditions.checkNotNull(frameWriter, "frameWriter");	1✔
53	}	1✔
54
55	@Override
56	public void connectionPreface() {
57	try {
58	frameWriter.connectionPreface();	1✔
59	} catch (IOException e) {	×
60	transportExceptionHandler.onException(e);	×
61	}	1✔
62	}	1✔
63
64	@Override
65	public void ackSettings(Settings peerSettings) {
66	try {
67	frameWriter.ackSettings(peerSettings);	1✔
68	} catch (IOException e) {	1✔
69	transportExceptionHandler.onException(e);	1✔
70	}	1✔
71	}	1✔
72
73	@Override
74	public void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders) {
75	try {
76	frameWriter.pushPromise(streamId, promisedStreamId, requestHeaders);	×
77	} catch (IOException e) {	×
78	transportExceptionHandler.onException(e);	×
79	}	×
80	}	×
81
82	@Override
83	public void flush() {
84	try {
85	frameWriter.flush();	1✔
86	} catch (IOException e) {	×
87	transportExceptionHandler.onException(e);	×
88	}	1✔
89	}	1✔
90
91	@Override
92	public void synStream(
93	boolean outFinished,
94	boolean inFinished,
95	int streamId,
96	int associatedStreamId,
97	List<Header> headerBlock) {
98	try {
99	frameWriter.synStream(outFinished, inFinished, streamId, associatedStreamId, headerBlock);	1✔
100	} catch (IOException e) {	×
101	transportExceptionHandler.onException(e);	×
102	}	1✔
103	}	1✔
104
105	@Override
106	public void synReply(boolean outFinished, int streamId,
107	List<Header> headerBlock) {
108	try {
109	frameWriter.synReply(outFinished, streamId, headerBlock);	×
110	} catch (IOException e) {	1✔
111	transportExceptionHandler.onException(e);	1✔
112	}	×
113	}	1✔
114
115	@Override
116	public void headers(int streamId, List<Header> headerBlock) {
117	try {
118	frameWriter.headers(streamId, headerBlock);	×
119	} catch (IOException e) {	×
120	transportExceptionHandler.onException(e);	×
121	}	×
122	}	×
123
124	@Override
125	public void rstStream(int streamId, ErrorCode errorCode) {
126	try {
127	frameWriter.rstStream(streamId, errorCode);	1✔
128	} catch (IOException e) {	1✔
129	transportExceptionHandler.onException(e);	1✔
130	}	1✔
131	}	1✔
132
133	@Override
134	public int maxDataLength() {
135	return frameWriter.maxDataLength();	1✔
136	}
137
138	@Override
139	public void data(boolean outFinished, int streamId, Buffer source, int byteCount) {
140	try {
141	frameWriter.data(outFinished, streamId, source, byteCount);	1✔
142	} catch (IOException e) {	×
143	transportExceptionHandler.onException(e);	×
144	}	1✔
145	}	1✔
146
147	@Override
148	public void settings(Settings okHttpSettings) {
149	try {
150	frameWriter.settings(okHttpSettings);	1✔
151	} catch (IOException e) {	×
152	transportExceptionHandler.onException(e);	×
153	}	1✔
154	}	1✔
155
156	@Override
157	public void ping(boolean ack, int payload1, int payload2) {
158	try {
159	frameWriter.ping(ack, payload1, payload2);	1✔
160	} catch (IOException e) {	×
161	transportExceptionHandler.onException(e);	×
162	}	1✔
163	}	1✔
164
165	@Override
166	public void goAway(int lastGoodStreamId, ErrorCode errorCode,
167	byte[] debugData) {
168	try {
169	frameWriter.goAway(lastGoodStreamId, errorCode, debugData);	1✔
170	// Flush it since after goAway, we are likely to close this writer.
171	frameWriter.flush();	1✔
172	} catch (IOException e) {	×
173	transportExceptionHandler.onException(e);	×
174	}	1✔
175	}	1✔
176
177	@Override
178	public void windowUpdate(int streamId, long windowSizeIncrement) {
179	try {
180	frameWriter.windowUpdate(streamId, windowSizeIncrement);	1✔
181	} catch (IOException e) {	×
182	transportExceptionHandler.onException(e);	×
183	}	1✔
184	}	1✔
185
186	@Override
187	public void close() {
188	try {
189	frameWriter.close();	1✔
190	} catch (IOException e) {	×
191	log.log(getLogLevel(e), "Failed closing connection", e);	×
192	}	1✔
193	}	1✔
194
195	/**
196	* Accepts a throwable and returns the appropriate logging level. Uninteresting exceptions
197	* should not clutter the log.
198	*/
199	@VisibleForTesting
200	static Level getLogLevel(Throwable t) {
201	if (t instanceof IOException	1✔
202	&& t.getMessage() != null	1✔
203	&& QUIET_ERRORS.contains(t.getMessage())) {	1✔
204	return Level.FINE;	1✔
205	}
206	return Level.INFO;	1✔
207	}
208
209	/** A class that handles transport exception. */
210	interface TransportExceptionHandler {
211	/** Handles exception. */
212	void onException(Throwable throwable);
213	}
214	}

grpc / grpc-java / 21314

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous