private void initStub(Stub stub) throws AxisFault { if( stub != null ) { final ServiceClient client = stub._getServiceClient(); final Options options = client.getOptions(); options.setProperty(WSHandlerConstants.PW_CALLBACK_REF, this); options.setProperty(WSSHandlerConstants.OUTFLOW_SECURITY, ofc.getProperty()); options.setProperty(HTTPConstants.REUSE_HTTP_CLIENT, "true"); options.setProperty(HTTPConstants.HTTP_PROTOCOL_VERSION, HTTPConstants.HEADER_PROTOCOL_11); URI uri = URI.create(bbUrl); if( uri.getScheme().toLowerCase().startsWith("https") ) { Protocol myhttps = new Protocol("https", new EasySSLProtocolSocketFactory(), 443); options.setProperty(HTTPConstants.CUSTOM_PROTOCOL_HANDLER, myhttps); } client.engageModule("rampart-1.5.1"); } }
public HttpClientTransmitterImpl() { protocolMap = new TreeMap<String,Protocol>(); protocolMap.put(HTTP_SCHEME_NAME, httpProtocol); protocolMap.put(HTTPS_SCHEME_NAME, httpsProtocol); httpClient = new HttpClient(); httpClient.setHttpConnectionManager(new MultiThreadedHttpConnectionManager()); httpMethodFactory = new StandardHttpMethodFactoryImpl(); jsonErrorSerializer = new ExceptionJsonSerializer(); // Create an HTTP Proxy Host if appropriate system properties are set httpProxyHost = HttpClientHelper.createProxyHost("http.proxyHost", "http.proxyPort", DEFAULT_HTTP_PORT); httpProxyCredentials = HttpClientHelper.createProxyCredentials("http.proxyUser", "http.proxyPassword"); httpAuthScope = createProxyAuthScope(httpProxyHost); // Create an HTTPS Proxy Host if appropriate system properties are set httpsProxyHost = HttpClientHelper.createProxyHost("https.proxyHost", "https.proxyPort", DEFAULT_HTTPS_PORT); httpsProxyCredentials = HttpClientHelper.createProxyCredentials("https.proxyUser", "https.proxyPassword"); httpsAuthScope = createProxyAuthScope(httpsProxyHost); }
/** Get a host for the given parameters. This method need not be thread-safe. */ public HttpHost getHost(String host, int port, String scheme) { if(scheme == null) { scheme = "http"; } Protocol protocol = protocols.get(scheme); if(protocol == null) { protocol = Protocol.getProtocol("http"); if(protocol == null) { throw new IllegalArgumentException("Unrecognised scheme parameter"); } } return new HttpHost(host, port, protocol); }
/** * Creates a new HTTP connection for the given host with the virtual * alias and port via the given proxy host and port using the given * protocol. * * @param proxyHost the host to proxy via * @param proxyPort the port to proxy via * @param host the host to connect to. Parameter value must be non-null. * @param port the port to connect to * @param protocol The protocol to use. Parameter value must be non-null. */ public HttpConnection( String proxyHost, int proxyPort, String host, int port, Protocol protocol) { if (host == null) { throw new IllegalArgumentException("host parameter is null"); } if (protocol == null) { throw new IllegalArgumentException("protocol is null"); } proxyHostName = proxyHost; proxyPortNumber = proxyPort; hostName = host; portNumber = protocol.resolvePort(port); protocolInUse = protocol; }
/** * Constructor for HttpHost. * * @param hostname the hostname (IP or DNS name). Can be <code>null</code>. * @param port the port. Value <code>-1</code> can be used to set default protocol port * @param protocol the protocol. Value <code>null</code> can be used to set default protocol */ public HttpHost(final String hostname, int port, final Protocol protocol) { super(); if (hostname == null) { throw new IllegalArgumentException("Host name may not be null"); } if (protocol == null) { throw new IllegalArgumentException("Protocol may not be null"); } this.hostname = hostname; this.protocol = protocol; if (port >= 0) { this.port = port; } else { this.port = this.protocol.getDefaultPort(); } }
public void testDefaults() throws IOException { this.server.setHttpService(new SimpleService()); this.client.getParams().setParameter(HttpMethodParams.USER_AGENT, "test"); HostConfiguration hostconfig = new HostConfiguration(); hostconfig.setHost( this.server.getLocalAddress(), this.server.getLocalPort(), Protocol.getProtocol("http")); GetMethod httpget = new GetMethod("/miss/"); try { this.client.executeMethod(hostconfig, httpget); } finally { httpget.releaseConnection(); } assertEquals(HttpStatus.SC_OK, httpget.getStatusCode()); assertEquals("test", httpget.getRequestHeader("User-Agent").getValue()); assertEquals("test", httpget.getParams(). getParameter(HttpMethodParams.USER_AGENT)); assertEquals("test", hostconfig.getParams(). getParameter(HttpMethodParams.USER_AGENT)); assertEquals("test", client.getParams(). getParameter(HttpMethodParams.USER_AGENT)); }
public void testRedirectWithVirtualHost() throws IOException { String host = this.server.getLocalAddress(); int port = this.server.getLocalPort(); Protocol testhttp = new Protocol("http", new VirtualSocketFactory(host, port), port); Protocol.registerProtocol("testhttp", testhttp); try { this.server.setHttpService(new VirtualHostService()); this.client.getHostConfiguration().setHost(host, port, "testhttp"); this.client.getHostConfiguration().getParams().setVirtualHost("whatever.com"); GetMethod httpget = new GetMethod("/"); httpget.setFollowRedirects(true); try { this.client.executeMethod(httpget); assertEquals(HttpStatus.SC_OK, httpget.getStatusCode()); assertEquals("http://www.whatever.co.nz/", httpget.getURI().toString()); } finally { httpget.releaseConnection(); } } finally { Protocol.unregisterProtocol("testhttp"); } }
public void testConnTimeout() { // create a custom protocol that will delay for 500 milliseconds Protocol testProtocol = new Protocol( "timeout", new DelayedProtocolSocketFactory( 500, Protocol.getProtocol("http").getSocketFactory() ), this.server.getLocalPort() ); HttpConnection conn = new HttpConnection( this.server.getLocalAddress(), this.server.getLocalPort(), testProtocol); // 1 ms is short enough to make this fail conn.getParams().setConnectionTimeout(1); try { conn.open(); fail("Should have timed out"); } catch(IOException e) { assertTrue(e instanceof ConnectTimeoutException); /* should fail */ } }
public void testNTLMAuthenticationRetry() throws Exception { this.server.setHttpService(new NTLMAuthService()); // configure the client this.client.getHostConfiguration().setHost( server.getLocalAddress(), server.getLocalPort(), Protocol.getProtocol("http")); this.client.getState().setCredentials(AuthScope.ANY, new NTCredentials("username", "password", "host", "domain")); FakeHttpMethod httpget = new FakeHttpMethod("/"); try { client.executeMethod(httpget); } finally { httpget.releaseConnection(); } assertNull(httpget.getResponseHeader("WWW-Authenticate")); assertEquals(200, httpget.getStatusCode()); }
public void testRelativeURLHitWithDefaultHost() throws IOException { this.server.setHttpService(new EchoService()); // Set default host this.client.getHostConfiguration().setHost( this.server.getLocalAddress(), this.server.getLocalPort(), Protocol.getProtocol("http")); GetMethod httpget = new GetMethod("/test/"); try { this.client.executeMethod(httpget); assertEquals(HttpStatus.SC_OK, httpget.getStatusCode()); } finally { httpget.releaseConnection(); } }
/** * Get a Protocol for the given parameters. The default implementation * selects a protocol based only on the scheme. Subclasses can do fancier * things, such as select SSL parameters based on the host or port. This * method must not return null. */ protected Protocol getProtocol(HostConfiguration old, String scheme, String host, int port) { final Protocol oldProtocol = old.getProtocol(); if (oldProtocol != null) { final String oldScheme = oldProtocol.getScheme(); if (oldScheme == scheme || (oldScheme != null && oldScheme.equalsIgnoreCase(scheme))) { // The old protocol has the desired scheme. return oldProtocol; // Retain it. } } Protocol newProtocol = (scheme != null && scheme.toLowerCase().endsWith("s")) ? httpsProtocol : httpProtocol; if (newProtocol == null) { newProtocol = Protocol.getProtocol(scheme); } return newProtocol; }
/** * Metodo Que Inicializa as Informações de Certificado Digital * * @param certificado * @param cacert * @throws CertificadoException */ public static void inicializaCertificado(Certificado certificado, InputStream cacert) throws CertificadoException { try { KeyStore keyStore = getKeyStore(certificado); X509Certificate certificate = getCertificate(certificado, keyStore); PrivateKey privateKey = (PrivateKey) keyStore.getKey(certificado.getNome(), certificado.getSenha().toCharArray()); if (certificado.isAtivarProperties()) { CertificadoProperties.inicia(certificado, cacert); } else { SocketFactoryDinamico socketFactory = new SocketFactoryDinamico(certificate, privateKey, cacert, certificado.getSslProtocol()); Protocol protocol = new Protocol("https", socketFactory, 443); Protocol.registerProtocol("https", protocol); } } catch (UnrecoverableKeyException | KeyStoreException | NoSuchAlgorithmException | KeyManagementException | CertificateException | IOException e) { throw new CertificadoException(e.getMessage()); } }
public static void load(KeyStore ks, String alias, char[] pin, String patOfCacerts) throws KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException { if (!isLoaded) { if ((alias == null) || ("".equals(alias))) { Enumeration<String> aliasesEnum = ks.aliases(); while (aliasesEnum.hasMoreElements()) { alias = (String) aliasesEnum.nextElement(); if (ks.isKeyEntry(alias)) { break; } } } X509Certificate certificate = (X509Certificate) ks.getCertificate(alias); PrivateKey privateKey = (PrivateKey) ks.getKey(alias, pin); SocketFactoryDinamico socketFactoryDinamico = new SocketFactoryDinamico(certificate, privateKey); socketFactoryDinamico.setFileCacerts(patOfCacerts); Protocol protocol = new Protocol("https", socketFactoryDinamico, 443); Protocol.registerProtocol("https", protocol); isLoaded = true; } }
public static javax.security.cert.X509Certificate getCert(String host, int port) { GetCertSSLProtocolSocketFactory certFactory = new GetCertSSLProtocolSocketFactory(); Protocol myhttps = new Protocol("https", certFactory, port); HttpClient httpclient = new HttpClient(); httpclient.getHostConfiguration().setHost(host, port, myhttps); GetMethod httpget = new GetMethod("/"); try { httpclient.executeMethod(httpget); //System.out.println(httpget.getStatusLine()); } catch (Throwable t) { //do nothing } finally { httpget.releaseConnection(); } return certFactory.getCertificate(); }
private void doSSL( HttpClient client, HostConfiguration hostConf, String host, int port){ if (hostConf.getProtocol().isSecure()) { // System.setProperty("javax.net.ssl.trustStore", sslKeystore); // Protocol sslPprotocol = new Protocol("https", new // org.apache.commons.httpclient.contrib.ssl.EasySSLProtocolSocketFactory(), // 443); // client.getHostConfiguration().setHost(host, 443, sslPprotocol); try { ProtocolSocketFactory factory = new InsecureSSLProtocolSocketFactory(); Protocol https = new Protocol("https", factory, port); Protocol.registerProtocol("https", https); client.getHostConfiguration().setHost(host, port, https); } catch (GeneralSecurityException e) { throw new CoreException(CoreException.SSL, e); } } }
private void replaceProtocol(HostConfiguration hostConfig, ProtocolSocketFactory socketFactory, String schema, int defaultPort) { // // switch protocol // due to how HttpCommons work internally this dance is best to be kept as is // // NB: not really needed (see below that the protocol is reseted) but in place just in case hostConfig = new ProtocolAwareHostConfiguration(hostConfig); Protocol directHttp = Protocol.getProtocol(schema); Protocol proxiedHttp = new DelegatedProtocol(socketFactory, directHttp, schema, defaultPort); // NB: register the new protocol since when using absolute URIs, HttpClient#executeMethod will override the configuration (#387) // NB: hence why the original/direct http protocol is saved - as otherwise the connection is not closed since it is considered different // NB: (as the protocol identities don't match) // this is not really needed since it's being replaced later on // hostConfig.setHost(proxyHost, proxyPort, proxiedHttp); Protocol.registerProtocol(schema, proxiedHttp); // end dance }
/** * Convenience method to set up the necessary HttpClient protocol and URL handler. * * Only works for HttpClient, because it's not possible (or at least very difficult) * to provide a different socket factory for the HttpURLConnection class. */ public static void setup(){ final String LOOPBACK = "loopback"; // $NON-NLS-1$ // This ensures tha HttpClient knows about the protocol Protocol.registerProtocol(LOOPBACK, new Protocol(LOOPBACK,new LoopbackHttpClientSocketFactory(),1)); // Now allow the URL handling to work. URLStreamHandlerFactory ushf = new URLStreamHandlerFactory(){ @Override public URLStreamHandler createURLStreamHandler(String protocol) { if (protocol.equalsIgnoreCase(LOOPBACK)){ return new URLStreamHandler(){ @Override protected URLConnection openConnection(URL u) throws IOException { return null;// not needed for HttpClient } }; } return null; } }; java.net.URL.setURLStreamHandlerFactory(ushf); }
public String saveSpMetadataFile(String uri, String spMetadataFileName) { //TODO: change for IDP3 if (StringHelper.isEmpty(uri)) { return null; } HTTPFileDownloader.setEasyhttps(new Protocol("https", new EasyCASSLProtocolSocketFactory(), 443)); String spMetadataFileContent = HTTPFileDownloader.getResource(uri, "application/xml, text/xml", null, null); if (StringHelper.isEmpty(spMetadataFileContent)) { return null; } // Save new file ByteArrayInputStream is; try { byte[] spMetadataFileContentBytes = spMetadataFileContent.getBytes("UTF-8"); is = new ByteArrayInputStream(spMetadataFileContentBytes); } catch (UnsupportedEncodingException ex) { return null; } FileUploadWrapper tmpfileWrapper = new FileUploadWrapper(); tmpfileWrapper.setStream(is); return saveSpMetadataFile(spMetadataFileName, tmpfileWrapper.getStream()); }
public String saveSpMetadataFile(String uri, String spMetadataFileName) { if (StringHelper.isEmpty(uri)) { return null; } HTTPFileDownloader.setEasyhttps(new Protocol("https", new EasyCASSLProtocolSocketFactory(), 443)); String spMetadataFileContent = HTTPFileDownloader.getResource(uri, "application/xml, text/xml", null, null); if (StringHelper.isEmpty(spMetadataFileContent)) { return null; } // Save new file ByteArrayInputStream is; try { byte[] spMetadataFileContentBytes = spMetadataFileContent.getBytes("UTF-8"); is = new ByteArrayInputStream(spMetadataFileContentBytes); } catch (UnsupportedEncodingException ex) { return null; } FileUploadWrapper tmpfileWrapper = new FileUploadWrapper(); tmpfileWrapper.setStream(is); return saveSpMetadataFile(spMetadataFileName, tmpfileWrapper.getStream()); }
@Override protected RouteBuilder createRouteBuilder() throws Exception { return new RouteBuilder() { public void configure() { SSLContextParameters params = new SSLContextParameters(); ProtocolSocketFactory factory = new SSLContextParametersSecureProtocolSocketFactory(params, context); Protocol.registerProtocol("https", new Protocol( "https", factory, 443)); from("direct:start") .to("https://mail.google.com/mail/").to("mock:results"); } }; }
/** * Registers or unregisters the proper components for advanced SSL handling. * @throws IOException */ @SuppressWarnings("deprecation") public static void registerAdvancedSslContext(boolean register, Context context) throws GeneralSecurityException, IOException { Protocol pr = null; try { pr = Protocol.getProtocol("https"); if (pr != null && mDefaultHttpsProtocol == null) { mDefaultHttpsProtocol = pr; } } catch (IllegalStateException e) { // nothing to do here; really } boolean isRegistered = (pr != null && pr.getSocketFactory() instanceof AdvancedSslSocketFactory); if (register && !isRegistered) { Protocol.registerProtocol("https", new Protocol("https", getAdvancedSslSocketFactory(context), 443)); } else if (!register && isRegistered) { if (mDefaultHttpsProtocol != null) { Protocol.registerProtocol("https", mDefaultHttpsProtocol); } } }
public MoveFileTest() { super(); Protocol pr = Protocol.getProtocol("https"); if (pr == null || !(pr.getSocketFactory() instanceof SelfSignedConfidentSslSocketFactory)) { try { ProtocolSocketFactory psf = new SelfSignedConfidentSslSocketFactory(); Protocol.registerProtocol( "https", new Protocol("https", psf, 443)); } catch (GeneralSecurityException e) { throw new AssertionFailedError( "Self-signed confident SSL context could not be loaded"); } } }
public SingleSessionManagerTest() { super(); Protocol pr = Protocol.getProtocol("https"); if (pr == null || !(pr.getSocketFactory() instanceof SelfSignedConfidentSslSocketFactory)) { try { ProtocolSocketFactory psf = new SelfSignedConfidentSslSocketFactory(); Protocol.registerProtocol( "https", new Protocol("https", psf, 443)); } catch (GeneralSecurityException e) { throw new AssertionFailedError( "Self-signed confident SSL context could not be loaded"); } } }
public SimpleFactoryManagerTest() { super(); Protocol pr = Protocol.getProtocol("https"); if (pr == null || !(pr.getSocketFactory() instanceof SelfSignedConfidentSslSocketFactory)) { try { ProtocolSocketFactory psf = new SelfSignedConfidentSslSocketFactory(); Protocol.registerProtocol( "https", new Protocol("https", psf, 443)); } catch (GeneralSecurityException e) { throw new AssertionFailedError( "Self-signed confident SSL context could not be loaded"); } } }
public OwnCloudClientTest() { super(); Protocol pr = Protocol.getProtocol("https"); if (pr == null || !(pr.getSocketFactory() instanceof SelfSignedConfidentSslSocketFactory)) { try { ProtocolSocketFactory psf = new SelfSignedConfidentSslSocketFactory(); Protocol.registerProtocol( "https", new Protocol("https", psf, 443)); } catch (GeneralSecurityException e) { throw new AssertionFailedError( "Self-signed confident SSL context could not be loaded"); } } }
/** * Configure the Federation certificate protocol to use certificates to communicate with remote server * @param federationConfiguration The configuration for the federation data source */ public static void configureFederationCertificate(FederationConfiguration federationConfiguration) { try { URL keystoreUrl = new URL(federationConfiguration.getKeystoreUrl()); // the keystore containing the key to send as the client URL truststoreUrl = new URL(federationConfiguration.getTruststoreUrl()); // the keystore containing the trusted certificates, to validate the server cert against ProtocolSocketFactory socketFactory = new AuthSSLProtocolSocketFactory(keystoreUrl, federationConfiguration.getKeystorePassword(), truststoreUrl, federationConfiguration.getTruststorePassword()); Protocol httpsProtocol = new Protocol(defaultFederationProtocol, socketFactory, defaultFederationSslPort); Protocol.registerProtocol(federationConfiguration.getFederationSslProtocol(), httpsProtocol); Logger.getLogger(FederationProxyUtilities.class).info("Federation HTTPS protocol handler successfully registered."); dumpSSLProperties(); } catch (MalformedURLException e) { Logger.getLogger(ImagingProxy.class).error( "Error configuring HTTPS client within federation proxy. \n" + "Keystore and/or truststore are unavailable. \n" + "Federation functionality will not be available."); } }
public HttpClient(int maxConPerHost, int conTimeOutMs, int soTimeOutMs, int maxSize) { connectionManager = new MultiThreadedHttpConnectionManager(); HttpConnectionManagerParams params = connectionManager.getParams(); params.setDefaultMaxConnectionsPerHost(maxConPerHost); params.setConnectionTimeout(conTimeOutMs); params.setSoTimeout(soTimeOutMs); HttpClientParams clientParams = new HttpClientParams(); // 忽略cookie 避免 Cookie rejected 警告 clientParams.setCookiePolicy(CookiePolicy.IGNORE_COOKIES); client = new org.apache.commons.httpclient.HttpClient(clientParams, connectionManager); Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443); Protocol.registerProtocol("https", myhttps); this.maxSize = maxSize; // 支持proxy if (proxyHost != null && !proxyHost.equals("")) { client.getHostConfiguration().setProxy(proxyHost, proxyPort); client.getParams().setAuthenticationPreemptive(true); if (proxyAuthUser != null && !proxyAuthUser.equals("")) { client.getState().setProxyCredentials(AuthScope.ANY, new UsernamePasswordCredentials(proxyAuthUser, proxyAuthPassword)); log("Proxy AuthUser: " + proxyAuthUser); log("Proxy AuthPassword: " + proxyAuthPassword); } } }
protected void initSocketFactory() throws IOException { if (hostConfig != null) { URL trustKeyStoreUrl = null; if (hostConfig.getTrustKeyStoreResource() != null) { trustKeyStoreUrl = hostConfig.getTrustKeyStoreResource().getURL(); } URL keyStoreUrl = null; if (hostConfig.getKeyStoreResource() != null) { keyStoreUrl = hostConfig.getKeyStoreResource().getURL(); } AuthSSLProtocolSocketFactory factory = new AuthSSLProtocolSocketFactory( keyStoreUrl, hostConfig.getKeyStorePassword(), trustKeyStoreUrl, hostConfig.getTrustKeyStorePassword()); if (sslEnabledProtocols != null) { factory.setEnabledProtocols(sslEnabledProtocols); } Protocol protocol = createProtocol(hostConfig, factory); httpClient.getHostConfiguration().setHost(hostConfig.getHost(), hostConfig.getSecurePort(), protocol); } }
public HttpClient(int maxConPerHost, int conTimeOutMs, int soTimeOutMs, int maxSize) { // MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager(); SimpleHttpConnectionManager connectionManager = new SimpleHttpConnectionManager(true); HttpConnectionManagerParams params = connectionManager.getParams(); params.setDefaultMaxConnectionsPerHost(maxConPerHost); params.setConnectionTimeout(conTimeOutMs); params.setSoTimeout(soTimeOutMs); HttpClientParams clientParams = new HttpClientParams(); clientParams.setCookiePolicy(CookiePolicy.IGNORE_COOKIES); client = new org.apache.commons.httpclient.HttpClient(clientParams, connectionManager); Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443); Protocol.registerProtocol("https", myhttps); }
public static void registerCerts() throws Exception { File keyFile = new File("samples/keystores/Sun.jks.ks"); File trustFile = new File("samples/cacerts-with-78-entries.jks"); URL ks = keyFile.toURI().toURL(); URL ts = trustFile.toURI().toURL(); AuthSSLProtocolSocketFactory sf; sf = new AuthSSLProtocolSocketFactory(ks, "changeit", ts, "changeit"); sf.setCheckHostname(false); // There should be 78 certs in this trust-chain. assertEquals(78, sf.getTrustChain().getCertificates().size()); TrustSSLProtocolSocketFactory tf; tf = new TrustSSLProtocolSocketFactory(trustFile.getAbsolutePath(), "changeit".toCharArray()); tf.setCheckHostname(false); String scheme1 = "https-test1"; Protocol.registerProtocol(scheme1, new Protocol(scheme1, (ProtocolSocketFactory) sf, 443)); String scheme2 = "https-test2"; Protocol.registerProtocol(scheme2, new Protocol(scheme2, (ProtocolSocketFactory) tf, 443)); }
public static IService getService() throws MalformedURLException { // Service srvcModel = new ObjectServiceFactory().create(IService.class); // XFireProxyFactory factory = new XFireProxyFactory(XFireFactory // .newInstance().getXFire()); // // IService srvc = (IService) factory.create(srvcModel, Constants.CONNECT_URL); // return srvc; ProtocolSocketFactory easy = new EasySSLProtocolSocketFactory(); Protocol protocol = new Protocol(HTTP_TYPE, easy, PORT); Protocol.registerProtocol(HTTP_TYPE, protocol); Service serviceModel = new ObjectServiceFactory().create(IService.class, SERVICE_NAME, SERVICE_NAMESPACE, null); IService service = (IService) new XFireProxyFactory().create(serviceModel, SERVICE_URL); Client client = ((XFireProxy)Proxy.getInvocationHandler(service)).getClient(); client.addOutHandler(new DOMOutHandler()); client.setProperty(CommonsHttpMessageSender.GZIP_ENABLED, Boolean.FALSE); client.setProperty(CommonsHttpMessageSender.DISABLE_EXPECT_CONTINUE, "1"); client.setProperty(CommonsHttpMessageSender.HTTP_TIMEOUT, "0"); return service; }
/** * @param target TransferTarget * @return HostConfiguration */ private HostConfiguration getHostConfig(TransferTarget target) { String requiredProtocol = target.getEndpointProtocol(); if (requiredProtocol == null) { throw new TransferException(MSG_UNSUPPORTED_PROTOCOL, new Object[] {target.getEndpointProtocol()}); } Protocol protocol = protocolMap.get(requiredProtocol.toLowerCase().trim()); if (protocol == null) { log.error("Unsupported protocol: " + target.getEndpointProtocol()); throw new TransferException(MSG_UNSUPPORTED_PROTOCOL, new Object[] {target.getEndpointProtocol()}); } HostConfiguration hostConfig = new HostConfiguration(); hostConfig.setHost(target.getEndpointHost(), target.getEndpointPort(), protocol); return hostConfig; }
/** * * Public Section * */ public void connectHTTP(String strUser, String strPass, String strHost, boolean insecure) { //Connect WebDAV with credentials hostConfig = new HostConfiguration(); hostConfig.setHost(strHost); connectionManager = new MultiThreadedHttpConnectionManager(); connectionManagerParams = new HttpConnectionManagerParams(); connectionManagerParams.setMaxConnectionsPerHost(hostConfig, this.intMaxConnections); connectionManager.setParams(connectionManagerParams); client = new HttpClient(connectionManager); creds = new UsernamePasswordCredentials(strUser, strPass); client.getState().setCredentials(AuthScope.ANY, creds); client.setHostConfiguration(hostConfig); if (insecure) { Protocol easyhttps = new Protocol("https", new EasySSLProtocolSocketFactory(), 443); Protocol.registerProtocol("https", easyhttps); } Status.print("WebDav Connection generated"); }
private String getRequest() { if (!Server.serving) return ""; CloseableHttpClient httpclient = HttpClients.createDefault(); HttpHost host = new HttpHost("localhost", Server.frontPort, Protocol.getProtocol("http")); HttpGet request = new HttpGet(host.toURI().concat("/" + Server.RESPONSES)); ResponseHandler<String> responseHandler = new ResponseHandler<String>() { public String handleResponse(final HttpResponse response) throws IOException { int status = response.getStatusLine().getStatusCode(); if (status >= 200 && status < 300) { HttpEntity entity = response.getEntity(); return entity != null ? EntityUtils.toString(entity) : null; } else throw new ClientProtocolException("Unexpected response status: " + status); } }; String responseBody = null; try { responseBody = httpclient.execute(request, responseHandler); } catch (IOException e) { Runner.LOGGER.warn(e); } return responseBody; }
public boolean testConnect(Calendar cal) throws MalformedURLException, ObjectStoreException { boolean connected = false; PathResolver RESOLVER = getPathResolver(cal.getTypeSelect()); Protocol protocol = getProtocol(cal.getIsSslConnection()); URL url = new URL(protocol.getScheme(), cal.getUrl(), cal.getPort(), ""); ICalendarStore store = new ICalendarStore(url, RESOLVER); try { connected = store.connect(cal.getLogin(), cal.getPassword()); } finally { store.disconnect(); } return connected; }
@Transactional public void sync(Calendar calendar) throws ICalendarException, MalformedURLException { PathResolver RESOLVER = getPathResolver(calendar.getTypeSelect()); Protocol protocol = getProtocol(calendar.getIsSslConnection()); URL url = new URL(protocol.getScheme(), calendar.getUrl(), calendar.getPort(), ""); ICalendarStore store = new ICalendarStore(url, RESOLVER); try { if(calendar.getLogin() != null && calendar.getPassword() != null && store.connect(calendar.getLogin(), calendar.getPassword())){ List<CalDavCalendarCollection> colList = store.getCollections(); if(!colList.isEmpty()){ calendar = doSync(calendar, colList.get(0)); calendarRepo.save(calendar); } } else{ throw new AxelorException(String.format(I18n.get(IExceptionMessage.CALENDAR_NOT_VALID)), IException.CONFIGURATION_ERROR); } } catch (Exception e) { throw new ICalendarException(e); } finally { store.disconnect(); } }