import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param client the http client to use
 * @param sslStrategy the SSL strategy
 * @param request the request
 * @param api the API
 * @param requiredAuthType the authorization type
 * @param hasDataPolicy if policy chain contains data policies
 * @param handler the result handler
 * @throws ConnectorException when unable to connect
 */
public HttpApiConnection(OkHttpClient client, ApiRequest request, Api api,
        RequiredAuthType requiredAuthType, SSLSessionStrategy sslStrategy,
        boolean hasDataPolicy, IAsyncResultHandler<IApiConnectionResponse> handler) throws ConnectorException {
    this.client = client;
    this.request = request;
    this.api = api;
    this.requiredAuthType = requiredAuthType;
    this.sslStrategy = sslStrategy;
    this.hasDataPolicy = hasDataPolicy;
    this.responseHandler = handler;

    try {
        connect();
    } catch (Exception e) {
        // Sometimes it's possible that multiple exceptions end up coming through. Ignore secondary ones.
        if (!isError) {
            handler.handle(AsyncResultImpl.<IApiConnectionResponse> create(e));
            isError = true;
        }
    }
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.io.IWriteStream#end()
 */
@Override
public void end() {
    try {
        IOUtils.closeQuietly(outputStream);
        if (isError) {
            return;
        } else if (!connected) {
            throw new IOException("Not connected."); //$NON-NLS-1$
        }
        outputStream = null;
        // Process the response, convert to an ApiResponse object, and return it
        response = GatewayThreadContext.getApiResponse();
        Map<String, List<String>> headerFields = connection.getHeaderFields();
        for (String headerName : headerFields.keySet()) {
            if (headerName != null && !SUPPRESSED_RESPONSE_HEADERS.contains(headerName)) {
                response.getHeaders().add(headerName, connection.getHeaderField(headerName));
            }
        }
        response.setCode(connection.getResponseCode());
        response.setMessage(connection.getResponseMessage());
        responseHandler.handle(AsyncResultImpl.<IApiConnectionResponse> create(this));
    } catch (Exception e) {
        handleConnectionError(e);
    }
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - no CA inherited trust
 *   - gateway does not explicitly trust the API, but automatically validates against self-signed
 *   - API trusts gateway certificate
 */
@Test
public void shouldSucceedWhenAllowedSelfSigned() {
    config.put(TLSOptions.TLS_TRUSTSTORE, getResourcePath("2waytest/basic_mutual_auth/gateway_ts.jks"));
    config.put(TLSOptions.TLS_TRUSTSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYSTORE, getResourcePath("2waytest/basic_mutual_auth/gateway_ks.jks"));
    config.put(TLSOptions.TLS_KEYSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYPASSWORD, "password");
    config.put(TLSOptions.TLS_ALLOWANYHOST, "true");
    config.put(TLSOptions.TLS_ALLOWSELFSIGNED, "true");

   HttpConnectorFactory factory = new HttpConnectorFactory(config);
   IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.MTLS, false);
   IApiConnection connection = connector.connect(request,
           new IAsyncResultHandler<IApiConnectionResponse>() {

    @Override
    public void handle(IAsyncResult<IApiConnectionResponse> result) {
        Assert.assertTrue(result.isSuccess());
    }
   });

   connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - Select invalid key alias (no such key).
 *   - Negotiation will fail
 * @throws CertificateException the certificate exception
 * @throws IOException the IO exception
 */
@Test
public void shouldFailWithInValidKeyAlias() throws CertificateException, IOException  {
    config.put(TLSOptions.TLS_TRUSTSTORE, getResourcePath("2waytest/basic_mutual_auth_2/gateway_ts.jks"));
    config.put(TLSOptions.TLS_TRUSTSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYSTORE, getResourcePath("2waytest/basic_mutual_auth_2/gateway_ks.jks"));
    config.put(TLSOptions.TLS_KEYSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYPASSWORD, "password");
    config.put(TLSOptions.TLS_ALLOWANYHOST, "true");
    config.put(TLSOptions.TLS_ALLOWSELFSIGNED, "false");
    // No such key exists in the keystore
    config.put(TLSOptions.TLS_KEYALIASES, "xxx");

    HttpConnectorFactory factory = new HttpConnectorFactory(config);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.MTLS, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {

                @Override
                public void handle(IAsyncResult<IApiConnectionResponse> result) {
                    Assert.assertTrue(result.isError());
                }
            });

            connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - Development mode TLS pass-through. Gateway accepts anything.
 *   - Server should still refuse on basis of requiring client auth.
 */
@Test
public void shouldFailWithDevModeAndNoClientKeys() {
    config.put(TLSOptions.TLS_DEVMODE, "true");

    HttpConnectorFactory factory = new HttpConnectorFactory(config);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.DEFAULT, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {

     @Override
     public void handle(IAsyncResult<IApiConnectionResponse> result) {
             Assert.assertTrue(result.isError());
             System.out.println(result.getError());
         }
    });

    connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - CA inherited trust
 *   - gateway trusts API via CA
 *   - API does not evaluate trust
 */
@Test
public void shouldSucceedWithValidTLS() {
    config.put(TLSOptions.TLS_TRUSTSTORE, getResourcePath("2waytest/mutual_trust_via_ca/common_ts.jks"));
    config.put(TLSOptions.TLS_TRUSTSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_ALLOWANYHOST, "true");
    config.put(TLSOptions.TLS_ALLOWSELFSIGNED, "false");

    HttpConnectorFactory factory = new HttpConnectorFactory(config);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.DEFAULT, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {

        @Override
        public void handle(IAsyncResult<IApiConnectionResponse> result) {
            if (result.isError())
                throw new RuntimeException(result.getError());

            Assert.assertTrue(result.isSuccess());
        }
    });

    connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - CA is only in API trust store, missing from gateway trust store
 *   - Gateway does not trust API, as it does not trust CA
 *   - API trusts gateway via CA
 */
@Test
public void shouldFailWhenCANotTrusted() {
    // Keystore does not trust the root CA API is signed with.
    config.put(TLSOptions.TLS_TRUSTSTORE, getResourcePath("2waytest/basic_mutual_auth/gateway_ts.jks"));
    config.put(TLSOptions.TLS_TRUSTSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_ALLOWANYHOST, "true");
    config.put(TLSOptions.TLS_ALLOWSELFSIGNED, "false");

    HttpConnectorFactory factory = new HttpConnectorFactory(config);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.DEFAULT, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {

     @Override
     public void handle(IAsyncResult<IApiConnectionResponse> result) {
         Assert.assertTrue(result.isError());
         System.out.println(result.getError());
         Assert.assertTrue(result.getError() instanceof ConnectorException);
     }
    });

    connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - Development mode TLS pass-through. Accepts anything.
 */
@Test
public void shouldAllowAllWhenDevMode() {
    config.put(TLSOptions.TLS_DEVMODE, "true");

    HttpConnectorFactory factory = new HttpConnectorFactory(config);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.DEFAULT, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {

     @Override
     public void handle(IAsyncResult<IApiConnectionResponse> result) {
         Assert.assertTrue(result.isSuccess());
     }
    });

    connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - No settings whatsoever.
 *   - Will fail, as defaults are relatively safe,
 *     and API certificate will not be recognised.
 */
@Test
public void shouldFailWithNoSettings() {
    HttpConnectorFactory factory = new HttpConnectorFactory(config);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.DEFAULT, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {

     @Override
     public void handle(IAsyncResult<IApiConnectionResponse> result) {
             Assert.assertTrue(result.isError());
             System.out.println(result.getError());
         }
    });

    connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario successful connection to the back end API via basic auth.
 */
@Test
public void shouldSucceedWithBasicAuth() {
    endpointProperties.put(BasicAuthOptions.BASIC_USERNAME, "user");
    endpointProperties.put(BasicAuthOptions.BASIC_PASSWORD, "user123!");
    endpointProperties.put(BasicAuthOptions.BASIC_REQUIRE_SSL, "false");
    api.setEndpointProperties(endpointProperties);
    api.setEndpoint("http://localhost:8008/echo");

    HttpConnectorFactory factory = new HttpConnectorFactory(globalConfig);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.BASIC, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {
                @Override
                public void handle(IAsyncResult<IApiConnectionResponse> result) {
                    Assert.assertTrue("Expected a successful connection response.", result.isSuccess());
                    IApiConnectionResponse scr = result.getResult();
                    Assert.assertEquals("Expected a 200 response from the echo server (valid creds).", 200, scr.getHead().getCode());
                }
            });

    if (connection.isConnected()) {
        connection.end();
    }
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario successful connection to the back end API via basic auth.
 */
@Test
public void shouldSucceedWithBasicAuthAndSSL() {
    endpointProperties.put(BasicAuthOptions.BASIC_USERNAME, "user");
    endpointProperties.put(BasicAuthOptions.BASIC_PASSWORD, "user123!");
    endpointProperties.put(BasicAuthOptions.BASIC_REQUIRE_SSL, "true");
    api.setEndpointProperties(endpointProperties);
    api.setEndpoint("https://localhost:8009/echo");

    HttpConnectorFactory factory = new HttpConnectorFactory(globalConfig);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.BASIC, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {
                @Override
                public void handle(IAsyncResult<IApiConnectionResponse> result) {
                    Assert.assertTrue("Expected a successful connection response.", result.isSuccess());
                    IApiConnectionResponse scr = result.getResult();
                    Assert.assertEquals("Expected a 200 response from the echo server (valid creds).", 200, scr.getHead().getCode());
                }
            });

    if (connection.isConnected()) {
        connection.end();
    }
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario successful connection to the back end API via basic auth.
 */
@Test
public void shouldFailWithNoSSL() {
    endpointProperties.put(BasicAuthOptions.BASIC_USERNAME, "user");
    endpointProperties.put(BasicAuthOptions.BASIC_PASSWORD, "user123!");
    endpointProperties.put(BasicAuthOptions.BASIC_REQUIRE_SSL, "true");
    api.setEndpointProperties(endpointProperties);
    api.setEndpoint("http://localhost:8008/echo");

    HttpConnectorFactory factory = new HttpConnectorFactory(globalConfig);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.BASIC, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {
                @Override
                public void handle(IAsyncResult<IApiConnectionResponse> result) {
                    Assert.assertTrue("Expected an error due to not using SSL.", result.isError());
                    Assert.assertTrue("Expected a ConnectorException due to not using SSL.", result.getError() instanceof ConnectorException);
                    Assert.assertEquals("Endpoint security requested (BASIC auth) but endpoint is not secure (SSL).", result.getError().getMessage());
                }
            });

    if (connection.isConnected()) {
        connection.end();
    }
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Should fail because the credentials provided are not valid/
 */
@Test
public void shouldFailWithBadCredentials() {
    endpointProperties.put(BasicAuthOptions.BASIC_USERNAME, "user");
    endpointProperties.put(BasicAuthOptions.BASIC_PASSWORD, "bad-password");
    endpointProperties.put(BasicAuthOptions.BASIC_REQUIRE_SSL, "false");
    api.setEndpointProperties(endpointProperties);
    api.setEndpoint("http://localhost:8008/echo");

    HttpConnectorFactory factory = new HttpConnectorFactory(globalConfig);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.BASIC, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {
                @Override
                public void handle(IAsyncResult<IApiConnectionResponse> result) {
                    Assert.assertTrue("Expected a successful connection response.", result.isSuccess());
                    IApiConnectionResponse scr = result.getResult();
                    Assert.assertEquals("Expected a 401 response from the echo server (invalid creds).", 401, scr.getHead().getCode());
                }
            });

    if (connection.isConnected()) {
        connection.end();
    }
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Should fail because no credentials were provided.
 */
@Test
public void shouldFailWithNoCredentials() {
    endpointProperties.remove(BasicAuthOptions.BASIC_USERNAME);
    endpointProperties.remove(BasicAuthOptions.BASIC_PASSWORD);
    endpointProperties.put(BasicAuthOptions.BASIC_REQUIRE_SSL, "false");
    api.setEndpointProperties(endpointProperties);
    api.setEndpoint("http://localhost:8008/echo");

    HttpConnectorFactory factory = new HttpConnectorFactory(globalConfig);
    IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.BASIC, false);
    IApiConnection connection = connector.connect(request,
            new IAsyncResultHandler<IApiConnectionResponse>() {
                @Override
                public void handle(IAsyncResult<IApiConnectionResponse> result) {
                    Assert.assertTrue("Expected a successful connection response.", result.isSuccess());
                    IApiConnectionResponse scr = result.getResult();
                    Assert.assertEquals("Expected a 401 response from the echo server (invalid creds).", 401, scr.getHead().getCode());
                }
            });

    if (connection.isConnected()) {
        connection.end();
    }
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Construct an {@link HttpConnector} instance. The {@link #resultHandler} must remain exclusive to a
 * given instance.
 *
 * @param vertx a vertx
 * @param client the vertx http client
 * @param api an API
 * @param request a request with fields filled
 * @param options the connector options
 * @param resultHandler a handler, called when reading is permitted
 */
public HttpConnector(Vertx vertx, HttpClient client, ApiRequest request, Api api, ApimanHttpConnectorOptions options,
        IAsyncResultHandler<IApiConnectionResponse> resultHandler) {
   this.client = client;
   this.api = api;
   this.apiRequest = request;

   this.resultHandler = resultHandler;
   this.exceptionHandler = new ExceptionHandler();
   this.apiEndpoint = options.getUri();
   this.options = options;

   apiHost = apiEndpoint.getHost();
   apiPort = getPort();
   apiPath = apiEndpoint.getPath().isEmpty() || apiEndpoint.getPath().equals("/") ? "" : apiEndpoint.getPath();
   destination = apiRequest.getDestination() == null ? "" : apiRequest.getDestination();

   verifyConnection();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
@Override
public IApiConnector createConnector() {
    return new IApiConnector() {
        @Override
        public IApiConnection connect(ApiRequest request, IAsyncResultHandler<IApiConnectionResponse> handler) throws ConnectorException {
            return new ShortcircuitServiceConnection(handler);
        }
    };
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
public ShortcircuitServiceConnection(IAsyncResultHandler<IApiConnectionResponse> handler) {
    responseHandler = handler;

    response = new ApiResponse();
    response.setCode(HttpURLConnection.HTTP_OK);
    response.setHeaders(new HeaderMap());
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
public ShortcircuitApiConnection(IAsyncResultHandler<IApiConnectionResponse> handler) {
    responseHandler = handler;

    response = new ApiResponse();
    response.setCode(200);
    response.setMessage("OK"); //$NON-NLS-1$
    response.setHeaders(responseHeaders);
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - no CA inherited trust
 *   - gateway trusts API certificate directly
 *   - API trusts gateway certificate directly
 */
@Test
public void shouldSucceedWithValidMTLS() {
    config.put(TLSOptions.TLS_TRUSTSTORE, getResourcePath("2waytest/basic_mutual_auth_2/gateway_ts.jks"));
    config.put(TLSOptions.TLS_TRUSTSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYSTORE, getResourcePath("2waytest/basic_mutual_auth_2/gateway_ks.jks"));
    config.put(TLSOptions.TLS_KEYSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYPASSWORD, "password");
    config.put(TLSOptions.TLS_ALLOWANYHOST, "true");
    config.put(TLSOptions.TLS_ALLOWSELFSIGNED, "false");

   HttpConnectorFactory factory = new HttpConnectorFactory(config);
   IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.MTLS, false);
   IApiConnection connection = connector.connect(request,
           new IAsyncResultHandler<IApiConnectionResponse>() {

    @Override
    public void handle(IAsyncResult<IApiConnectionResponse> result) {
        if (result.isError())
            throw new RuntimeException(result.getError());

      Assert.assertTrue(result.isSuccess());
    }
   });

   connection.end();
}
 

import io.apiman.gateway.engine.IApiConnectionResponse; //导入依赖的package包/类
/**
 * Scenario:
 *   - no CA inherited trust
 *   - gateway does <em>not</em> trust the API
 *   - API trusts gateway certificate
 */
@Test
public void shouldFailWhenGatewayDoesNotTrustApi() {
    config.put(TLSOptions.TLS_TRUSTSTORE, getResourcePath("2waytest/basic_mutual_auth/gateway_ts.jks"));
    config.put(TLSOptions.TLS_TRUSTSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYSTORE, getResourcePath("2waytest/basic_mutual_auth/gateway_ks.jks"));
    config.put(TLSOptions.TLS_KEYSTOREPASSWORD, "password");
    config.put(TLSOptions.TLS_KEYPASSWORD, "password");
    config.put(TLSOptions.TLS_ALLOWANYHOST, "true");
    config.put(TLSOptions.TLS_ALLOWSELFSIGNED, "false");

   HttpConnectorFactory factory = new HttpConnectorFactory(config);
   IApiConnector connector = factory.createConnector(request, api, RequiredAuthType.MTLS, false);
   IApiConnection connection = connector.connect(request,
           new IAsyncResultHandler<IApiConnectionResponse>() {

    @Override
    public void handle(IAsyncResult<IApiConnectionResponse> result) {
        Assert.assertTrue(result.isError());

        System.out.println(result.getError());
        Assert.assertTrue(result.getError() instanceof ConnectorException);
        // Would like to assert on SSL error, but is sun specific info
        // TODO improve connector to handle this situation better
    }
   });

   connection.end();
}