raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 10

Embedding the Uuid lib, deleting it from the embedded repo and dropping the jsr166z.jar

Browse source
This commit is contained in:
Viktor Klang 2011-03-02 16:34:21 +01:00
parent c9b699da0e
commit 407b631462
11 changed files with 1189 additions and 11 deletions
Download patch file Download diff file Expand all files Collapse all files

215
akka-actor/src/main/java/com/eaio/util/lang/Hex.java Normal file
View file

@ -0,0 +1,215 @@
/*
* Hex.java
*
* Created 04.07.2003.
*
* eaio: UUID - an implementation of the UUID specification Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com)
* http://eaio.com.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
* documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
package com.eaio.util.lang;
import java.io.IOException;
/**
* Number-to-hexadecimal and hexadecimal-to-number conversions.
*
* @see <a href="http://johannburkard.de/software/uuid/">UUID</a>
* @author <a href="mailto:jb@eaio.com">Johann Burkard</a>
* @version $Id: Hex.java 1888 2009-03-15 12:43:24Z johann $
*/
public final class Hex {
/**
* No instances needed.
*/
private Hex() {
super();
}
private static final char[] DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
'f' };
/**
* Turns a <code>short</code> into hex octets.
*
* @param a the {@link Appendable}, may not be <code>null</code>
* @param in the integer
* @return {@link Appendable}
*/
public static Appendable append(Appendable a, short in) {
return append(a, (long) in, 4);
}
/**
* Turns a <code>short</code> into hex octets.
*
* @param a the {@link Appendable}, may not be <code>null</code>
* @param in the integer
* @param length the number of octets to produce
* @return {@link Appendable}
*/
public static Appendable append(Appendable a, short in, int length) {
return append(a, (long) in, length);
}
/**
* Turns an <code>int</code> into hex octets.
*
* @param a the {@link Appendable}, may not be <code>null</code>
* @param in the integer
* @return {@link Appendable}
*/
public static Appendable append(Appendable a, int in) {
return append(a, (long) in, 8);
}
/**
* Turns an <code>int</code> into hex octets.
*
* @param a the {@link Appendable}, may not be <code>null</code>
* @param in the integer
* @param length the number of octets to produce
* @return {@link Appendable}
*/
public static Appendable append(Appendable a, int in, int length) {
return append(a, (long) in, length);
}
/**
* Turns a <code>long</code> into hex octets.
*
* @param a the {@link Appendable}, may not be <code>null</code>
* @param in the long
* @return {@link Appendable}
*/
public static Appendable append(Appendable a, long in) {
return append(a, in, 16);
}
/**
* Turns a <code>long</code> into hex octets.
*
* @param a the {@link Appendable}, may not be <code>null</code>
* @param in the long
* @param length the number of octets to produce
* @return {@link Appendable}
*/
public static Appendable append(Appendable a, long in, int length) {
try {
int lim = (length << 2) - 4;
while (lim >= 0) {
a.append(DIGITS[(byte) (in >> lim) & 0x0f]);
lim -= 4;
}
}
catch (IOException ex) {
// Bla
}
return a;
}
/**
* Turns a <code>byte</code> array into hex octets.
*
* @param a the {@link Appendable}, may not be <code>null</code>
* @param bytes the <code>byte</code> array
* @return {@link Appendable}
*/
public static Appendable append(Appendable a, byte[] bytes) {
try {
for (byte b : bytes) {
a.append(DIGITS[(byte) ((b & 0xF0) >> 4)]);
a.append(DIGITS[(byte) (b & 0x0F)]);
}
}
catch (IOException ex) {
// Bla
}
return a;
}
/**
* Parses a <code>long</code> from a hex encoded number. This method will skip all characters that are not 0-9,
* A-F and a-f.
* <p>
* Returns 0 if the {@link CharSequence} does not contain any interesting characters.
*
* @param s the {@link CharSequence} to extract a <code>long</code> from, may not be <code>null</code>
* @return a <code>long</code>
* @throws NullPointerException if the {@link CharSequence} is <code>null</code>
*/
public static long parseLong(CharSequence s) {
long out = 0;
byte shifts = 0;
char c;
for (int i = 0; i < s.length() && shifts < 16; i++) {
c = s.charAt(i);
if ((c > 47) && (c < 58)) {
++shifts;
out <<= 4;
out |= c - 48;
}
else if ((c > 64) && (c < 71)) {
++shifts;
out <<= 4;
out |= c - 55;
}
else if ((c > 96) && (c < 103)) {
++shifts;
out <<= 4;
out |= c - 87;
}
}
return out;
}
/**
* Parses a <code>short</code> from a hex encoded number. This method will skip all characters that are not 0-9,
* A-F and a-f.
* <p>
* Returns 0 if the {@link CharSequence} does not contain any interesting characters.
*
* @param s the {@link CharSequence} to extract a <code>short</code> from, may not be <code>null</code>
* @return a <code>short</code>
* @throws NullPointerException if the {@link CharSequence} is <code>null</code>
*/
public static short parseShort(String s) {
short out = 0;
byte shifts = 0;
char c;
for (int i = 0; i < s.length() && shifts < 4; i++) {
c = s.charAt(i);
if ((c > 47) && (c < 58)) {
++shifts;
out <<= 4;
out |= c - 48;
}
else if ((c > 64) && (c < 71)) {
++shifts;
out <<= 4;
out |= c - 55;
}
else if ((c > 96) && (c < 103)) {
++shifts;
out <<= 4;
out |= c - 87;
}
}
return out;
}
}

