1 // 2 // ======================================================================== 3 // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. 4 // ------------------------------------------------------------------------ 5 // All rights reserved. This program and the accompanying materials 6 // are made available under the terms of the Eclipse Public License v1.0 7 // and Apache License v2.0 which accompanies this distribution. 8 // 9 // The Eclipse Public License is available at 10 // http://www.eclipse.org/legal/epl-v10.html 11 // 12 // The Apache License v2.0 is available at 13 // http://www.opensource.org/licenses/apache2.0.php 14 // 15 // You may elect to redistribute this code under either of these licenses. 16 // ======================================================================== 17 // 18 19 package org.eclipse.jetty.client; 20 21 import java.io.IOException; 22 import java.io.InputStream; 23 import java.net.URI; 24 import java.util.concurrent.atomic.AtomicInteger; 25 26 import org.eclipse.jetty.client.security.SecurityListener; 27 import org.eclipse.jetty.http.HttpFields; 28 import org.eclipse.jetty.http.HttpHeaders; 29 import org.eclipse.jetty.http.HttpMethods; 30 import org.eclipse.jetty.http.HttpSchemes; 31 import org.eclipse.jetty.http.HttpURI; 32 import org.eclipse.jetty.http.HttpVersions; 33 import org.eclipse.jetty.io.Buffer; 34 import org.eclipse.jetty.io.BufferCache.CachedBuffer; 35 import org.eclipse.jetty.io.ByteArrayBuffer; 36 import org.eclipse.jetty.io.Connection; 37 import org.eclipse.jetty.io.EndPoint; 38 import org.eclipse.jetty.util.log.Log; 39 import org.eclipse.jetty.util.log.Logger; 40 import org.eclipse.jetty.util.thread.Timeout; 41 42 /** 43 * <p> 44 * An HTTP client API that encapsulates an exchange (a request and its response) with a HTTP server. 45 * </p> 46 * 47 * This object encapsulates: 48 * <ul> 49 * <li>The HTTP server address, see {@link #setAddress(Address)}, or {@link #setURI(URI)}, or {@link #setURL(String)}) 50 * <li>The HTTP request method, URI and HTTP version (see {@link #setMethod(String)}, {@link #setRequestURI(String)}, and {@link #setVersion(int)}) 51 * <li>The request headers (see {@link #addRequestHeader(String, String)} or {@link #setRequestHeader(String, String)}) 52 * <li>The request content (see {@link #setRequestContent(Buffer)} or {@link #setRequestContentSource(InputStream)}) 53 * <li>The status of the exchange (see {@link #getStatus()}) 54 * <li>Callbacks to handle state changes (see the onXxx methods such as {@link #onRequestComplete()} or {@link #onResponseComplete()}) 55 * <li>The ability to intercept callbacks (see {@link #setEventListener(HttpEventListener)} 56 * </ul> 57 * 58 * <p> 59 * The HttpExchange class is intended to be used by a developer wishing to have close asynchronous interaction with the the exchange.<br /> 60 * Typically a developer will extend the HttpExchange class with a derived class that overrides some or all of the onXxx callbacks. <br /> 61 * There are also some predefined HttpExchange subtypes that can be used as a basis, see {@link org.eclipse.jetty.client.ContentExchange} and 62 * {@link org.eclipse.jetty.client.CachedExchange}. 63 * </p> 64 * 65 * <p> 66 * Typically the HttpExchange is passed to the {@link HttpClient#send(HttpExchange)} method, which in turn selects a {@link HttpDestination} and calls its 67 * {@link HttpDestination#send(HttpExchange)}, which then creates or selects a {@link AbstractHttpConnection} and calls its {@link AbstractHttpConnection#send(HttpExchange)}. A 68 * developer may wish to directly call send on the destination or connection if they wish to bypass some handling provided (eg Cookie handling in the 69 * HttpDestination). 70 * </p> 71 * 72 * <p> 73 * In some circumstances, the HttpClient or HttpDestination may wish to retry a HttpExchange (eg. failed pipeline request, authentication retry or redirection). 74 * In such cases, the HttpClient and/or HttpDestination may insert their own HttpExchangeListener to intercept and filter the call backs intended for the 75 * HttpExchange. 76 * </p> 77 */ 78 public class HttpExchange 79 { 80 static final Logger LOG = Log.getLogger(HttpExchange.class); 81 82 public static final int STATUS_START = 0; 83 public static final int STATUS_WAITING_FOR_CONNECTION = 1; 84 public static final int STATUS_WAITING_FOR_COMMIT = 2; 85 public static final int STATUS_SENDING_REQUEST = 3; 86 public static final int STATUS_WAITING_FOR_RESPONSE = 4; 87 public static final int STATUS_PARSING_HEADERS = 5; 88 public static final int STATUS_PARSING_CONTENT = 6; 89 public static final int STATUS_COMPLETED = 7; 90 public static final int STATUS_EXPIRED = 8; 91 public static final int STATUS_EXCEPTED = 9; 92 public static final int STATUS_CANCELLING = 10; 93 public static final int STATUS_CANCELLED = 11; 94 95 // HTTP protocol fields 96 private String _method = HttpMethods.GET; 97 private Buffer _scheme = HttpSchemes.HTTP_BUFFER; 98 private String _uri; 99 private int _version = HttpVersions.HTTP_1_1_ORDINAL; 100 private Address _address; 101 private final HttpFields _requestFields = new HttpFields(); 102 private Buffer _requestContent; 103 private InputStream _requestContentSource; 104 105 private AtomicInteger _status = new AtomicInteger(STATUS_START); 106 private boolean _retryStatus = false; 107 // controls if the exchange will have listeners autoconfigured by the destination 108 private boolean _configureListeners = true; 109 private HttpEventListener _listener = new Listener(); 110 private volatile AbstractHttpConnection _connection; 111 112 private Address _localAddress = null; 113 114 // a timeout for this exchange 115 private long _timeout = -1; 116 private volatile Timeout.Task _timeoutTask; 117 private long _lastStateChange=System.currentTimeMillis(); 118 private long _sent=-1; 119 private int _lastState=-1; 120 private int _lastStatePeriod=-1; 121 122 boolean _onRequestCompleteDone; 123 boolean _onResponseCompleteDone; 124 boolean _onDone; // == onConnectionFail || onException || onExpired || onCancelled || onResponseCompleted && onRequestCompleted 125 126 protected void expire(HttpDestination destination) 127 { 128 AbstractHttpConnection connection = _connection; 129 if (getStatus() < HttpExchange.STATUS_COMPLETED) 130 setStatus(HttpExchange.STATUS_EXPIRED); 131 destination.exchangeExpired(this); 132 if (connection != null) 133 connection.exchangeExpired(this); 134 } 135 136 public int getStatus() 137 { 138 return _status.get(); 139 } 140 141 /** 142 * @param status 143 * the status to wait for 144 * @throws InterruptedException 145 * if the waiting thread is interrupted 146 * @deprecated Use {@link #waitForDone()} instead 147 */ 148 @Deprecated 149 public void waitForStatus(int status) throws InterruptedException 150 { 151 throw new UnsupportedOperationException(); 152 } 153 154 /** 155 * Wait until the exchange is "done". Done is defined as when a final state has been passed to the HttpExchange via the associated onXxx call. Note that an 156 * exchange can transit a final state when being used as part of a dialog (eg {@link SecurityListener}. Done status is thus defined as: 157 * 158 * <pre> 159 * done == onConnectionFailed || onException || onExpire || onRequestComplete && onResponseComplete 160 * </pre> 161 * 162 * @return the done status 163 * @throws InterruptedException 164 */ 165 public int waitForDone() throws InterruptedException 166 { 167 synchronized (this) 168 { 169 while (!isDone()) 170 this.wait(); 171 return _status.get(); 172 } 173 } 174 175 public void reset() 176 { 177 // TODO - this should do a cancel and wakeup everybody that was waiting. 178 // might need a version number concept 179 synchronized (this) 180 { 181 _timeoutTask = null; 182 _onRequestCompleteDone = false; 183 _onResponseCompleteDone = false; 184 _onDone = false; 185 setStatus(STATUS_START); 186 } 187 } 188 189 /* ------------------------------------------------------------ */ 190 /** 191 * @param newStatus 192 * @return True if the status was actually set. 193 */ 194 boolean setStatus(int newStatus) 195 { 196 boolean set = false; 197 try 198 { 199 int oldStatus = _status.get(); 200 boolean ignored = false; 201 if (oldStatus != newStatus) 202 { 203 long now = System.currentTimeMillis(); 204 _lastStatePeriod=(int)(now-_lastStateChange); 205 _lastState=oldStatus; 206 _lastStateChange=now; 207 if (newStatus==STATUS_SENDING_REQUEST) 208 _sent=_lastStateChange; 209 } 210 211 // State machine: from which old status you can go into which new status 212 switch (oldStatus) 213 { 214 case STATUS_START: 215 switch (newStatus) 216 { 217 case STATUS_START: 218 case STATUS_WAITING_FOR_CONNECTION: 219 case STATUS_WAITING_FOR_COMMIT: 220 case STATUS_CANCELLING: 221 case STATUS_EXCEPTED: 222 set = _status.compareAndSet(oldStatus,newStatus); 223 break; 224 case STATUS_EXPIRED: 225 set = setStatusExpired(newStatus,oldStatus); 226 break; 227 } 228 break; 229 case STATUS_WAITING_FOR_CONNECTION: 230 switch (newStatus) 231 { 232 case STATUS_WAITING_FOR_COMMIT: 233 case STATUS_CANCELLING: 234 case STATUS_EXCEPTED: 235 set = _status.compareAndSet(oldStatus,newStatus); 236 break; 237 case STATUS_EXPIRED: 238 set = setStatusExpired(newStatus,oldStatus); 239 break; 240 } 241 break; 242 case STATUS_WAITING_FOR_COMMIT: 243 switch (newStatus) 244 { 245 case STATUS_SENDING_REQUEST: 246 case STATUS_CANCELLING: 247 case STATUS_EXCEPTED: 248 set = _status.compareAndSet(oldStatus,newStatus); 249 break; 250 case STATUS_EXPIRED: 251 set = setStatusExpired(newStatus,oldStatus); 252 break; 253 } 254 break; 255 case STATUS_SENDING_REQUEST: 256 switch (newStatus) 257 { 258 case STATUS_WAITING_FOR_RESPONSE: 259 if (set = _status.compareAndSet(oldStatus,newStatus)) 260 getEventListener().onRequestCommitted(); 261 break; 262 case STATUS_CANCELLING: 263 case STATUS_EXCEPTED: 264 set = _status.compareAndSet(oldStatus,newStatus); 265 break; 266 case STATUS_EXPIRED: 267 set = setStatusExpired(newStatus,oldStatus); 268 break; 269 } 270 break; 271 case STATUS_WAITING_FOR_RESPONSE: 272 switch (newStatus) 273 { 274 case STATUS_PARSING_HEADERS: 275 case STATUS_CANCELLING: 276 case STATUS_EXCEPTED: 277 set = _status.compareAndSet(oldStatus,newStatus); 278 break; 279 case STATUS_EXPIRED: 280 set = setStatusExpired(newStatus,oldStatus); 281 break; 282 } 283 break; 284 case STATUS_PARSING_HEADERS: 285 switch (newStatus) 286 { 287 case STATUS_PARSING_CONTENT: 288 if (set = _status.compareAndSet(oldStatus,newStatus)) 289 getEventListener().onResponseHeaderComplete(); 290 break; 291 case STATUS_CANCELLING: 292 case STATUS_EXCEPTED: 293 set = _status.compareAndSet(oldStatus,newStatus); 294 break; 295 case STATUS_EXPIRED: 296 set = setStatusExpired(newStatus,oldStatus); 297 break; 298 } 299 break; 300 case STATUS_PARSING_CONTENT: 301 switch (newStatus) 302 { 303 case STATUS_COMPLETED: 304 if (set = _status.compareAndSet(oldStatus,newStatus)) 305 getEventListener().onResponseComplete(); 306 break; 307 case STATUS_CANCELLING: 308 case STATUS_EXCEPTED: 309 set = _status.compareAndSet(oldStatus,newStatus); 310 break; 311 case STATUS_EXPIRED: 312 set = setStatusExpired(newStatus,oldStatus); 313 break; 314 } 315 break; 316 case STATUS_COMPLETED: 317 switch (newStatus) 318 { 319 case STATUS_START: 320 case STATUS_EXCEPTED: 321 case STATUS_WAITING_FOR_RESPONSE: 322 set = _status.compareAndSet(oldStatus,newStatus); 323 break; 324 case STATUS_CANCELLING: 325 case STATUS_EXPIRED: 326 // Don't change the status, it's too late 327 ignored = true; 328 break; 329 } 330 break; 331 case STATUS_CANCELLING: 332 switch (newStatus) 333 { 334 case STATUS_EXCEPTED: 335 case STATUS_CANCELLED: 336 if (set = _status.compareAndSet(oldStatus,newStatus)) 337 done(); 338 break; 339 default: 340 // Ignore other statuses, we're cancelling 341 ignored = true; 342 break; 343 } 344 break; 345 case STATUS_EXCEPTED: 346 case STATUS_EXPIRED: 347 case STATUS_CANCELLED: 348 switch (newStatus) 349 { 350 case STATUS_START: 351 set = _status.compareAndSet(oldStatus,newStatus); 352 break; 353 354 case STATUS_COMPLETED: 355 ignored = true; 356 done(); 357 break; 358 359 default: 360 ignored = true; 361 break; 362 } 363 break; 364 default: 365 // Here means I allowed to set a state that I don't recognize 366 throw new AssertionError(oldStatus + " => " + newStatus); 367 } 368 369 if (!set && !ignored) 370 throw new IllegalStateException(toState(oldStatus) + " => " + toState(newStatus)); 371 LOG.debug("setStatus {} {}",newStatus,this); 372 } 373 catch (IOException x) 374 { 375 LOG.warn(x); 376 } 377 return set; 378 } 379 380 private boolean setStatusExpired(int newStatus, int oldStatus) 381 { 382 boolean set; 383 if (set = _status.compareAndSet(oldStatus,newStatus)) 384 getEventListener().onExpire(); 385 return set; 386 } 387 388 public boolean isDone() 389 { 390 synchronized (this) 391 { 392 return _onDone; 393 } 394 } 395 396 /** 397 * @deprecated 398 */ 399 @Deprecated 400 public boolean isDone(int status) 401 { 402 return isDone(); 403 } 404 405 public HttpEventListener getEventListener() 406 { 407 return _listener; 408 } 409 410 public void setEventListener(HttpEventListener listener) 411 { 412 _listener = listener; 413 } 414 415 public void setTimeout(long timeout) 416 { 417 _timeout = timeout; 418 } 419 420 public long getTimeout() 421 { 422 return _timeout; 423 } 424 425 /** 426 * @param url 427 * an absolute URL (for example 'http://localhost/foo/bar?a=1') 428 */ 429 public void setURL(String url) 430 { 431 setURI(URI.create(url)); 432 } 433 434 /** 435 * @param address 436 * the address of the server 437 */ 438 public void setAddress(Address address) 439 { 440 _address = address; 441 } 442 443 /** 444 * @return the address of the server 445 */ 446 public Address getAddress() 447 { 448 return _address; 449 } 450 451 /** 452 * the local address used by the connection 453 * 454 * Note: this method will not be populated unless the exchange has been executed by the HttpClient 455 * 456 * @return the local address used for the running of the exchange if available, null otherwise. 457 */ 458 public Address getLocalAddress() 459 { 460 return _localAddress; 461 } 462 463 /** 464 * @param scheme 465 * the scheme of the URL (for example 'http') 466 */ 467 public void setScheme(Buffer scheme) 468 { 469 _scheme = scheme; 470 } 471 472 /** 473 * @param scheme 474 * the scheme of the URL (for example 'http') 475 */ 476 public void setScheme(String scheme) 477 { 478 if (scheme != null) 479 { 480 if (HttpSchemes.HTTP.equalsIgnoreCase(scheme)) 481 setScheme(HttpSchemes.HTTP_BUFFER); 482 else if (HttpSchemes.HTTPS.equalsIgnoreCase(scheme)) 483 setScheme(HttpSchemes.HTTPS_BUFFER); 484 else 485 setScheme(new ByteArrayBuffer(scheme)); 486 } 487 } 488 489 /** 490 * @return the scheme of the URL 491 */ 492 public Buffer getScheme() 493 { 494 return _scheme; 495 } 496 497 /** 498 * @param version 499 * the HTTP protocol version as integer, 9, 10 or 11 for 0.9, 1.0 or 1.1 500 */ 501 public void setVersion(int version) 502 { 503 _version = version; 504 } 505 506 /** 507 * @param version 508 * the HTTP protocol version as string 509 */ 510 public void setVersion(String version) 511 { 512 CachedBuffer v = HttpVersions.CACHE.get(version); 513 if (v == null) 514 _version = 10; 515 else 516 _version = v.getOrdinal(); 517 } 518 519 /** 520 * @return the HTTP protocol version as integer 521 * @see #setVersion(int) 522 */ 523 public int getVersion() 524 { 525 return _version; 526 } 527 528 /** 529 * @param method 530 * the HTTP method (for example 'GET') 531 */ 532 public void setMethod(String method) 533 { 534 _method = method; 535 } 536 537 /** 538 * @return the HTTP method 539 */ 540 public String getMethod() 541 { 542 return _method; 543 } 544 545 /** 546 * @return request URI 547 * @see #getRequestURI() 548 * @deprecated 549 */ 550 @Deprecated 551 public String getURI() 552 { 553 return getRequestURI(); 554 } 555 556 /** 557 * @return request URI 558 */ 559 public String getRequestURI() 560 { 561 return _uri; 562 } 563 564 /** 565 * Set the request URI 566 * 567 * @param uri 568 * new request URI 569 * @see #setRequestURI(String) 570 * @deprecated 571 */ 572 @Deprecated 573 public void setURI(String uri) 574 { 575 setRequestURI(uri); 576 } 577 578 /** 579 * Set the request URI 580 * 581 * Per RFC 2616 sec5, Request-URI = "*" | absoluteURI | abs_path | authority<br/> 582 * where:<br/> 583 * <br/> 584 * "*" - request applies to server itself<br/> 585 * absoluteURI - required for proxy requests, e.g. http://localhost:8080/context<br/> 586 * (this form is generated automatically by HttpClient)<br/> 587 * abs_path - used for most methods, e.g. /context<br/> 588 * authority - used for CONNECT method only, e.g. localhost:8080<br/> 589 * <br/> 590 * For complete definition of URI components, see RFC 2396 sec3.<br/> 591 * 592 * @param uri 593 * new request URI 594 */ 595 public void setRequestURI(String uri) 596 { 597 _uri = uri; 598 } 599 600 /* ------------------------------------------------------------ */ 601 /** 602 * @param uri 603 * an absolute URI (for example 'http://localhost/foo/bar?a=1') 604 */ 605 public void setURI(URI uri) 606 { 607 if (!uri.isAbsolute()) 608 throw new IllegalArgumentException("!Absolute URI: " + uri); 609 610 if (uri.isOpaque()) 611 throw new IllegalArgumentException("Opaque URI: " + uri); 612 613 if (LOG.isDebugEnabled()) 614 LOG.debug("URI = {}",uri.toASCIIString()); 615 616 String scheme = uri.getScheme(); 617 int port = uri.getPort(); 618 if (port <= 0) 619 port = "https".equalsIgnoreCase(scheme)?443:80; 620 621 setScheme(scheme); 622 setAddress(new Address(uri.getHost(),port)); 623 624 HttpURI httpUri = new HttpURI(uri); 625 String completePath = httpUri.getCompletePath(); 626 setRequestURI(completePath == null?"/":completePath); 627 } 628 629 /** 630 * Adds the specified request header 631 * 632 * @param name 633 * the header name 634 * @param value 635 * the header value 636 */ 637 public void addRequestHeader(String name, String value) 638 { 639 getRequestFields().add(name,value); 640 } 641 642 /** 643 * Adds the specified request header 644 * 645 * @param name 646 * the header name 647 * @param value 648 * the header value 649 */ 650 public void addRequestHeader(Buffer name, Buffer value) 651 { 652 getRequestFields().add(name,value); 653 } 654 655 /** 656 * Sets the specified request header 657 * 658 * @param name 659 * the header name 660 * @param value 661 * the header value 662 */ 663 public void setRequestHeader(String name, String value) 664 { 665 getRequestFields().put(name,value); 666 } 667 668 /** 669 * Sets the specified request header 670 * 671 * @param name 672 * the header name 673 * @param value 674 * the header value 675 */ 676 public void setRequestHeader(Buffer name, Buffer value) 677 { 678 getRequestFields().put(name,value); 679 } 680 681 /** 682 * @param value 683 * the content type of the request 684 */ 685 public void setRequestContentType(String value) 686 { 687 getRequestFields().put(HttpHeaders.CONTENT_TYPE_BUFFER,value); 688 } 689 690 /** 691 * @return the request headers 692 */ 693 public HttpFields getRequestFields() 694 { 695 return _requestFields; 696 } 697 698 /** 699 * @param requestContent 700 * the request content 701 */ 702 public void setRequestContent(Buffer requestContent) 703 { 704 _requestContent = requestContent; 705 } 706 707 /** 708 * @param stream 709 * the request content as a stream 710 */ 711 public void setRequestContentSource(InputStream stream) 712 { 713 _requestContentSource = stream; 714 if (_requestContentSource != null && _requestContentSource.markSupported()) 715 _requestContentSource.mark(Integer.MAX_VALUE); 716 } 717 718 /** 719 * @return the request content as a stream 720 */ 721 public InputStream getRequestContentSource() 722 { 723 return _requestContentSource; 724 } 725 726 public Buffer getRequestContentChunk(Buffer buffer) throws IOException 727 { 728 synchronized (this) 729 { 730 if (_requestContentSource!=null) 731 { 732 if (buffer == null) 733 buffer = new ByteArrayBuffer(8192); // TODO configure 734 735 int space = buffer.space(); 736 int length = _requestContentSource.read(buffer.array(),buffer.putIndex(),space); 737 if (length >= 0) 738 { 739 buffer.setPutIndex(buffer.putIndex()+length); 740 return buffer; 741 } 742 } 743 return null; 744 } 745 } 746 747 /** 748 * @return the request content 749 */ 750 public Buffer getRequestContent() 751 { 752 return _requestContent; 753 } 754 755 /** 756 * @return whether a retry will be attempted or not 757 */ 758 public boolean getRetryStatus() 759 { 760 return _retryStatus; 761 } 762 763 /** 764 * @param retryStatus 765 * whether a retry will be attempted or not 766 */ 767 public void setRetryStatus(boolean retryStatus) 768 { 769 _retryStatus = retryStatus; 770 } 771 772 /** 773 * Initiates the cancelling of this exchange. The status of the exchange is set to {@link #STATUS_CANCELLING}. Cancelling the exchange is an asynchronous 774 * operation with respect to the request/response, and as such checking the request/response status of a cancelled exchange may return undefined results 775 * (for example it may have only some of the response headers being sent by the server). The cancelling of the exchange is completed when the exchange 776 * status (see {@link #getStatus()}) is {@link #STATUS_CANCELLED}, and this can be waited using {@link #waitForDone()}. 777 */ 778 public void cancel() 779 { 780 setStatus(STATUS_CANCELLING); 781 abort(); 782 } 783 784 private void done() 785 { 786 synchronized (this) 787 { 788 disassociate(); 789 _onDone = true; 790 notifyAll(); 791 } 792 } 793 794 private void abort() 795 { 796 AbstractHttpConnection httpConnection = _connection; 797 if (httpConnection != null) 798 { 799 try 800 { 801 // Closing the connection here will cause the connection 802 // to be returned in HttpConnection.handle() 803 httpConnection.close(); 804 } 805 catch (IOException x) 806 { 807 LOG.debug(x); 808 } 809 finally 810 { 811 disassociate(); 812 } 813 } 814 } 815 816 void associate(AbstractHttpConnection connection) 817 { 818 if (connection.getEndPoint().getLocalAddr() != null) 819 _localAddress = new Address(connection.getEndPoint().getLocalAddr(),connection.getEndPoint().getLocalPort()); 820 821 _connection = connection; 822 if (getStatus() == STATUS_CANCELLING) 823 abort(); 824 } 825 826 boolean isAssociated() 827 { 828 return this._connection != null; 829 } 830 831 AbstractHttpConnection disassociate() 832 { 833 AbstractHttpConnection result = _connection; 834 this._connection = null; 835 if (getStatus() == STATUS_CANCELLING) 836 setStatus(STATUS_CANCELLED); 837 return result; 838 } 839 840 public static String toState(int s) 841 { 842 String state; 843 switch (s) 844 { 845 case STATUS_START: 846 state = "START"; 847 break; 848 case STATUS_WAITING_FOR_CONNECTION: 849 state = "CONNECTING"; 850 break; 851 case STATUS_WAITING_FOR_COMMIT: 852 state = "CONNECTED"; 853 break; 854 case STATUS_SENDING_REQUEST: 855 state = "SENDING"; 856 break; 857 case STATUS_WAITING_FOR_RESPONSE: 858 state = "WAITING"; 859 break; 860 case STATUS_PARSING_HEADERS: 861 state = "HEADERS"; 862 break; 863 case STATUS_PARSING_CONTENT: 864 state = "CONTENT"; 865 break; 866 case STATUS_COMPLETED: 867 state = "COMPLETED"; 868 break; 869 case STATUS_EXPIRED: 870 state = "EXPIRED"; 871 break; 872 case STATUS_EXCEPTED: 873 state = "EXCEPTED"; 874 break; 875 case STATUS_CANCELLING: 876 state = "CANCELLING"; 877 break; 878 case STATUS_CANCELLED: 879 state = "CANCELLED"; 880 break; 881 default: 882 state = "UNKNOWN"; 883 } 884 return state; 885 } 886 887 @Override 888 public String toString() 889 { 890 String state=toState(getStatus()); 891 long now=System.currentTimeMillis(); 892 long forMs = now -_lastStateChange; 893 String s= _lastState>=0 894 ?String.format("%s@%x=%s//%s%s#%s(%dms)->%s(%dms)",getClass().getSimpleName(),hashCode(),_method,_address,_uri,toState(_lastState),_lastStatePeriod,state,forMs) 895 :String.format("%s@%x=%s//%s%s#%s(%dms)",getClass().getSimpleName(),hashCode(),_method,_address,_uri,state,forMs); 896 if (getStatus()>=STATUS_SENDING_REQUEST && _sent>0) 897 s+="sent="+(now-_sent)+"ms"; 898 return s; 899 } 900 901 /** 902 */ 903 protected Connection onSwitchProtocol(EndPoint endp) throws IOException 904 { 905 return null; 906 } 907 908 /** 909 * Callback called when the request headers have been sent to the server. This implementation does nothing. 910 * 911 * @throws IOException 912 * allowed to be thrown by overriding code 913 */ 914 protected void onRequestCommitted() throws IOException 915 { 916 } 917 918 /** 919 * Callback called when the request and its body have been sent to the server. This implementation does nothing. 920 * 921 * @throws IOException 922 * allowed to be thrown by overriding code 923 */ 924 protected void onRequestComplete() throws IOException 925 { 926 } 927 928 /** 929 * Callback called when a response status line has been received from the server. This implementation does nothing. 930 * 931 * @param version 932 * the HTTP version 933 * @param status 934 * the HTTP status code 935 * @param reason 936 * the HTTP status reason string 937 * @throws IOException 938 * allowed to be thrown by overriding code 939 */ 940 protected void onResponseStatus(Buffer version, int status, Buffer reason) throws IOException 941 { 942 } 943 944 /** 945 * Callback called for each response header received from the server. This implementation does nothing. 946 * 947 * @param name 948 * the header name 949 * @param value 950 * the header value 951 * @throws IOException 952 * allowed to be thrown by overriding code 953 */ 954 protected void onResponseHeader(Buffer name, Buffer value) throws IOException 955 { 956 } 957 958 /** 959 * Callback called when the response headers have been completely received from the server. This implementation does nothing. 960 * 961 * @throws IOException 962 * allowed to be thrown by overriding code 963 */ 964 protected void onResponseHeaderComplete() throws IOException 965 { 966 } 967 968 /** 969 * Callback called for each chunk of the response content received from the server. This implementation does nothing. 970 * 971 * @param content 972 * the buffer holding the content chunk 973 * @throws IOException 974 * allowed to be thrown by overriding code 975 */ 976 protected void onResponseContent(Buffer content) throws IOException 977 { 978 } 979 980 /** 981 * Callback called when the entire response has been received from the server This implementation does nothing. 982 * 983 * @throws IOException 984 * allowed to be thrown by overriding code 985 */ 986 protected void onResponseComplete() throws IOException 987 { 988 } 989 990 /** 991 * Callback called when an exception was thrown during an attempt to establish the connection with the server (for example the server is not listening). 992 * This implementation logs a warning. 993 * 994 * @param x 995 * the exception thrown attempting to establish the connection with the server 996 */ 997 protected void onConnectionFailed(Throwable x) 998 { 999 LOG.warn("CONNECTION FAILED " + this,x); 1000 } 1001 1002 /** 1003 * Callback called when any other exception occurs during the handling of this exchange. This implementation logs a warning. 1004 * 1005 * @param x 1006 * the exception thrown during the handling of this exchange 1007 */ 1008 protected void onException(Throwable x) 1009 { 1010 LOG.warn("EXCEPTION " + this,x); 1011 } 1012 1013 /** 1014 * Callback called when no response has been received within the timeout. This implementation logs a warning. 1015 */ 1016 protected void onExpire() 1017 { 1018 LOG.warn("EXPIRED " + this); 1019 } 1020 1021 /** 1022 * Callback called when the request is retried (due to failures or authentication). Implementations must reset any consumable content that needs to be sent. 1023 * 1024 * @throws IOException 1025 * allowed to be thrown by overriding code 1026 */ 1027 protected void onRetry() throws IOException 1028 { 1029 if (_requestContentSource != null) 1030 { 1031 if (_requestContentSource.markSupported()) 1032 { 1033 _requestContent = null; 1034 _requestContentSource.reset(); 1035 } 1036 else 1037 { 1038 throw new IOException("Unsupported retry attempt"); 1039 } 1040 } 1041 } 1042 1043 /** 1044 * @return true if the exchange should have listeners configured for it by the destination, false if this is being managed elsewhere 1045 * @see #setConfigureListeners(boolean) 1046 */ 1047 public boolean configureListeners() 1048 { 1049 return _configureListeners; 1050 } 1051 1052 /** 1053 * @param autoConfigure 1054 * whether the listeners are configured by the destination or elsewhere 1055 */ 1056 public void setConfigureListeners(boolean autoConfigure) 1057 { 1058 this._configureListeners = autoConfigure; 1059 } 1060 1061 protected void scheduleTimeout(final HttpDestination destination) 1062 { 1063 assert _timeoutTask == null; 1064 1065 _timeoutTask = new Timeout.Task() 1066 { 1067 @Override 1068 public void expired() 1069 { 1070 HttpExchange.this.expire(destination); 1071 } 1072 }; 1073 1074 HttpClient httpClient = destination.getHttpClient(); 1075 long timeout = getTimeout(); 1076 if (timeout > 0) 1077 httpClient.schedule(_timeoutTask,timeout); 1078 else 1079 httpClient.schedule(_timeoutTask); 1080 } 1081 1082 protected void cancelTimeout(HttpClient httpClient) 1083 { 1084 Timeout.Task task = _timeoutTask; 1085 if (task != null) 1086 httpClient.cancel(task); 1087 _timeoutTask = null; 1088 } 1089 1090 private class Listener implements HttpEventListener 1091 { 1092 public void onConnectionFailed(Throwable ex) 1093 { 1094 try 1095 { 1096 HttpExchange.this.onConnectionFailed(ex); 1097 } 1098 finally 1099 { 1100 done(); 1101 } 1102 } 1103 1104 public void onException(Throwable ex) 1105 { 1106 try 1107 { 1108 HttpExchange.this.onException(ex); 1109 } 1110 finally 1111 { 1112 done(); 1113 } 1114 } 1115 1116 public void onExpire() 1117 { 1118 try 1119 { 1120 HttpExchange.this.onExpire(); 1121 } 1122 finally 1123 { 1124 done(); 1125 } 1126 } 1127 1128 public void onRequestCommitted() throws IOException 1129 { 1130 HttpExchange.this.onRequestCommitted(); 1131 } 1132 1133 public void onRequestComplete() throws IOException 1134 { 1135 try 1136 { 1137 HttpExchange.this.onRequestComplete(); 1138 } 1139 finally 1140 { 1141 synchronized (HttpExchange.this) 1142 { 1143 _onRequestCompleteDone = true; 1144 // Member _onDone may already be true, for example 1145 // because the exchange expired or has been canceled 1146 _onDone |= _onResponseCompleteDone; 1147 if (_onDone) 1148 disassociate(); 1149 HttpExchange.this.notifyAll(); 1150 } 1151 } 1152 } 1153 1154 public void onResponseComplete() throws IOException 1155 { 1156 try 1157 { 1158 HttpExchange.this.onResponseComplete(); 1159 } 1160 finally 1161 { 1162 synchronized (HttpExchange.this) 1163 { 1164 _onResponseCompleteDone = true; 1165 // Member _onDone may already be true, for example 1166 // because the exchange expired or has been canceled 1167 _onDone |= _onRequestCompleteDone; 1168 if (_onDone) 1169 disassociate(); 1170 HttpExchange.this.notifyAll(); 1171 } 1172 } 1173 } 1174 1175 public void onResponseContent(Buffer content) throws IOException 1176 { 1177 HttpExchange.this.onResponseContent(content); 1178 } 1179 1180 public void onResponseHeader(Buffer name, Buffer value) throws IOException 1181 { 1182 HttpExchange.this.onResponseHeader(name,value); 1183 } 1184 1185 public void onResponseHeaderComplete() throws IOException 1186 { 1187 HttpExchange.this.onResponseHeaderComplete(); 1188 } 1189 1190 public void onResponseStatus(Buffer version, int status, Buffer reason) throws IOException 1191 { 1192 HttpExchange.this.onResponseStatus(version,status,reason); 1193 } 1194 1195 public void onRetry() 1196 { 1197 HttpExchange.this.setRetryStatus(true); 1198 try 1199 { 1200 HttpExchange.this.onRetry(); 1201 } 1202 catch (IOException e) 1203 { 1204 LOG.debug(e); 1205 } 1206 } 1207 } 1208 1209 /** 1210 * @deprecated use {@link org.eclipse.jetty.client.CachedExchange} instead 1211 */ 1212 @Deprecated 1213 public static class CachedExchange extends org.eclipse.jetty.client.CachedExchange 1214 { 1215 public CachedExchange(boolean cacheFields) 1216 { 1217 super(cacheFields); 1218 } 1219 } 1220 1221 /** 1222 * @deprecated use {@link org.eclipse.jetty.client.ContentExchange} instead 1223 */ 1224 @Deprecated 1225 public static class ContentExchange extends org.eclipse.jetty.client.ContentExchange 1226 { 1227 } 1228 } 1229
