/** @return The hashing values for the user source that were stored in the backup */
public Hashing getHashing() {
prisms.util.LongList mults = new prisms.util.LongList();
prisms.util.LongList mods = new prisms.util.LongList();
try {
if (!"hashing".equals(theJsonReader.getNextProperty())) return null;
JsonSerialReader.StructState rootState = theJsonReader.startObject();
try {
if (!"multiples".equals(theJsonReader.getNextProperty())) return null;
theJsonReader.startArray();
Number num;
do {
num = theJsonReader.parseNumber();
if (num != null) mults.add(num.longValue());
} while (num != null);
theJsonReader.endArray(null);
if (!"modulos".equals(theJsonReader.getNextProperty())) return null;
theJsonReader.startArray();
do {
num = theJsonReader.parseNumber();
if (num != null) mods.add(num.longValue());
} while (num != null);
theJsonReader.endArray(null);
} finally {
theJsonReader.endObject(rootState);
}
} catch (Exception e) {
log.error("Could not read JSON backup data", e);
return null;
}
Hashing ret = new Hashing();
ret.setPrimaryHashing(mults.toArray(), mods.toArray());
return ret;
}
void importData(
PrismsApplication app,
PrismsSynchronizer sync,
String version,
JsonSerialReader jsr,
StringBuilder message)
throws java.io.IOException, SAJParser.ParseException {
SyncRecord syncRecord =
new SyncRecord(
new PrismsCenter("Export"),
SyncRecord.Type.AUTOMATIC,
System.currentTimeMillis(),
false);
PrismsSynchronizer.SyncTransaction trans =
sync.transact(
version, true, syncRecord, false, new prisms.ui.UI.DefaultProgressInformer());
// Items
PrismsSynchronizer.PS2ItemReader itemReader = new PrismsSynchronizer.PS2ItemReader(trans);
if (!jsr.goToProperty("items")) {
message.append("\n\t\tNo items property in sync data");
return;
}
int items = 0;
org.json.simple.JSONObject obj;
jsr.startArray();
obj = jsr.parseObject();
while (obj != null) {
items++;
try {
itemReader.read(obj);
} catch (PrismsRecordException e) {
log.error("Error parsing item", e);
}
obj = jsr.parseObject();
}
jsr.endArray(null);
message.append("\n\t\t").append(items).append(" items");
PrismsCenter[] centers;
try {
centers = sync.getKeeper().getCenters();
} catch (PrismsRecordException e) {
message.append("\n\t\t").append("Could not get centers");
log.error("Could not get centers", e);
centers = null;
}
if (centers != null && trans.getImpl().getCentersProperty() != null) {
PrismsCenter[] appCenters = centers;
for (int i = 0; i < appCenters.length; i++)
if (centers[i].getID() == 0) {
// Don't include the "Here" center in the UI value
appCenters = prisms.util.ArrayUtils.remove(appCenters, i);
break;
}
app.setGlobalProperty(
trans.getImpl().getCentersProperty(),
appCenters,
RecordUtils.TRANSACTION_EVENT_PROP,
new prisms.records.RecordsTransaction());
}
// Changes
PrismsSynchronizer.ChangeReader changeReader =
new PrismsSynchronizer.ChangeReader(trans, null, itemReader, 0);
if (!jsr.goToProperty("changes")) {
message.append("\n\t\tNo changes property in sync data");
return;
}
int changes = 0;
jsr.startArray();
obj = jsr.parseObject();
while (obj != null) {
changes++;
changeReader.readChange(obj);
obj = jsr.parseObject();
}
jsr.endArray(null);
message.append(", ").append(changes).append(" changes");
changeReader = null;
itemReader = null;
// Sync records
if (centers != null) {
if (jsr.goToProperty("syncRecords")) {
int syncRecords = 0;
jsr.startArray();
while (jsr.getNextItem(true, false) instanceof JsonSerialReader.ObjectItem) {
JsonSerialReader.StructState centerState = jsr.save();
try {
if (!jsr.goToProperty("id")) {
message.append("\n\t\tID missing in sync records group");
break;
}
int centerID = jsr.parseInt();
PrismsCenter center = null;
for (PrismsCenter c : centers)
if (c.getID() == centerID) {
center = c;
break;
}
if (center == null) {
log.warn("No such center with ID " + centerID);
continue;
}
if (!jsr.goToProperty("syncRecords")) {
message.append("\n\t\tsyncRecords missing in sync records group");
continue;
}
jsr.startArray();
while (jsr.getNextItem(true, false) instanceof JsonSerialReader.ObjectItem) {
JsonSerialReader.StructState srState = jsr.save();
try {
if (!jsr.goToProperty("id")) {
log.warn("No id property in sync record");
continue;
}
int srID = jsr.parseInt();
if (!jsr.goToProperty("parallelID")) {
log.warn("No parallelID property in sync record");
continue;
}
int parallelID = jsr.parseInt();
if (!jsr.goToProperty("syncType")) {
log.warn("No syncType property in sync record");
continue;
}
String typeName = jsr.parseString();
SyncRecord.Type type = SyncRecord.Type.byName(typeName);
if (type == null) {
log.warn("Unrecognized sync type in sync record: " + typeName);
continue;
}
if (!jsr.goToProperty("time")) {
log.warn("No time property in sync record");
continue;
}
long time = jsr.parseLong();
if (!jsr.goToProperty("isImport")) {
log.warn("No isImport property in sync record");
continue;
}
boolean isImport = jsr.parseBoolean();
if (!jsr.goToProperty("syncError")) {
log.warn("No syncError property in sync record");
continue;
}
Object syncError = jsr.parseNext(false);
SyncRecord sr = new SyncRecord(center, type, time, isImport);
sr.setID(srID);
sr.setParallelID(parallelID);
if (syncError instanceof String) sr.setSyncError((String) syncError);
else if (syncError == JsonSerialReader.NULL) sr.setSyncError(null);
else String.class.cast(syncError);
try {
sync.getKeeper().putSyncRecord(sr);
} catch (PrismsRecordException e) {
log.error("Could not persist sync record", e);
continue;
}
syncRecords++;
if (!jsr.goToProperty("associated")) {
log.warn("No associated property in sync record");
continue;
}
prisms.util.LongList assocIDs = new prisms.util.LongList();
prisms.util.BooleanList assocErrors = new prisms.util.BooleanList();
jsr.startArray();
while (jsr.getNextItem(true, false) instanceof JsonSerialReader.ObjectItem) {
if (!jsr.goToProperty("id")) {
log.warn("No id for associated change");
jsr.endObject(null);
continue;
}
assocIDs.add(jsr.parseLong());
if (jsr.goToProperty("error")) assocErrors.add(jsr.parseBoolean());
else assocErrors.add(false);
jsr.endObject(null);
}
jsr.endArray(null);
ChangeRecord[] assocChanges;
try {
assocChanges = sync.getKeeper().getItems(assocIDs.toArray());
} catch (PrismsRecordException e) {
log.error("Could not get associated changes", e);
continue;
}
for (int i = 0; i < assocChanges.length; i++) {
if (assocChanges[i] != null)
try {
sync.getKeeper().associate(assocChanges[i], sr, assocErrors.get(i));
} catch (PrismsRecordException e) {
log.error("Could not associated change", e);
}
}
} finally {
jsr.endObject(srState);
}
}
jsr.endArray(null);
} finally {
jsr.endObject(centerState);
}
}
jsr.endArray(null);
message.append(", ").append(syncRecords).append(" sync records");
}
}
// Latest changes
if (jsr.goToProperty("latestChanges")) {
JsonSerialReader.StructState rootState = jsr.startArray();
while (jsr.getNextItem(true, false) instanceof JsonSerialReader.ObjectItem) {
JsonSerialReader.StructState lcState = jsr.save();
try {
if (!jsr.goToProperty("center")) {
log.warn("No center for latest change entry");
continue;
}
int centerID = jsr.parseInt();
if (!jsr.goToProperty("subjectCenter")) {
log.warn("No subjectCenter for latest change entry");
continue;
}
int subjectCenter = jsr.parseInt();
if (!jsr.goToProperty("latestChange")) {
log.warn("No latestChange for latest change entry");
continue;
}
long changeTime = jsr.parseLong();
try {
sync.getKeeper().setLatestChange(centerID, subjectCenter, changeTime);
} catch (PrismsRecordException e) {
log.error("Could not set latest change", e);
}
} finally {
jsr.endObject(lcState);
}
}
jsr.endArray(rootState);
}
}
/**
* Imports data stored in an export file
*
* @param apps The applications in the PRISMS environment
* @return Whether the import succeeded
*/
public boolean importData(PrismsApplication[] apps) {
try {
java.util.HashMap<String, PrismsSynchronizer> syncs;
java.util.HashMap<String, PrismsApplication> appsByNS;
syncs = new java.util.HashMap<String, PrismsSynchronizer>();
appsByNS = new java.util.HashMap<String, PrismsApplication>();
for (PrismsApplication app : apps) {
for (prisms.arch.event.PrismsProperty<?> property : app.getGlobalProperties()) {
if (PrismsSynchronizer.class.isAssignableFrom(property.getType())) {
PrismsSynchronizer sync = (PrismsSynchronizer) app.getGlobalProperty(property);
if (sync == null || !(sync.getKeeper() instanceof DBRecordKeeper)) continue;
syncs.put(((DBRecordKeeper) sync.getKeeper()).getNamespace(), sync);
appsByNS.put(((DBRecordKeeper) sync.getKeeper()).getNamespace(), app);
}
}
}
if (!theJsonReader.goToProperty("data")) {
log.error("No \"data\" property found in exported data");
return false;
}
JsonSerialReader.StructState rootState = theJsonReader.startArray();
JsonSerialReader.JsonParseItem item;
StringBuilder message = new StringBuilder();
message
.append("Imported PRISMS data from ")
.append(prisms.util.PrismsUtils.print(theExportDataTime))
.append(" (");
prisms.util.PrismsUtils.printTimeLength(
System.currentTimeMillis() - theExportDataTime, message, false);
message.append(" old).");
for (item = theJsonReader.getNextItem(true, false);
item instanceof JsonSerialReader.ObjectItem;
item = theJsonReader.getNextItem(true, false)) {
JsonSerialReader.StructState syncState = theJsonReader.save();
try {
/* The current state is now just past the beginning of one synchronizer's exported data */
if (!"namespace".equals(theJsonReader.getNextProperty())) {
message.append("\n\tNamespace expected in sync data set");
continue;
}
String namespace = theJsonReader.parseString();
PrismsSynchronizer sync = syncs.get(namespace);
if (sync == null) {
message.append("\n\tNo synchronizer loaded with namespace " + namespace);
continue;
}
message.append("\n\tImporting data for namespace \"").append(namespace).append('"');
String version;
if (!"version".equals(theJsonReader.getNextProperty())) version = null;
else version = theJsonReader.parseString();
boolean preAI = ((DBRecordKeeper) sync.getKeeper()).hasAbsoluteIntegrity();
((DBRecordKeeper) sync.getKeeper()).setAbsoluteIntegrity(true);
try {
importData(appsByNS.get(namespace), sync, version, theJsonReader, message);
} catch (Exception e) {
message.append("\n\t\tImport failed: ").append(e);
log.error("Could not import data for synchronizer " + namespace, e);
} finally {
((DBRecordKeeper) sync.getKeeper()).setAbsoluteIntegrity(preAI);
}
} finally {
theJsonReader.endObject(syncState);
}
}
theJsonReader.endArray(rootState);
int passwords = 0;
if (theJsonReader.goToProperty("passwords")) {
rootState = theJsonReader.startArray();
prisms.util.LongList pwdData = new prisms.util.LongList();
for (item = theJsonReader.getNextItem(true, false);
item instanceof JsonSerialReader.ObjectItem;
item = theJsonReader.getNextItem(true, false)) {
JsonSerialReader.StructState pwdState = theJsonReader.save();
try {
theJsonReader.goToProperty("userName");
String userName = theJsonReader.parseString();
User user = apps[0].getEnvironment().getUserSource().getUser(userName);
if (user == null) continue;
theJsonReader.goToProperty("passwordData");
theJsonReader.startArray();
Number num;
do {
num = theJsonReader.parseNumber();
if (num != null) pwdData.add(num.longValue());
} while (num != null);
theJsonReader.endArray(null);
try {
apps[0].getEnvironment().getUserSource().setPassword(user, pwdData.toArray(), true);
} catch (prisms.arch.PrismsException e) {
log.error("Could not set password for user " + userName, e);
}
passwords++;
pwdData.clear();
} finally {
theJsonReader.endObject(pwdState);
}
}
theJsonReader.endArray(rootState);
}
message.append("\n\tImported ").append(passwords).append(" passwords");
log.info(message.toString());
return true;
} catch (Exception e) {
log.error("Could not read or parse exported data", e);
return false;
} finally {
close();
}
}
void exportData(
prisms.ui.UI ui,
PrismsSynchronizer sync,
JsonStreamWriter jsw,
java.util.HashSet<String> namespaces,
prisms.ui.UI.DefaultProgressInformer pi,
boolean global)
throws java.io.IOException, PrismsRecordException {
DBRecordKeeper keeper = (DBRecordKeeper) sync.getKeeper();
String namespace = keeper.getNamespace();
if (namespaces.contains(namespace)) return;
namespaces.add(namespace);
for (PrismsSynchronizer depend : sync.getDepends())
exportData(ui, depend, jsw, namespaces, pi, global);
jsw.startObject();
jsw.startProperty("namespace");
jsw.writeString(namespace);
jsw.startProperty("version");
String v = null;
SynchronizeImpl impl = null;
for (SynchronizeImpl imp : sync.getImpls())
if (prisms.arch.PrismsConfig.compareVersions(imp.getVersion(), v) > 0) {
impl = imp;
v = impl.getVersion();
}
jsw.writeString(v);
SyncRecord syncRecord =
new SyncRecord(
new PrismsCenter("Export"),
SyncRecord.Type.AUTOMATIC,
System.currentTimeMillis(),
false);
pi.setProgressText("Exporting " + namespace + " items");
ui.startTimedTask(pi);
PrismsSynchronizer.SyncTransaction syncTrans = sync.transact(v, false, syncRecord, false, pi);
PrismsSynchronizer.PS2ItemWriter itemWriter =
new PrismsSynchronizer.PS2ItemWriter(
syncTrans, jsw, new prisms.records.LatestCenterChange[0]);
int[] centerIDs = global ? keeper.getAllCenterIDs() : new int[] {keeper.getCenterID()};
SynchronizeImpl.ItemIterator iter = impl.getAllItems(centerIDs, syncRecord.getCenter());
jsw.startProperty("items");
jsw.startArray();
while (iter.hasNext()) itemWriter.writeItem(iter.next());
for (PrismsCenter center : keeper.getCenters()) itemWriter.writeItem(center);
if (keeper.getAutoPurger() != null) itemWriter.writeItem(keeper.getAutoPurger());
jsw.endArray();
pi.setProgressText("Exporting " + namespace + " changes");
prisms.util.Sorter<RecordKeeper.ChangeField> sorter;
sorter = new prisms.util.Sorter<RecordKeeper.ChangeField>();
sorter.addSort(RecordKeeper.ChangeField.CHANGE_TIME, true);
prisms.util.Search changeSearch =
global
? null
: new prisms.records.ChangeSearch.IDRange(
Long.valueOf(IDGenerator.getMinID(keeper.getCenterID())),
Long.valueOf(IDGenerator.getMaxID(keeper.getCenterID())))
.and(new prisms.records.ChangeSearch.LocalOnlySearch(null));
prisms.util.LongList changeIDs =
new prisms.util.LongList(keeper.search(changeSearch, sorter));
long[] batch = new long[changeIDs.size() < 200 ? changeIDs.size() : 200];
jsw.startProperty("changes");
jsw.startArray();
for (int i = 0; i < changeIDs.size(); i += batch.length) {
if (changeIDs.size() - i < batch.length) batch = new long[changeIDs.size() - i];
changeIDs.arrayCopy(i, batch, 0, batch.length);
ChangeRecord[] changes = keeper.getItems(batch);
for (ChangeRecord change : changes)
if (change != null
&& (change.type.subjectType instanceof PrismsChange || impl.shouldSend(change)))
itemWriter.writeChange(change, false);
}
jsw.endArray();
if (global) {
pi.setProgressText("Exporting " + namespace + " sync records");
jsw.startProperty("syncRecords");
jsw.startArray();
for (PrismsCenter center : keeper.getCenters()) exportSyncRecords(center, keeper, jsw);
jsw.endArray();
pi.setProgressText("Exporting " + namespace + " metadata");
jsw.startProperty("latestChanges");
jsw.startArray();
prisms.util.IntList allCenterIDs = new prisms.util.IntList(keeper.getAllCenterIDs());
for (int i = 0; i < allCenterIDs.size(); i++)
for (int j = 0; j < allCenterIDs.size(); j++) {
long changeTime = keeper.getLatestChange(allCenterIDs.get(i), allCenterIDs.get(j));
if (changeTime > 0) {
jsw.startObject();
jsw.startProperty("center");
jsw.writeNumber(Integer.valueOf(allCenterIDs.get(i)));
jsw.startProperty("subjectCenter");
jsw.writeNumber(Integer.valueOf(allCenterIDs.get(i)));
jsw.startProperty("latestChange");
jsw.writeNumber(Long.valueOf(changeTime));
jsw.endObject();
}
}
jsw.endArray();
}
jsw.endObject();
}