116
akka-actor/src/main/java/com/eaio/uuid/MACAddressParser.java Normal file
View file

@ -0,0 +1,116 @@
/*
* MACAddressParserTest.java
*
* Created 30.01.2006.
*
* eaio: UUID - an implementation of the UUID specification
* Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) http://eaio.com.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
package com.eaio.uuid;
/**
* The MAC address parser attempts to find the following patterns:
* <ul>
* <li>.{1,2}:.{1,2}:.{1,2}:.{1,2}:.{1,2}:.{1,2}</li>
* <li>.{1,2}-.{1,2}-.{1,2}-.{1,2}-.{1,2}-.{1,2}</li>
* </ul>
*
* @see <a href="http://johannburkard.de/software/uuid/">UUID</a>
* @author <a href="mailto:jb@eaio.com">Johann Burkard</a>
* @version $Id: MACAddressParser.java 1888 2009-03-15 12:43:24Z johann $
*/
class MACAddressParser {
/**
* No instances needed.
*/
private MACAddressParser() {
super();
}
/**
* Attempts to find a pattern in the given String.
*
* @param in the String, may not be <code>null</code>
* @return the substring that matches this pattern or <code>null</code>
*/
static String parse(String in) {
String out = in;
// lanscan
int hexStart = out.indexOf("0x");
if (hexStart != -1 && out.indexOf("ETHER") != -1) {
int hexEnd = out.indexOf(' ', hexStart);
if (hexEnd > hexStart + 2) {
out = out.substring(hexStart, hexEnd);
}
}
else {
int octets = 0;
int lastIndex, old, end;
if (out.indexOf('-') > -1) {
out = out.replace('-', ':');
}
lastIndex = out.lastIndexOf(':');
if (lastIndex > out.length() - 2) {
out = null;
}
else {
end = Math.min(out.length(), lastIndex + 3);
++octets;
old = lastIndex;
while (octets != 5 && lastIndex != -1 && lastIndex > 1) {
lastIndex = out.lastIndexOf(':', --lastIndex);
if (old - lastIndex == 3 || old - lastIndex == 2) {
++octets;
old = lastIndex;
}
}
if (octets == 5 && lastIndex > 1) {
out = out.substring(lastIndex - 2, end).trim();
}
else {
out = null;
}
}
}
if (out != null && out.startsWith("0x")) {
out = out.substring(2);
}
return out;
}
}

311
akka-actor/src/main/java/com/eaio/uuid/UUID.java Normal file
View file

