public boolean send(@NotNull Value value, @Optional JMSQueue replyTo) throws JMSException {
Message message = null;
if (value.isArray()) {
message = _session.createMapMessage();
ArrayValue array = (ArrayValue) value;
Set<Map.Entry<Value, Value>> entrySet = array.entrySet();
for (Map.Entry<Value, Value> entry : entrySet) {
if (entry.getValue() instanceof BinaryValue) {
byte[] bytes = ((BinaryValue) entry.getValue()).toBytes();
((MapMessage) message).setBytes(entry.getKey().toString(), bytes);
} else {
// every primitive except for bytes can be translated from a string
((MapMessage) message).setString(entry.getKey().toString(), entry.getValue().toString());
}
}
} else if (value instanceof BinaryValue) {
message = _session.createBytesMessage();
byte[] bytes = ((BinaryValue) value).toBytes();
((BytesMessage) message).writeBytes(bytes);
} else if (value.isLongConvertible()) {
message = _session.createStreamMessage();
((StreamMessage) message).writeLong(value.toLong());
} else if (value.isDoubleConvertible()) {
message = _session.createStreamMessage();
((StreamMessage) message).writeDouble(value.toDouble());
} else if (value.toJavaObject() instanceof String) {
message = _session.createTextMessage();
((TextMessage) message).setText(value.toString());
} else if (value.toJavaObject() instanceof Serializable) {
message = _session.createObjectMessage();
((ObjectMessage) message).setObject((Serializable) value.toJavaObject());
} else {
return false;
}
if (replyTo != null) message.setJMSReplyTo(replyTo._destination);
_producer.send(message);
return true;
}
public static String store2Hdfs(Key srcKey) {
assert srcKey._kb[0] != Key.ARRAYLET_CHUNK;
assert PersistHdfs.getPathForKey(srcKey) != null; // Validate key name
Value v = DKV.get(srcKey);
if (v == null) return "Key " + srcKey + " not found";
if (!v.isArray()) { // Simple chunk?
v.setHdfs(); // Set to HDFS and be done
return null; // Success
}
// For ValueArrays, make the .hex header
ValueArray ary = v.get();
String err = PersistHdfs.freeze(srcKey, ary);
if (err != null) return err;
// The task managing which chunks to write next,
// store in a known key
TaskStore2HDFS ts = new TaskStore2HDFS(srcKey);
Key selfKey = ts.selfKey();
UKV.put(selfKey, ts);
// Then start writing chunks in-order with the zero chunk
H2ONode chk0_home = ValueArray.getChunkKey(0, srcKey).home_node();
RPC.call(ts.chunkHome(), ts);
// Watch the progress key until it gets removed or an error appears
long idx = 0;
while ((ts = UKV.get(selfKey, TaskStore2HDFS.class)) != null) {
if (ts._indexFrom != idx) {
System.out.print(" " + idx + "/" + ary.chunks());
idx = ts._indexFrom;
}
if (ts._err != null) { // Found an error?
UKV.remove(selfKey); // Cleanup & report
return ts._err;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
}
System.out.println(" " + ary.chunks() + "/" + ary.chunks());
// PersistHdfs.refreshHDFSKeys();
return null;
}
// Store Value v to disk.
static void fileStore(Value v) {
// Only the home node does persistence on NFS
if (!v._key.home()) return;
// A perhaps useless cutout: the upper layers should test this first.
if (v.isPersisted()) return;
// Never store arraylets on NFS, instead we'll store the entire array.
assert !v.isArray();
try {
File f = getFileForKey(v._key);
f.mkdirs();
FileOutputStream s = new FileOutputStream(f);
try {
byte[] m = v.memOrLoad();
assert (m == null || m.length == v._max); // Assert not saving partial files
if (m != null) new AutoBuffer(s.getChannel(), false, Value.NFS).putA1(m, m.length).close();
v.setdsk(); // Set as write-complete to disk
} finally {
s.close();
}
} catch (IOException e) {
H2O.ignore(e);
}
}
public static void addFormValue(
Env env,
ArrayValue array,
String key,
Value formValue,
String[] formValueList,
boolean addSlashesToValues) {
int p = -1;
int q = -1;
if (key != null) {
p = key.indexOf('[');
q = key.indexOf(']', p);
}
if (p >= 0 && p < q) {
String index = key;
Value keyValue;
Value existingValue;
if (p > 0) {
key = key.substring(0, p);
key = key.replaceAll("\\.", "_");
keyValue = env.createString(key);
existingValue = array.get(keyValue);
if (existingValue == null || !existingValue.isset()) {
existingValue = new ArrayValueImpl();
array.put(keyValue, existingValue);
} else if (!existingValue.isArray()) {
// existing is overwritten
// php/115g
existingValue = new ArrayValueImpl();
array.put(keyValue, existingValue);
}
array = (ArrayValue) existingValue;
}
int p1;
while ((p1 = index.indexOf('[', q)) > 0) {
key = index.substring(p + 1, q);
if (key.equals("")) {
existingValue = new ArrayValueImpl();
array.put(existingValue);
} else {
keyValue = env.createString(key);
existingValue = array.get(keyValue);
if (existingValue == null || !existingValue.isset()) {
existingValue = new ArrayValueImpl();
array.put(keyValue, existingValue);
} else if (!existingValue.isArray()) {
existingValue = new ArrayValueImpl().put(existingValue);
array.put(keyValue, existingValue);
}
}
array = (ArrayValue) existingValue;
p = p1;
q = index.indexOf(']', p);
}
if (q > 0) index = index.substring(p + 1, q);
else index = index.substring(p + 1);
if (index.equals("")) {
if (formValueList != null) {
for (int i = 0; i < formValueList.length; i++) {
Value value;
if (formValueList[i] != null) value = env.createString(formValueList[i]);
else value = NullValue.NULL;
put(array, null, value, addSlashesToValues);
}
} else array.put(formValue);
} else if ('0' <= index.charAt(0) && index.charAt(0) <= '9')
put(array, LongValue.create(StringValue.toLong(index)), formValue, addSlashesToValues);
else put(array, env.createString(index), formValue, addSlashesToValues);
} else {
if (key != null) {
key = key.replaceAll("\\.", "_");
put(array, env.createString(key), formValue, addSlashesToValues);
} else {
put(array, null, formValue, addSlashesToValues);
}
}
}
