private void addRemoveSlaves(
final MasterSlaveEntry entry,
final ClusterPartition currentPart,
final ClusterPartition newPart) {
Set<URI> removedSlaves = new HashSet<URI>(currentPart.getSlaveAddresses());
removedSlaves.removeAll(newPart.getSlaveAddresses());
for (URI uri : removedSlaves) {
currentPart.removeSlaveAddress(uri);
slaveDown(entry, uri.getHost(), uri.getPort(), FreezeReason.MANAGER);
log.info("slave {} removed for slot ranges: {}", uri, currentPart.getSlotRanges());
}
Set<URI> addedSlaves = new HashSet<URI>(newPart.getSlaveAddresses());
addedSlaves.removeAll(currentPart.getSlaveAddresses());
for (final URI uri : addedSlaves) {
Future<Void> future = entry.addSlave(uri.getHost(), uri.getPort());
future.addListener(
new FutureListener<Void>() {
@Override
public void operationComplete(Future<Void> future) throws Exception {
if (!future.isSuccess()) {
log.error("Can't add slave: " + uri, future.cause());
return;
}
currentPart.addSlaveAddress(uri);
entry.slaveUp(uri.getHost(), uri.getPort(), FreezeReason.MANAGER);
log.info("slave {} added for slot ranges: {}", uri, currentPart.getSlotRanges());
}
});
}
}
@Override
public int getPort() {
if (publicUri.getPort() == -1) {
return publicUri.getScheme().equalsIgnoreCase("https") ? 443 : 80;
}
return publicUri.getPort();
}
protected void bind() throws IOException {
URI bind = getBindLocation();
String host = bind.getHost();
host = (host == null || host.length() == 0) ? "localhost" : host;
InetAddress addr = InetAddress.getByName(host);
try {
if (host.trim().equals("localhost") || addr.equals(InetAddress.getLocalHost())) {
this.serverSocket = serverSocketFactory.createServerSocket(bind.getPort(), backlog);
} else {
this.serverSocket = serverSocketFactory.createServerSocket(bind.getPort(), backlog, addr);
}
this.serverSocket.setSoTimeout(2000);
} catch (IOException e) {
throw IOExceptionSupport.create(
"Failed to bind to server socket: " + bind + " due to: " + e, e);
}
try {
setConnectURI(
new URI(
bind.getScheme(),
bind.getUserInfo(),
resolveHostName(bind.getHost()),
serverSocket.getLocalPort(),
bind.getPath(),
bind.getQuery(),
bind.getFragment()));
} catch (URISyntaxException e) {
throw IOExceptionSupport.create(e);
}
}
/**
* Decodes a SmtpTransport URI.
*
* <p>Possible forms:
*
* <pre>
* smtp://user:password@server:port CONNECTION_SECURITY_NONE
* smtp+tls://user:password@server:port CONNECTION_SECURITY_TLS_OPTIONAL
* smtp+tls+://user:password@server:port CONNECTION_SECURITY_TLS_REQUIRED
* smtp+ssl+://user:password@server:port CONNECTION_SECURITY_SSL_REQUIRED
* smtp+ssl://user:password@server:port CONNECTION_SECURITY_SSL_OPTIONAL
* </pre>
*/
public static ServerSettings decodeUri(String uri) {
String host;
int port;
ConnectionSecurity connectionSecurity;
String authenticationType = AUTH_AUTOMATIC;
String username = null;
String password = null;
URI smtpUri;
try {
smtpUri = new URI(uri);
} catch (URISyntaxException use) {
throw new IllegalArgumentException("Invalid SmtpTransport URI", use);
}
String scheme = smtpUri.getScheme();
if (scheme.equals("smtp")) {
connectionSecurity = ConnectionSecurity.NONE;
port = 25;
} else if (scheme.equals("smtp+tls")) {
connectionSecurity = ConnectionSecurity.STARTTLS_OPTIONAL;
port = 25;
} else if (scheme.equals("smtp+tls+")) {
connectionSecurity = ConnectionSecurity.STARTTLS_REQUIRED;
port = 25;
} else if (scheme.equals("smtp+ssl+")) {
connectionSecurity = ConnectionSecurity.SSL_TLS_REQUIRED;
port = 465;
} else if (scheme.equals("smtp+ssl")) {
connectionSecurity = ConnectionSecurity.SSL_TLS_OPTIONAL;
port = 465;
} else {
throw new IllegalArgumentException("Unsupported protocol (" + scheme + ")");
}
host = smtpUri.getHost();
if (smtpUri.getPort() != -1) {
port = smtpUri.getPort();
}
if (smtpUri.getUserInfo() != null) {
try {
String[] userInfoParts = smtpUri.getUserInfo().split(":");
username = URLDecoder.decode(userInfoParts[0], "UTF-8");
if (userInfoParts.length > 1) {
password = URLDecoder.decode(userInfoParts[1], "UTF-8");
}
if (userInfoParts.length > 2) {
authenticationType = userInfoParts[2];
}
} catch (UnsupportedEncodingException enc) {
// This shouldn't happen since the encoding is hardcoded to UTF-8
throw new IllegalArgumentException("Couldn't urldecode username or password.", enc);
}
}
return new ServerSettings(
TRANSPORT_TYPE, host, port, connectionSecurity, authenticationType, username, password);
}
/** @tests java.net.URI(java.lang.String) */
public void test_ConstructorLjava_lang_String() throws URISyntaxException {
// Regression test for HARMONY-23
try {
new URI("%3");
fail("Assert 0: URI constructor failed to throw exception on invalid input.");
} catch (URISyntaxException e) {
// Expected
assertEquals("Assert 1: Wrong index in URISyntaxException.", 0, e.getIndex());
}
// Regression test for HARMONY-25
// if port value is negative, the authority should be considered registry-based.
URI uri = new URI("http://host:-8096/path/index.html");
assertEquals("Assert 2: returned wrong port value,", -1, uri.getPort());
assertNull("Assert 3: returned wrong host value,", uri.getHost());
try {
uri.parseServerAuthority();
fail("Assert 4: Expected URISyntaxException");
} catch (URISyntaxException e) {
// Expected
}
uri = new URI("http", "//myhost:-8096", null);
assertEquals("Assert 5: returned wrong port value,", -1, uri.getPort());
assertNull("Assert 6: returned wrong host value,", uri.getHost());
try {
uri.parseServerAuthority();
fail("Assert 7: Expected URISyntaxException");
} catch (URISyntaxException e) {
// Expected
}
}
/*
* see if two file systems are the same or not.
*/
private boolean compareFs(FileSystem srcFs, FileSystem destFs) {
URI srcUri = srcFs.getUri();
URI dstUri = destFs.getUri();
if (srcUri.getScheme() == null) {
return false;
}
if (!srcUri.getScheme().equals(dstUri.getScheme())) {
return false;
}
String srcHost = srcUri.getHost();
String dstHost = dstUri.getHost();
if ((srcHost != null) && (dstHost != null)) {
try {
srcHost = InetAddress.getByName(srcHost).getCanonicalHostName();
dstHost = InetAddress.getByName(dstHost).getCanonicalHostName();
} catch (UnknownHostException ue) {
return false;
}
if (!srcHost.equals(dstHost)) {
return false;
}
} else if (srcHost == null && dstHost != null) {
return false;
} else if (srcHost != null && dstHost == null) {
return false;
}
// check for ports
if (srcUri.getPort() != dstUri.getPort()) {
return false;
}
return true;
}
DnsNameResolver(
@Nullable String nsAuthority,
String name,
Attributes params,
Resource<ScheduledExecutorService> timerServiceResource,
Resource<ExecutorService> executorResource) {
// TODO: if a DNS server is provided as nsAuthority, use it.
// https://www.captechconsulting.com/blogs/accessing-the-dusty-corners-of-dns-with-java
this.timerServiceResource = timerServiceResource;
this.executorResource = executorResource;
// Must prepend a "//" to the name when constructing a URI, otherwise it will be treated as an
// opaque URI, thus the authority and host of the resulted URI would be null.
URI nameUri = URI.create("//" + name);
authority =
Preconditions.checkNotNull(
nameUri.getAuthority(), "nameUri (%s) doesn't have an authority", nameUri);
host = Preconditions.checkNotNull(nameUri.getHost(), "host");
if (nameUri.getPort() == -1) {
Integer defaultPort = params.get(NameResolver.Factory.PARAMS_DEFAULT_PORT);
if (defaultPort != null) {
port = defaultPort;
} else {
throw new IllegalArgumentException(
"name '" + name + "' doesn't contain a port, and default port is not set in params");
}
} else {
port = nameUri.getPort();
}
}
public NetServerSpecFactoryBean configure(URI uri) {
setHost(null != uri.getHost() ? uri.getHost() : "0.0.0.0");
setPort(uri.getPort() > 0 ? uri.getPort() : 3000);
setFraming(null != uri.getPath() ? uri.getPath().substring(1) : "linefeed");
this.delegateCodec = StandardCodecs.STRING_CODEC;
if (null != uri.getQuery()) {
String[] params = StringUtils.split(uri.getQuery(), "&");
if (null == params) {
params = new String[] {uri.getQuery()};
}
for (String pair : params) {
String[] parts = StringUtils.split(pair, "=");
if (parts.length > 1) {
if ("codec".equals(parts[0])) {
setCodec(parts[1]);
} else if ("dispatcher".equals(parts[0])) {
setDispatcher(parts[1]);
} else if ("lengthFieldLength".equals(parts[0])) {
setLengthFieldLength(Integer.parseInt(parts[1]));
}
}
}
}
return this;
}
private void checkMasterNodesChange(Collection<ClusterPartition> newPartitions) {
for (ClusterPartition newPart : newPartitions) {
for (ClusterPartition currentPart : lastPartitions.values()) {
if (!newPart.getMasterAddress().equals(currentPart.getMasterAddress())) {
continue;
}
// current master marked as failed
if (newPart.isMasterFail()) {
for (ClusterSlotRange currentSlotRange : currentPart.getSlotRanges()) {
ClusterPartition newMasterPart = find(newPartitions, currentSlotRange);
// does partition has a new master?
if (!newMasterPart.getMasterAddress().equals(currentPart.getMasterAddress())) {
log.info(
"changing master from {} to {} for {}",
currentPart.getMasterAddress(),
newMasterPart.getMasterAddress(),
currentSlotRange);
URI newUri = newMasterPart.getMasterAddress();
URI oldUri = currentPart.getMasterAddress();
changeMaster(currentSlotRange, newUri.getHost(), newUri.getPort());
slaveDown(currentSlotRange, oldUri.getHost(), oldUri.getPort(), FreezeReason.MANAGER);
currentPart.setMasterAddress(newMasterPart.getMasterAddress());
}
}
}
break;
}
}
}
public void setUp() {
if (uri == null) return;
if (config != null) {
if (config.getServletConfig().getInitParameter(REDIS_AUTH) != null) {
authToken = config.getServletConfig().getInitParameter(REDIS_AUTH);
}
if (config.getServletConfig().getInitParameter(REDIS_SERVER) != null) {
uri = URI.create(config.getServletConfig().getInitParameter(REDIS_SERVER));
}
}
jedisSubscriber = new Jedis(uri.getHost(), uri.getPort());
try {
jedisSubscriber.connect();
} catch (IOException e) {
logger.error("failed to connect subscriber", e);
}
jedisSubscriber.auth(authToken);
jedisSubscriber.flushAll();
jedisPublisher = new Jedis(uri.getHost(), uri.getPort());
try {
jedisPublisher.connect();
} catch (IOException e) {
logger.error("failed to connect publisher", e);
}
jedisPublisher.auth(authToken);
jedisPublisher.flushAll();
}
/**
* Helper method to check whether requests from the specified origin must be allowed.
*
* @param requestOrigin origin as reported by the client, {@code null} if unknown.
* @return {@code true} if the origin is allowed, else {@code false}.
*/
public boolean isAllowedOrigin(final String requestOrigin) {
if (allowAnyOrigin) {
return true;
}
if (requestOrigin == null) {
return false;
}
URI requestOriginURI;
try {
requestOriginURI = new URI(requestOrigin);
} catch (URISyntaxException e) {
return false;
}
String requestScheme = requestOriginURI.getScheme();
String requestHost = requestOriginURI.getHost();
int requestPort = requestOriginURI.getPort();
if (requestScheme == null || requestHost == null) {
return false;
}
for (URI allowedOrigin : allowedOrigins) {
if ((requestHost.equalsIgnoreCase(allowedOrigin.getHost())
|| requestHost.toLowerCase().endsWith("." + allowedOrigin.getHost().toLowerCase()))
&& requestPort == allowedOrigin.getPort()
&& requestScheme.equalsIgnoreCase(allowedOrigin.getScheme())) {
return true;
}
}
return false;
}
/**
* Valide le format de l'adresse du serveur et sépare le nom d'hôte ainsi que le port pour
* utilisation future. Utilise la classe URI de Java pour séparer les deux sections plus
* facilement.
*
* <p>Largement inspiré de cet exemple:
* http://stackoverflow.com/questions/2345063/java-common-way-to-validate-
* and-convert-hostport-to-inetsocketaddress
*
* @param adresse Adresse du serveur fournit par l'utilisateur.
* @return Si l'adresse est au format exigé ou non.
*/
public static boolean estValide(String adresse) {
boolean valide = true;
try {
// En cas d'adresse vide
if (adresse.equals("")) {
throw new URISyntaxException("", "L'adresse ne peut pas être vide.");
}
URI uri = new URI("my://" + adresse);
host = uri.getHost();
port = uri.getPort();
// Si le nom d'hôte est invalide
if (uri.getHost() == null || uri.getHost() == "")
throw new URISyntaxException(
uri.toString(), "L'adresse doit contenir un hôte au format valide.");
// Si le port est invalide
else if (uri.getPort() == -1)
throw new URISyntaxException(uri.toString(), "L'adresse doit contenir un port valide.");
} catch (URISyntaxException ex) {
valide = false;
JOptionPane.showMessageDialog(null, ex.getReason(), "Serveur", JOptionPane.WARNING_MESSAGE);
}
return valide;
}
public void parseURI(URI uri) throws URISyntaxException {
String protocol = uri.getScheme();
if (!protocol.equalsIgnoreCase("hdfs2")) {
throw new IllegalArgumentException(
"Unrecognized Cache protocol: " + protocol + " for uri: " + uri);
}
hostName = uri.getHost();
if (hostName == null) {
hostName = "localhost";
}
port = uri.getPort() == -1 ? HdfsConstants.DEFAULT_PORT : uri.getPort();
path = uri.getPath();
Map<String, Object> hdfsSettings = URISupport.parseParameters(uri);
overwrite = getBoolean(hdfsSettings, "overwrite", overwrite);
append = getBoolean(hdfsSettings, "append", append);
wantAppend = append;
bufferSize = getInteger(hdfsSettings, "bufferSize", bufferSize);
replication = getShort(hdfsSettings, "replication", replication);
blockSize = getLong(hdfsSettings, "blockSize", blockSize);
compressionType = getCompressionType(hdfsSettings, "compressionType", compressionType);
compressionCodec = getCompressionCodec(hdfsSettings, "compressionCodec", compressionCodec);
fileType = getFileType(hdfsSettings, "fileType", fileType);
fileSystemType = getFileSystemType(hdfsSettings, "fileSystemType", fileSystemType);
keyType = getWritableType(hdfsSettings, "keyType", keyType);
valueType = getWritableType(hdfsSettings, "valueType", valueType);
openedSuffix = getString(hdfsSettings, "openedSuffix", openedSuffix);
readSuffix = getString(hdfsSettings, "readSuffix", readSuffix);
initialDelay = getLong(hdfsSettings, "initialDelay", initialDelay);
delay = getLong(hdfsSettings, "delay", delay);
pattern = getString(hdfsSettings, "pattern", pattern);
chunkSize = getInteger(hdfsSettings, "chunkSize", chunkSize);
splitStrategies = getSplitStrategies(hdfsSettings);
}
/** * Creates a new FTPFile instance by converting the given file: URI into an abstract pathname. * * <p>FTP URI protocol:<br> * ftp:// [ userName [ : password ] @ ] host [ : port ][ / path ] * * <p>example:<br> * ftp://[email protected]:21/pub/testfile.txt * * @param uri An absolute, hierarchical URI using a supported scheme. * @throws NullPointerException if <code>uri</code> is <code>null</code>. * @throws IllegalArgumentException If the preconditions on the parameter do not hold. */ public FTPFile(URI uri) throws IOException, URISyntaxException { super(uri); if (uri.getScheme().equals("ftp")) { String userinfo = uri.getUserInfo(); if (userinfo != null) { int index = userinfo.indexOf(":"); if (index >= 0) { setFileSystem( new FTPFileSystem( new FTPAccount( uri.getHost(), uri.getPort(), userinfo.substring(0, index - 1), userinfo.substring(index + 1), uri.getPath()))); } else { setFileSystem( new FTPFileSystem( new FTPAccount(uri.getHost(), uri.getPort(), userinfo, "", uri.getPath()))); } } else { fileSystem = new FTPFileSystem( new FTPAccount(uri.getHost(), uri.getPort(), null, "", uri.getPath())); } setFileName(uri.getPath()); ftpClient = ((FTPFileSystem) fileSystem).getFTPClient(); } else { throw new URISyntaxException(uri.toString(), "Wrong URI scheme"); } }
public void run(URI uri) throws Exception {
int port = uri.getPort() > 0 ? uri.getPort() : BaseTestConfig.HTTPS_PORT;
String host = uri.getHost();
// Configure SSL context if necessary.
final SslContext sslCtx;
sslCtx =
SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).build();
// Configure the client.
EventLoopGroup group = new NioEventLoopGroup();
httpsInitializer = generateHttpsInitializer(sslCtx);
try {
Bootstrap b = new Bootstrap();
b.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000);
b.group(group).channel(NioSocketChannel.class).handler(httpsInitializer);
// Make the connection attempt.
startTime = System.nanoTime();
Channel ch = b.connect(host, port).sync().channel();
localAddress = ch.localAddress();
remoteAddress = ch.remoteAddress();
sendRequests(uri.toURL(), ch);
// Wait for the server to close the connection.
ch.closeFuture().sync();
endTime = System.nanoTime();
long duration = endTime - startTime;
logger.info(String.format("connection duration: %,dns (%d)", duration, duration));
} finally {
// Shut down executor threads to exit.
group.shutdownGracefully();
}
}
protected ServerSocket createSocket(URI uri)
throws IOException, NoSuchAlgorithmException, KeyManagementException {
SslConnector cnn = null;
ServerSocketFactory ssf = null;
cnn = (SslConnector) connector;
// An SSLContext is an environment for implementing JSSE
// It is used to create a ServerSocketFactory
SSLContext sslc = SSLContext.getInstance(cnn.getProtocol().toLowerCase());
// Initialize the SSLContext to work with our key managers
sslc.init(cnn.getKeyManagerFactory().getKeyManagers(), null, null);
ssf = sslc.getServerSocketFactory();
String host = StringUtils.defaultIfEmpty(uri.getHost(), "localhost");
int backlog = cnn.getBacklog();
SSLServerSocket serverSocket = null;
InetAddress inetAddress = InetAddress.getByName(host);
if (inetAddress.equals(InetAddress.getLocalHost())
|| inetAddress.isLoopbackAddress()
|| host.trim().equals("localhost")) {
serverSocket = (SSLServerSocket) ssf.createServerSocket(uri.getPort(), backlog);
} else {
serverSocket = (SSLServerSocket) ssf.createServerSocket(uri.getPort(), backlog, inetAddress);
}
// Authenticate the client?
serverSocket.setNeedClientAuth(cnn.isRequireClientAuthentication());
return serverSocket;
}
@Override
public UriBuilder uri(URI uri) {
if (uri == null) {
throw new IllegalArgumentException("URI parameter is null");
}
if (uri.getRawFragment() != null) {
fragment = uri.getRawFragment();
}
if (uri.isOpaque()) {
scheme = uri.getScheme();
ssp = uri.getRawSchemeSpecificPart();
return this;
}
if (uri.getScheme() == null) {
if (ssp != null) {
if (uri.getRawSchemeSpecificPart() != null) {
ssp = uri.getRawSchemeSpecificPart();
return this;
}
}
} else {
scheme = uri.getScheme();
}
ssp = null;
if (uri.getRawAuthority() != null) {
if (uri.getRawUserInfo() == null && uri.getHost() == null && uri.getPort() == -1) {
authority = uri.getRawAuthority();
userInfo = null;
host = null;
port = -1;
} else {
authority = null;
if (uri.getRawUserInfo() != null) {
userInfo = uri.getRawUserInfo();
}
if (uri.getHost() != null) {
host = uri.getHost();
}
if (uri.getPort() != -1) {
port = uri.getPort();
}
}
}
if (uri.getRawPath() != null && uri.getRawPath().length() > 0) {
path.setLength(0);
path.append(uri.getRawPath());
}
if (uri.getRawQuery() != null && uri.getRawQuery().length() > 0) {
query.setLength(0);
query.append(uri.getRawQuery());
}
return this;
}
public int getSchemePort(URI uri) {
if (uri.getScheme() == null || !uri.getScheme().equals(scheme)) return -1;
if (uri.getPort() == -1) {
return port;
} else {
return uri.getPort();
}
}
private int getPort(URI uri) {
if (uri.getScheme().equals("http") && uri.getPort() == 80
|| uri.getScheme().equals("https") && uri.getPort() == 443) {
return -1;
} else {
return uri.getPort();
}
}
private @Nullable Distribution toDistribution(
@Nonnull ProviderContext ctx, @Nullable String container)
throws CloudException, InternalException {
if (container == null) {
return null;
}
NovaMethod method = new NovaMethod(provider);
Map<String, String> headers = method.headResource(SERVICE, RESOURCE, container);
if (headers == null) {
return null;
}
String enabled = null, uriString = null;
for (String key : headers.keySet()) {
if (key.equalsIgnoreCase("X-CDN-Enabled")) {
enabled = headers.get(key);
} else if (key.equalsIgnoreCase("X-CDN-URI")) {
if (uriString == null) {
uriString = headers.get(key);
}
} else if (key.equalsIgnoreCase("X-CDN-SSL-URI")) {
uriString = headers.get(key);
}
}
if (uriString == null) {
return null;
}
String dns;
try {
URI uri = new URI(uriString);
dns = uri.getHost();
if (uri.getPort() > 0) {
if (dns.startsWith("https:") && uri.getPort() != 443) {
dns = dns + ":" + uri.getPort();
}
if (dns.startsWith("http:") && uri.getPort() != 80) {
dns = dns + ":" + uri.getPort();
}
}
} catch (URISyntaxException e) {
throw new CloudException(e);
}
Distribution distribution = new Distribution();
distribution.setName(container);
distribution.setActive(enabled != null && enabled.equalsIgnoreCase("true"));
distribution.setAliases(new String[0]);
distribution.setDeployed(enabled != null && enabled.equalsIgnoreCase("true"));
distribution.setDnsName(dns);
distribution.setLocation(uriString);
distribution.setLogDirectory(null);
distribution.setProviderDistributionId(container);
distribution.setProviderOwnerId(getTenantId());
return distribution;
}
private static String localIp(String cloudControllerUri) {
final URI uri = URI.create(cloudControllerUri);
final int port = uri.getPort() == -1 ? 80 : uri.getPort();
try (Socket socket = new Socket(uri.getHost(), port)) {
return socket.getLocalAddress().getHostAddress();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
protected void connect() throws Exception {
if (socket == null && socketFactory == null) {
throw new IllegalStateException(
"Cannot connect if the socket or socketFactory have not been set");
}
InetSocketAddress localAddress = null;
InetSocketAddress remoteAddress = null;
if (localLocation != null) {
localAddress =
new InetSocketAddress(
InetAddress.getByName(localLocation.getHost()), localLocation.getPort());
}
if (remoteLocation != null) {
String host = resolveHostName(remoteLocation.getHost());
remoteAddress = new InetSocketAddress(host, remoteLocation.getPort());
}
// Set the traffic class before the socket is connected when possible so
// that the connection packets are given the correct traffic class.
this.trafficClassSet = setTrafficClass(socket);
if (socket != null) {
if (localAddress != null) {
socket.bind(localAddress);
}
// If it's a server accepted socket.. we don't need to connect it
// to a remote address.
if (remoteAddress != null) {
if (connectionTimeout >= 0) {
socket.connect(remoteAddress, connectionTimeout);
} else {
socket.connect(remoteAddress);
}
}
} else {
// For SSL sockets.. you can't create an unconnected socket :(
// This means the timout option are not supported either.
if (localAddress != null) {
socket =
socketFactory.createSocket(
remoteAddress.getAddress(), remoteAddress.getPort(),
localAddress.getAddress(), localAddress.getPort());
} else {
socket = socketFactory.createSocket(remoteAddress.getAddress(), remoteAddress.getPort());
}
}
initialiseSocket(socket);
initializeStreams();
}
/**
* Return the complete host of the uri
*
* @param uri the uri to extract host from
* @return the complete host of the uri
*/
public static String getCompleteHost(URI uri) {
if (uri.getPort() > 0) {
return uri.getScheme()
+ HtmlConstants.SCHEME_AND_AUTHORITY_SEPARATOR
+ uri.getHost()
+ ":"
+ uri.getPort();
}
return uri.getScheme() + HtmlConstants.SCHEME_AND_AUTHORITY_SEPARATOR + uri.getHost();
}
private ServerAddress createServerAddress(String uriProperty)
throws URISyntaxException, UnknownHostException {
URI uri = new URI(uriProperty);
int port = uri.getPort();
ServerAddress serverAddress =
port == -1
? new ServerAddress(uri.getHost())
: new ServerAddress(uri.getHost(), uri.getPort());
return serverAddress;
}
public ClusterInstance instance(String to) throws URISyntaxException {
URI uri = new URI(to);
for (ClusterInstance clusterInstance : instances) {
URI instanceUri = clusterInstance.uri();
if (instanceUri.getHost().equals(uri.getHost()) && instanceUri.getPort() == uri.getPort()) {
return clusterInstance;
}
}
throw new IllegalArgumentException("No instance in cluster at address: " + to);
}
@SqlNullable
@Description("extract port from url")
@ScalarFunction
@LiteralParameters("x")
@SqlType(StandardTypes.BIGINT)
public static Long urlExtractPort(@SqlType("varchar(x)") Slice url) {
URI uri = parseUrl(url);
if ((uri == null) || (uri.getPort() < 0)) {
return null;
}
return (long) uri.getPort();
}
public void setUri(URI uri, int defaultPort) {
mHost = uri.getHost();
mPort = defaultPort;
if (uri.getPort() != -1) {
mPort = uri.getPort();
}
if (uri.getUserInfo() != null) {
mUserInfoParts = uri.getUserInfo().split(":", 2);
}
}
private static void addHostHeader(
final Request request, final URI uri, final HttpRequestPacket requestPacket) {
String host = request.getVirtualHost();
if (host != null) {
requestPacket.addHeader(Header.Host, host);
} else {
if (uri.getPort() == -1) {
requestPacket.addHeader(Header.Host, uri.getHost());
} else {
requestPacket.addHeader(Header.Host, uri.getHost() + ':' + uri.getPort());
}
}
}
/**
* XMLRPCClient constructor. Creates new instance based on server URI
*
* @param XMLRPC server URI
*/
public XMLRPCClient(URI uri, String httpuser, String httppasswd) {
postMethod = new HttpPost(uri);
postMethod.addHeader("Content-Type", "text/xml");
postMethod.addHeader("charset", "UTF-8");
// UPDATE THE VERSION NUMBER BEFORE RELEASE! <3 Dan
postMethod.addHeader("User-Agent", "evodroid/" + Constants.versionNumber);
httpParams = postMethod.getParams();
HttpProtocolParams.setUseExpectContinue(httpParams, false);
// username & password not needed
UsernamePasswordCredentials creds = new UsernamePasswordCredentials(httpuser, httppasswd);
// this gets connections working over https
if (uri.getScheme() != null) {
if (uri.getScheme().equals("https")) {
if (uri.getPort() == -1)
try {
client = new ConnectionClient(creds, 443);
} catch (KeyManagementException e) {
client = new ConnectionClient(creds);
} catch (NoSuchAlgorithmException e) {
client = new ConnectionClient(creds);
} catch (KeyStoreException e) {
client = new ConnectionClient(creds);
} catch (UnrecoverableKeyException e) {
client = new ConnectionClient(creds);
}
else
try {
client = new ConnectionClient(creds, uri.getPort());
} catch (KeyManagementException e) {
client = new ConnectionClient(creds);
} catch (NoSuchAlgorithmException e) {
client = new ConnectionClient(creds);
} catch (KeyStoreException e) {
client = new ConnectionClient(creds);
} catch (UnrecoverableKeyException e) {
client = new ConnectionClient(creds);
}
} else {
client = new ConnectionClient(creds);
}
} else {
client = new ConnectionClient(creds);
}
serializer = Xml.newSerializer();
}
private void convertPort(Port port) throws IOException {
String comment = "";
String name = port.getName();
String protocol = "soap";
String location = "socket://localhost:80/";
if (port.getDocumentationElement() != null) {
comment = port.getDocumentationElement().getNodeValue();
}
List<ExtensibilityElement> extElements = port.getExtensibilityElements();
for (ExtensibilityElement element : extElements) {
if (element instanceof SOAPAddress) {
location = ((SOAPAddress) element).getLocationURI().toString();
StringBuilder builder = new StringBuilder();
builder
.append("soap {\n")
.append("\t.wsdl = \"")
.append(definition.getDocumentBaseURI())
.append("\";\n")
.append("\t.wsdl.port = \"")
.append(port.getName())
.append("\"\n}");
protocol = builder.toString();
} else if (element instanceof HTTPAddress) {
location = ((HTTPAddress) element).getLocationURI().toString();
protocol = "http";
}
}
try {
URI uri = new URI(location);
uri =
new URI(
"socket",
uri.getUserInfo(),
uri.getHost(),
(uri.getPort() < 1) ? 80 : uri.getPort(),
uri.getPath(),
uri.getQuery(),
uri.getFragment());
location = uri.toString();
} catch (URISyntaxException e) {
e.printStackTrace();
}
Binding binding = port.getBinding();
PortType portType = binding.getPortType();
convertPortType(portType, binding);
outputPorts.put(
name,
new OutputPort(name, location, protocol, portType.getQName().getLocalPart(), comment));
}