@ -0,0 +1,311 @@
/*
* UUID.java
*
* Created 07.02.2003
*
* eaio: UUID - an implementation of the UUID specification
* Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) http://eaio.com.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
package com.eaio.uuid;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import org.omg.CORBA.portable.IDLEntity;
import com.eaio.util.lang.Hex;
/**
* Creates UUIDs according to the DCE Universal Token Identifier specification.
* <p>
* All you need to know:
* <pre>
* UUID u = new UUID();
* </pre>
*
* @see <a href="http://www.opengroup.org/onlinepubs/9629399/apdxa.htm">
* http://www.opengroup.org/onlinepubs/9629399/apdxa.htm
* </a>
* @see <a href="http://www.uddi.org/pubs/draft-leach-uuids-guids-01.txt">
* http://www.uddi.org/pubs/draft-leach-uuids-guids-01.txt
* </a>
* @see <a href="http://johannburkard.de/software/uuid/">UUID</a>
* @author <a href="mailto:jb@eaio.de">Johann Burkard</a>
* @version $Id: UUID.java 1888 2009-03-15 12:43:24Z johann $
*/
public class UUID implements Comparable<UUID>, Serializable, Cloneable,
IDLEntity {
/**
* Hasn't ever changed between versions.
*/
static final long serialVersionUID = 7435962790062944603L;
/**
* The time field of the UUID.
*
* @serial
*/
public long time;
/**
* The clock sequence and node field of the UUID.
*
* @serial
*/
public long clockSeqAndNode;
/**
* Constructor for UUID. Constructs a new, unique UUID.
*
* @see UUIDGen#newTime()
* @see UUIDGen#getClockSeqAndNode()
*/
public UUID() {
this(UUIDGen.newTime(), UUIDGen.getClockSeqAndNode());
}
/**
* Constructor for UUID. Constructs a UUID from two <code>long</code> values.
*
* @param time the upper 64 bits
* @param clockSeqAndNode the lower 64 bits
*/
public UUID(long time, long clockSeqAndNode) {
this.time = time;
this.clockSeqAndNode = clockSeqAndNode;
}
/**
* Copy constructor for UUID. Values of the given UUID are copied.
*
* @param u the UUID, may not be <code>null</code>
*/
public UUID(UUID u) {
this(u.time, u.clockSeqAndNode);
}
/**
* Parses a textual representation of a UUID.
* <p>
* No validation is performed. If the {@link CharSequence} is shorter than 36 characters,
* {@link ArrayIndexOutOfBoundsException}s will be thrown.
*
* @param s the {@link CharSequence}, may not be <code>null</code>
*/
public UUID(CharSequence s) {
this(Hex.parseLong(s.subSequence(0, 18)), Hex.parseLong(s.subSequence(
19, 36)));
}
/**
* Compares this UUID to another Object. Throws a {@link ClassCastException} if
* the other Object is not an instance of the UUID class. Returns a value
* smaller than zero if the other UUID is "larger" than this UUID and a value
* larger than zero if the other UUID is "smaller" than this UUID.
*
* @param t the other UUID, may not be <code>null</code>
* @return a value &lt; 0, 0 or a value &gt; 0
* @see java.lang.Comparable#compareTo(java.lang.Object)
* @throws ClassCastException
*/
public int compareTo(UUID t) {
if (this == t) {
return 0;
}
if (time > t.time) {
return 1;
}
if (time < t.time) {
return -1;
}
if (clockSeqAndNode > t.clockSeqAndNode) {
return 1;
}
if (clockSeqAndNode < t.clockSeqAndNode) {
return -1;
}
return 0;
}
/**
* Tweaked Serialization routine.
*
* @param out the ObjectOutputStream
* @throws IOException
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.writeLong(time);
out.writeLong(clockSeqAndNode);
}
/**
* Tweaked Serialization routine.
*
* @param in the ObjectInputStream
* @throws IOException
*/
private void readObject(ObjectInputStream in) throws IOException {
time = in.readLong();
clockSeqAndNode = in.readLong();
}
/**
* Returns this UUID as a String.
*
* @return a String, never <code>null</code>
* @see java.lang.Object#toString()
* @see #toAppendable(Appendable)
*/
@Override
public final String toString() {
return toAppendable(null).toString();
}
/**
* Appends a String representation of this to the given {@link StringBuffer} or
* creates a new one if none is given.
*
* @param in the StringBuffer to append to, may be <code>null</code>
* @return a StringBuffer, never <code>null</code>
* @see #toAppendable(Appendable)
*/
public StringBuffer toStringBuffer(StringBuffer in) {
StringBuffer out = in;
if (out == null) {
out = new StringBuffer(36);
}
else {
out.ensureCapacity(out.length() + 36);
}
return (StringBuffer) toAppendable(out);
}
/**
* Appends a String representation of this object to the given {@link Appendable} object.
* <p>
* For reasons I'll probably never understand, Sun has decided to have a number of I/O classes implement
* Appendable which forced them to destroy an otherwise nice and simple interface with {@link IOException}s.
* <p>
* I decided to ignore any possible IOExceptions in this method.
*
* @param a the Appendable object, may be <code>null</code>
* @return an Appendable object, defaults to a {@link StringBuilder} if <code>a</code> is <code>null</code>
*/
public Appendable toAppendable(Appendable a) {
Appendable out = a;
if (out == null) {
out = new StringBuilder(36);
}
try {
Hex.append(out, (int) (time >> 32)).append('-');
Hex.append(out, (short) (time >> 16)).append('-');
Hex.append(out, (short) time).append('-');
Hex.append(out, (short) (clockSeqAndNode >> 48)).append('-');
Hex.append(out, clockSeqAndNode, 12);
}
catch (IOException ex) {
// What were they thinking?
}
return out;
}
/**
* Returns a hash code of this UUID. The hash code is calculated by XOR'ing the
* upper 32 bits of the time and clockSeqAndNode fields and the lower 32 bits of
* the time and clockSeqAndNode fields.
*
* @return an <code>int</code> representing the hash code
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return (int) ((time >> 32) ^ time ^ (clockSeqAndNode >> 32) ^ clockSeqAndNode);
}
/**
* Clones this UUID.
*
* @return a new UUID with identical values, never <code>null</code>
*/
@Override
public Object clone() {
try {
return super.clone();
}
catch (CloneNotSupportedException ex) {
// One of Sun's most epic fails.
return null;
}
}
/**
* Returns the time field of the UUID (upper 64 bits).
*
* @return the time field
*/
public final long getTime() {
return time;
}
/**
* Returns the clock and node field of the UUID (lower 64 bits).
*
* @return the clockSeqAndNode field
*/
public final long getClockSeqAndNode() {
return clockSeqAndNode;
}
/**
* Compares two Objects for equality.
*
* @see java.lang.Object#equals(Object)
* @param obj the Object to compare this UUID with, may be <code>null</code>
* @return <code>true</code> if the other Object is equal to this UUID,
* <code>false</code> if not
*/
@Override
public boolean equals(Object obj) {
if (!(obj instanceof UUID)) {
return false;
}
return compareTo((UUID) obj) == 0;
}
/**
* Returns the nil UUID (a UUID whose values are both set to zero).
* <p>
* Starting with version 2.0, this method does return a new UUID instance every
* time it is called. Earlier versions returned one instance. This has now been
* changed because this UUID has public, non-final instance fields. Returning a
* new instance is therefore more safe.
*
* @return a nil UUID, never <code>null</code>
*/
public static UUID nilUUID() {
return new UUID(0, 0);
}
}

