andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'Netty/master' into fix-414

Browse Source
This commit is contained in:
Cruz Julian Bishop 2012-06-29 13:02:32 +10:00
commit 00ae0e8ad9
4 changed files with 120 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
codec-http/src/main/java/io/netty/handler/codec/spdy/SpdyHttpHeaders.java
View File

@ -165,6 +165,6 @@ public final class SpdyHttpHeaders {
* Sets the {@code "X-SPDY-Scheme"} header.
*/
public static void setScheme(HttpMessage message, String scheme) {
message.setHeader(Names.URL, scheme);
message.setHeader(Names.SCHEME, scheme);
}
}

69
common/src/main/java/io/netty/util/NetworkConstants.java
View File

@ -24,62 +24,101 @@ import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
/**
* A class that holds a number of network-related constants.
*/
public final class NetworkConstants {
/**
* The {@link InetAddress} representing the host machine
*
* We cache this because some machines take almost forever to return from
* {@link InetAddress}.getLocalHost(). This may be due to incorrect
* configuration of the hosts and DNS client configuration files.
*/
public static final InetAddress LOCALHOST;
/**
* The loopback {@link NetworkInterface} on the current machine
*/
public static final NetworkInterface LOOPBACK_IF;
/**
* The logger being used by this class
*/
private static final InternalLogger logger =
InternalLoggerFactory.getInstance(NetworkConstants.class);
static {
// We cache this because some machine takes almost forever to return
// from InetAddress.getLocalHost(). I think it's due to the incorrect
// /etc/hosts or /etc/resolve.conf.
//Start the process of discovering localhost
InetAddress localhost = null;
try {
//Let's start by getting localhost automatically
localhost = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
//No? That's okay.
try {
//Try to force an IPv4 localhost address
localhost = InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 });
} catch (UnknownHostException e1) {
//No? Okay. You must be using IPv6
try {
//Try to force an IPv6 localhost address
localhost = InetAddress.getByAddress(
new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 });
} catch (UnknownHostException e2) {
logger.error("Failed to resolve localhost", e2);
//No? Okay.
logger.error("Failed to resolve localhost - Incorrect network configuration?", e2);
}
}
}
//Set the localhost constant
LOCALHOST = localhost;
NetworkInterface loopbackIf;
//Prepare to get the local NetworkInterface
NetworkInterface loopbackInterface;
try {
loopbackIf = NetworkInterface.getByInetAddress(LOCALHOST);
//Automatically get the loopback interface
loopbackInterface = NetworkInterface.getByInetAddress(LOCALHOST);
} catch (SocketException e) {
loopbackIf = null;
//No? Alright. There is a backup!
loopbackInterface = null;
}
// If null is returned, iterate over all the available network interfaces.
if (loopbackIf == null) {
//Check to see if a network interface was not found
if (loopbackInterface == null) {
try {
for (Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();
e.hasMoreElements();) {
NetworkInterface nif = e.nextElement();
if (nif.isLoopback()) {
loopbackIf = nif;
//Start iterating over all network interfaces
for (Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
interfaces.hasMoreElements();) {
//Get the "next" interface
NetworkInterface networkInterface = interfaces.nextElement();
//Check to see if the interface is a loopback interface
if (networkInterface.isLoopback()) {
//Phew! The loopback interface was found.
loopbackInterface = networkInterface;
//No need to keep iterating
break;
}
}
} catch (SocketException e) {
//Nope. Can't do anything else, sorry!
logger.error("Failed to enumerate network interfaces", e);
}
}
LOOPBACK_IF = loopbackIf;
//Set the loopback interface constant
LOOPBACK_IF = loopbackInterface;
}
/**
* A constructor to stop this class being constructed.
*/
private NetworkConstants() {
// Unused
}

60
common/src/main/java/io/netty/util/internal/NonReentrantLock.java
View File

@ -20,48 +20,97 @@ import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
* A custom implementation of a lock that does not allow reentry
*/
public final class NonReentrantLock extends AbstractQueuedSynchronizer
implements Lock {
/**
* The serial version unique ID
*/
private static final long serialVersionUID = -833780837233068610L;
/**
* The {@link Thread} that owns this {@link NonReentrantLock}
*/
private Thread owner;
/**
* Locks this {@link NonReentrantLock}
*/
@Override
public void lock() {
acquire(1);
}
/**
* Locks this {@link NonReentrantLock}, but allow interruption
*
* @throws InterruptedException The lock was interrupted
*/
@Override
public void lockInterruptibly() throws InterruptedException {
acquireInterruptibly(1);
}
/**
* Try to lock this {@link NonReentrantLock}
*
* @return True if locking was successful, otherwise false
*/
@Override
public boolean tryLock() {
return tryAcquire(1);
}
/**
* Tries to lock this {@link NonReentrantLock} over a period of time
*
* @param time The maximum number of time units to attempt to get a lock for.
* @param unit The {@link TimeUnit} associated with the time parameter
* @return True if the lock was successful, otherwise false
* @throws InterruptedException The locking attempt was interrupted
*/
@Override
public boolean tryLock(long time, TimeUnit unit)
throws InterruptedException {
return tryAcquireNanos(1, unit.toNanos(time));
}
/**
* Unlocks this {@link NonReentrantLock}
*/
@Override
public void unlock() {
release(1);
}
/**
* Checks to see if this {@link NonReentrantLock} is held by the current {@link Thread}
*
* @return True if held by the current thread, otherwise false
*/
public boolean isHeldByCurrentThread() {
return isHeldExclusively();
}
/**
* Creates a new {@link Condition}
*
* @return The condition object
*/
@Override
public Condition newCondition() {
return new ConditionObject();
}
/**
* Try to acquire a lock
*
* @param acquires A number that is sent by acquiring methods
* @return True if a lock is acquired, otherwise false
*/
@Override
protected boolean tryAcquire(int acquires) {
if (compareAndSetState(0, 1)) {
@ -71,6 +120,12 @@ public final class NonReentrantLock extends AbstractQueuedSynchronizer
return false;
}
/**
* Tries to release the lock
*
* @param releases A number that is passed by the release methods
* @return True if a release is granted, otherwise false
*/
@Override
protected boolean tryRelease(int releases) {
if (Thread.currentThread() != owner) {
@ -81,6 +136,11 @@ public final class NonReentrantLock extends AbstractQueuedSynchronizer
return true;
}
/**
* Checks to see if this {@link NonReentrantLock} is held exclusively by the current {@link Thread}
*
* @return True if held exclusively, otherwise false
*/
@Override
protected boolean isHeldExclusively() {
return getState() != 0 && owner == Thread.currentThread();

8
pom.xml
View File

@ -216,7 +216,7 @@
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.6.4</version>
<version>1.6.6</version>
<scope>test</scope>
</dependency>
@ -226,7 +226,7 @@
<plugins>
<plugin>
<artifactId>maven-enforcer-plugin</artifactId>
<version>1.0.1</version>
<version>1.1</version>
<executions>
<execution>
<id>enforce-tools</id>
@ -266,7 +266,7 @@
be used even when compiling with java 1.7+ -->
<groupId>org.codehaus.mojo</groupId>
<artifactId>animal-sniffer-maven-plugin</artifactId>
<version>1.7</version>
<version>1.8</version>
<configuration>
<signature>
<groupId>org.codehaus.mojo.signature</groupId>
@ -345,7 +345,7 @@
</plugin>
<plugin>
<artifactId>maven-release-plugin</artifactId>
<version>2.3.1</version>
<version>2.3.2</version>
<configuration>
<releaseProfiles>release,full</releaseProfiles>
</configuration>