364
akka-actor/src/main/java/com/eaio/uuid/UUIDGen.java Normal file
View file

@ -0,0 +1,364 @@
/*
* UUIDGen.java
*
* Created on 09.08.2003.
*
* eaio: UUID - an implementation of the UUID specification
* Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) http://eaio.com.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
package com.eaio.uuid;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
import com.eaio.util.lang.Hex;
/**
* This class contains methods to generate UUID fields. These methods have been
* refactored out of {@link com.eaio.uuid.UUID}.
* <p>
* Starting with version 2, this implementation tries to obtain the MAC address
* of the network card. Under Microsoft Windows, the <code>ifconfig</code>
* command is used which may pop up a command window in Java Virtual Machines
* prior to 1.4 once this class is initialized. The command window is closed
* automatically.
* <p>
* The MAC address code has been tested extensively in Microsoft Windows,
* Linux, Solaris 8, HP-UX 11, but should work in MacOS X and BSDs, too.
* <p>
* If you use JDK 6 or later, the code in {@link InterfaceAddress} will be used.
*
* @see <a href="http://johannburkard.de/software/uuid/">UUID</a>
* @author <a href="mailto:jb@eaio.de">Johann Burkard</a>
* @version $Id: UUIDGen.java 2914 2010-04-23 11:35:00Z johann $
* @see com.eaio.uuid.UUID
*/
public final class UUIDGen {
/**
* No instances needed.
*/
private UUIDGen() {
super();
}
/**
* The last time value. Used to remove duplicate UUIDs.
*/
private static long lastTime = Long.MIN_VALUE;
/**
* The cached MAC address.
*/
private static String macAddress = null;
/**
* The current clock and node value.
*/
private static long clockSeqAndNode = 0x8000000000000000L;
static {
try {
Class.forName("java.net.InterfaceAddress");
macAddress = Class.forName(
"com.eaio.uuid.UUIDGen$HardwareAddressLookup").newInstance().toString();
}
catch (ExceptionInInitializerError err) {
// Ignored.
}
catch (ClassNotFoundException ex) {
// Ignored.
}
catch (LinkageError err) {
// Ignored.
}
catch (IllegalAccessException ex) {
// Ignored.
}
catch (InstantiationException ex) {
// Ignored.
}
catch (SecurityException ex) {
// Ignored.
}
if (macAddress == null) {
Process p = null;
BufferedReader in = null;
try {
String osname = System.getProperty("os.name", "");
if (osname.startsWith("Windows")) {
p = Runtime.getRuntime().exec(
new String[] { "ipconfig", "/all" }, null);
}
// Solaris code must appear before the generic code
else if (osname.startsWith("Solaris")
|| osname.startsWith("SunOS")) {
String hostName = getFirstLineOfCommand(
"uname", "-n" );
if (hostName != null) {
p = Runtime.getRuntime().exec(
new String[] { "/usr/sbin/arp", hostName },
null);
}
}
else if (new File("/usr/sbin/lanscan").exists()) {
p = Runtime.getRuntime().exec(
new String[] { "/usr/sbin/lanscan" }, null);
}
else if (new File("/sbin/ifconfig").exists()) {
p = Runtime.getRuntime().exec(
new String[] { "/sbin/ifconfig", "-a" }, null);
}
if (p != null) {
in = new BufferedReader(new InputStreamReader(
p.getInputStream()), 128);
String l = null;
while ((l = in.readLine()) != null) {
macAddress = MACAddressParser.parse(l);
if (macAddress != null
&& Hex.parseShort(macAddress) != 0xff) {
break;
}
}
}
}
catch (SecurityException ex) {
// Ignore it.
}
catch (IOException ex) {
// Ignore it.
}
finally {
if (p != null) {
if (in != null) {
try {
in.close();
}
catch (IOException ex) {
// Ignore it.
}
}
try {
p.getErrorStream().close();
}
catch (IOException ex) {
// Ignore it.
}
try {
p.getOutputStream().close();
}
catch (IOException ex) {
// Ignore it.
}
p.destroy();
}
}
}
if (macAddress != null) {
clockSeqAndNode |= Hex.parseLong(macAddress);
}
else {
try {
byte[] local = InetAddress.getLocalHost().getAddress();
clockSeqAndNode |= (local[0] << 24) & 0xFF000000L;
clockSeqAndNode |= (local[1] << 16) & 0xFF0000;
clockSeqAndNode |= (local[2] << 8) & 0xFF00;
clockSeqAndNode |= local[3] & 0xFF;
}
catch (UnknownHostException ex) {
clockSeqAndNode |= (long) (Math.random() * 0x7FFFFFFF);
}
}
// Skip the clock sequence generation process and use random instead.
clockSeqAndNode |= (long) (Math.random() * 0x3FFF) << 48;
}
/**
* Returns the current clockSeqAndNode value.
*
* @return the clockSeqAndNode value
* @see UUID#getClockSeqAndNode()
*/
public static long getClockSeqAndNode() {
return clockSeqAndNode;
}
/**
* Generates a new time field. Each time field is unique and larger than the
* previously generated time field.
*
* @return a new time value
* @see UUID#getTime()
*/
public static long newTime() {
return createTime(System.currentTimeMillis());
}
/**
* Creates a new time field from the given timestamp. Note that even identical
* values of <code>currentTimeMillis</code> will produce different time fields.
*
* @param currentTimeMillis the timestamp
* @return a new time value
* @see UUID#getTime()
*/
public static synchronized long createTime(long currentTimeMillis) {
long time;
// UTC time
long timeMillis = (currentTimeMillis * 10000) + 0x01B21DD213814000L;
if (timeMillis > lastTime) {
lastTime = timeMillis;
}
else {
timeMillis = ++lastTime;
}
// time low
time = timeMillis << 32;
// time mid
time |= (timeMillis & 0xFFFF00000000L) >> 16;
// time hi and version
time |= 0x1000 | ((timeMillis >> 48) & 0x0FFF); // version 1
return time;
}
/**
* Returns the MAC address. Not guaranteed to return anything.
*
* @return the MAC address, may be <code>null</code>
*/
public static String getMACAddress() {
return macAddress;
}
/**
* Returns the first line of the shell command.
*
* @param commands the commands to run
* @return the first line of the command
* @throws IOException
*/
static String getFirstLineOfCommand(String... commands) throws IOException {
Process p = null;
BufferedReader reader = null;
try {
p = Runtime.getRuntime().exec(commands);
reader = new BufferedReader(new InputStreamReader(
p.getInputStream()), 128);
return reader.readLine();
}
finally {
if (p != null) {
if (reader != null) {
try {
reader.close();
}
catch (IOException ex) {
// Ignore it.
}
}
try {
p.getErrorStream().close();
}
catch (IOException ex) {
// Ignore it.
}
try {
p.getOutputStream().close();
}
catch (IOException ex) {
// Ignore it.
}
p.destroy();
}
}
}
/**
* Scans MAC addresses for good ones.
*/
static class HardwareAddressLookup {
/**
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
String out = null;
try {
Enumeration<NetworkInterface> ifs = NetworkInterface.getNetworkInterfaces();
if (ifs != null) {
while (ifs.hasMoreElements()) {
NetworkInterface iface = ifs.nextElement();
byte[] hardware = iface.getHardwareAddress();
if (hardware != null && hardware.length == 6
&& hardware[1] != (byte) 0xff) {
out = Hex.append(new StringBuilder(36), hardware).toString();
break;
}
}
}
}
catch (SocketException ex) {
// Ignore it.
}
return out;
}
}
}

86
akka-actor/src/main/java/com/eaio/uuid/UUIDHelper.java Normal file
View file

@ -0,0 +1,86 @@
package com.eaio.uuid;
/**
* com/eaio/uuid/UUIDHelper.java .
* Generated by the IDL-to-Java compiler (portable), version "3.1"
* from uuid.idl
* Sonntag, 7. März 2004 21.35 Uhr CET
*/
/**
* The UUID struct.
*/
abstract public class UUIDHelper
{
private static String _id = "IDL:com/eaio/uuid/UUID:1.0";
public static void insert (org.omg.CORBA.Any a, com.eaio.uuid.UUID that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static com.eaio.uuid.UUID extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
private static boolean __active = false;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
synchronized (org.omg.CORBA.TypeCode.class)
{
if (__typeCode == null)
{
if (__active)
{
return org.omg.CORBA.ORB.init().create_recursive_tc ( _id );
}
__active = true;
org.omg.CORBA.StructMember[] _members0 = new org.omg.CORBA.StructMember [2];
org.omg.CORBA.TypeCode _tcOf_members0 = null;
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_longlong);
_members0[0] = new org.omg.CORBA.StructMember (
"time",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_longlong);
_members0[1] = new org.omg.CORBA.StructMember (
"clockSeqAndNode",
_tcOf_members0,
null);
__typeCode = org.omg.CORBA.ORB.init ().create_struct_tc (com.eaio.uuid.UUIDHelper.id (), "UUID", _members0);
__active = false;
}
}
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static com.eaio.uuid.UUID read (org.omg.CORBA.portable.InputStream istream)
{
com.eaio.uuid.UUID value = new com.eaio.uuid.UUID ();
value.time = istream.read_longlong ();
value.clockSeqAndNode = istream.read_longlong ();
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, com.eaio.uuid.UUID value)
{
ostream.write_longlong (value.time);
ostream.write_longlong (value.clockSeqAndNode);
}
}

42
akka-actor/src/main/java/com/eaio/uuid/UUIDHolder.java Normal file
View file

@ -0,0 +1,42 @@
package com.eaio.uuid;
/**
* com/eaio/uuid/UUIDHolder.java .
* Generated by the IDL-to-Java compiler (portable), version "3.1"
* from uuid.idl
* Sonntag, 7. März 2004 21.35 Uhr CET
*/
/**
* The UUID struct.
*/
public final class UUIDHolder implements org.omg.CORBA.portable.Streamable
{
public com.eaio.uuid.UUID value = null;
public UUIDHolder ()
{
}
public UUIDHolder (com.eaio.uuid.UUID initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = com.eaio.uuid.UUIDHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
com.eaio.uuid.UUIDHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return com.eaio.uuid.UUIDHelper.type ();
}
}

55
akka-actor/src/main/java/resources/uuid.idl Normal file
View file

@ -0,0 +1,55 @@
/*
* uuid.idl
*
* Created 19:49 16.12.2003
*
* eaio: UUID - an implementation of the UUID specification
* Copyright (c) 2003-2009 Johann Burkard (jb@eaio.com) http://eaio.com.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
module com {
module eaio {
module uuid {
/**
* The UUID struct.
*/
struct UUID {
/**
* The time field of the UUID.
*/
long long time;
/**
* The clock sequence and node field of the UUID.
*/
long long clockSeqAndNode;
};
};
};
};

BIN
embedded-repo/com/eaio/uuid/3.2/uuid-3.2.jar
View file

Binary file not shown.

8
embedded-repo/com/eaio/uuid/3.2/uuid-3.2.pom
View file

@ -1,8 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.eaio</groupId>
<artifactId>uuid</artifactId>
<version>3.2</version>
<packaging>jar</packaging>
</project>

BIN
embedded-repo/jsr166x/jsr166x/1.0/jsr166x-1.0.jar
View file

Binary file not shown.

3
project/build/AkkaProject.scala
View file

@ -149,8 +149,6 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
lazy val jetty_xml = "org.eclipse.jetty" % "jetty-xml" % JETTY_VERSION % "compile" //Eclipse license
lazy val jetty_servlet = "org.eclipse.jetty" % "jetty-servlet" % JETTY_VERSION % "compile" //Eclipse license
lazy val uuid = "com.eaio" % "uuid" % "3.2" % "compile" //MIT license
lazy val guicey = "org.guiceyfruit" % "guice-all" % "2.0" % "compile" //ApacheV2
lazy val h2_lzf = "voldemort.store.compress" % "h2-lzf" % "1.0" % "compile" //ApacheV2
@ -312,7 +310,6 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
// -------------------------------------------------------------------------------------------------------------------
class AkkaActorProject(info: ProjectInfo) extends AkkaDefaultProject(info, distPath) {
val uuid = Dependencies.uuid
val configgy = Dependencies.configgy
val logback = Dependencies.logback