use of io.siddhi.core.util.persistence.util.IncrementalSnapshotInfo in project siddhi by wso2.
the class IncrementalFileSystemPersistenceStore method getLastRevision.
@Override
public String getLastRevision(String siddhiAppName) {
long restoreTime = -1;
IncrementalSnapshotInfo lastSnapshotInfo = null;
File dir = new File(folder + File.separator + siddhiAppName);
File[] files = dir.listFiles();
if (files == null || files.length == 0) {
return null;
}
for (File file : files) {
String fileName = file.getName();
IncrementalSnapshotInfo snapshotInfo = PersistenceHelper.convertRevision(fileName);
if (snapshotInfo.getTime() > restoreTime && siddhiAppName.equals(snapshotInfo.getSiddhiAppId()) && snapshotInfo.getId() != null && snapshotInfo.getQueryName() != null) {
// Note: Here we discard the (items.length == 2) scenario which is handled
// by the full snapshot handling
restoreTime = snapshotInfo.getTime();
lastSnapshotInfo = snapshotInfo;
}
}
if (restoreTime != -1) {
if (log.isDebugEnabled()) {
log.debug("Latest revision to load: " + restoreTime + PersistenceConstants.REVISION_SEPARATOR + siddhiAppName);
}
return lastSnapshotInfo.getRevision();
}
return null;
}
use of io.siddhi.core.util.persistence.util.IncrementalSnapshotInfo in project siddhi by wso2.
the class SnapshotService method restoreRevision.
public void restoreRevision(String revision) throws CannotRestoreSiddhiAppStateException {
PersistenceStore persistenceStore = siddhiAppContext.getSiddhiContext().getPersistenceStore();
IncrementalPersistenceStore incrementalPersistenceStore = siddhiAppContext.getSiddhiContext().getIncrementalPersistenceStore();
String siddhiAppName = siddhiAppContext.getName();
if (persistenceStore != null) {
if (log.isDebugEnabled()) {
log.debug("Restoring revision: " + revision + " ...");
}
byte[] snapshot = persistenceStore.load(siddhiAppContext.getName(), revision);
if (snapshot != null) {
restore(snapshot);
if (log.isDebugEnabled()) {
log.debug("Restored revision: " + revision);
}
} else {
if (log.isDebugEnabled()) {
log.debug("No data found for revision: " + revision);
}
throw new PersistenceStoreException("No data found for revision: " + revision);
}
} else if (incrementalPersistenceStore != null) {
if (log.isDebugEnabled()) {
log.debug("Restoring revision: " + revision + " ...");
}
IncrementalSnapshotInfo restoreSnapshotInfo = PersistenceHelper.convertRevision(revision);
List<IncrementalSnapshotInfo> incrementalSnapshotInfos = incrementalPersistenceStore.getListOfRevisionsToLoad(restoreSnapshotInfo.getTime(), restoreSnapshotInfo.getSiddhiAppId());
if (incrementalSnapshotInfos != null) {
incrementalSnapshotInfos.sort(new Comparator<IncrementalSnapshotInfo>() {
@Override
public int compare(IncrementalSnapshotInfo o1, IncrementalSnapshotInfo o2) {
int results = o1.getId().compareTo(o2.getId());
if (results == 0) {
results = Long.compare(o2.getTime(), o1.getTime());
if (results == 0) {
return o2.getType().compareTo(o1.getType());
}
}
return results;
}
});
String lastId = null;
boolean baseFound = false;
boolean perioicFound = false;
for (Iterator<IncrementalSnapshotInfo> iterator = incrementalSnapshotInfos.iterator(); iterator.hasNext(); ) {
IncrementalSnapshotInfo snapshotInfo = iterator.next();
if (snapshotInfo.getId().equals(lastId)) {
if (baseFound && (snapshotInfo.getType() == IncrementalSnapshotInfo.SnapshotType.BASE || snapshotInfo.getType() == IncrementalSnapshotInfo.SnapshotType.INCREMENT)) {
iterator.remove();
} else if (perioicFound && snapshotInfo.getType() == IncrementalSnapshotInfo.SnapshotType.PERIODIC) {
iterator.remove();
} else if (snapshotInfo.getType() == IncrementalSnapshotInfo.SnapshotType.BASE) {
baseFound = true;
} else if (snapshotInfo.getType() == IncrementalSnapshotInfo.SnapshotType.PERIODIC) {
perioicFound = true;
}
} else {
baseFound = snapshotInfo.getType() == IncrementalSnapshotInfo.SnapshotType.BASE;
perioicFound = snapshotInfo.getType() == IncrementalSnapshotInfo.SnapshotType.PERIODIC;
}
lastId = snapshotInfo.getId();
}
Map<String, Map<String, Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>>>> incrementalState = new HashMap<>();
for (IncrementalSnapshotInfo snapshotInfo : incrementalSnapshotInfos) {
Map<String, Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>>> incrementalStateByPartitionGroupByKey = incrementalState.computeIfAbsent(snapshotInfo.getPartitionId(), k -> new TreeMap<>());
Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>> incrementalStateByTime = incrementalStateByPartitionGroupByKey.computeIfAbsent(snapshotInfo.getPartitionGroupByKey(), k -> new TreeMap<>());
Map<Long, Map<IncrementalSnapshotInfo, byte[]>> idByTime = incrementalStateByTime.computeIfAbsent(snapshotInfo.getId(), k -> new TreeMap<>());
Map<IncrementalSnapshotInfo, byte[]> incrementalStateByInfo = idByTime.computeIfAbsent(snapshotInfo.getTime(), k -> new HashMap<>());
incrementalStateByInfo.put(snapshotInfo, incrementalPersistenceStore.load(snapshotInfo));
}
restore(incrementalState);
if (log.isDebugEnabled()) {
log.debug("Restored revision: " + revision);
}
} else {
if (log.isDebugEnabled()) {
log.debug("No data found for revision: " + revision);
}
throw new PersistenceStoreException("No data found for revision: " + revision);
}
} else {
throw new NoPersistenceStoreException("No persistence store assigned for siddhi app " + siddhiAppName);
}
}
use of io.siddhi.core.util.persistence.util.IncrementalSnapshotInfo in project siddhi by wso2.
the class SnapshotService method restore.
public void restore(Map<String, Map<String, Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>>>> snapshot) throws CannotRestoreSiddhiAppStateException {
try {
threadBarrier.lock();
waitForSystemStabilization();
try {
// cleaning old group by states
cleanGroupByStates();
// restore data
for (Map.Entry<String, Map<String, Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>>>> partitionIdSnapshot : snapshot.entrySet()) {
PartitionIdStateHolder partitionStateHolder = partitionIdStates.get(partitionIdSnapshot.getKey());
if (partitionStateHolder == null) {
continue;
}
for (Iterator<Map.Entry<String, Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>>>> iterator = partitionIdSnapshot.getValue().entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<String, Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>>> partitionGroupByKeySnapshot = iterator.next();
restoreIncrementalSnapshot(partitionStateHolder, partitionGroupByKeySnapshot.getValue());
iterator.remove();
}
}
} catch (Throwable t) {
throw new CannotRestoreSiddhiAppStateException("Restoring of Siddhi app " + siddhiAppContext.getName() + " not completed properly because content of Siddhi " + "app has changed since last state persistence. Clean persistence store for a " + "fresh deployment.", t);
}
} finally {
threadBarrier.unlock();
}
}
use of io.siddhi.core.util.persistence.util.IncrementalSnapshotInfo in project siddhi by wso2.
the class SnapshotService method restoreIncrementalSnapshot.
private void restoreIncrementalSnapshot(PartitionIdStateHolder partitionIdStateHolder, Map<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>> incrementalStateByTime) {
if (incrementalStateByTime != null) {
String id = null;
State state = null;
StateHolder stateHolder = null;
Map<String, Object> deserializedStateMap = null;
try {
for (Iterator<Map.Entry<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>>> iterator = incrementalStateByTime.entrySet().iterator(); iterator.hasNext(); ) {
Map.Entry<String, Map<Long, Map<IncrementalSnapshotInfo, byte[]>>> incrementalStateByTimeEntry = iterator.next();
iterator.remove();
for (Iterator<Map.Entry<Long, Map<IncrementalSnapshotInfo, byte[]>>> partitionGroupByKeyIterator = incrementalStateByTimeEntry.getValue().entrySet().iterator(); partitionGroupByKeyIterator.hasNext(); ) {
Map.Entry<Long, Map<IncrementalSnapshotInfo, byte[]>> partitionGroupByKeyStateByTimeEntry = partitionGroupByKeyIterator.next();
partitionGroupByKeyIterator.remove();
for (Iterator<Map.Entry<IncrementalSnapshotInfo, byte[]>> iterator1 = partitionGroupByKeyStateByTimeEntry.getValue().entrySet().iterator(); iterator1.hasNext(); ) {
Map.Entry<IncrementalSnapshotInfo, byte[]> incrementalStateByInfoEntry = iterator1.next();
iterator1.remove();
IncrementalSnapshotInfo incrementalSnapshotInfo = incrementalStateByInfoEntry.getKey();
Map<String, Object> singleIncrementSnapshot = (Map<String, Object>) ByteSerializer.byteToObject(incrementalStateByInfoEntry.getValue(), siddhiAppContext);
if (singleIncrementSnapshot != null) {
if (!incrementalSnapshotInfo.getId().equals(id)) {
if (id != null) {
state.restore(deserializedStateMap);
SiddhiAppContext.startPartitionFlow(id);
try {
stateHolder.returnState(state);
} finally {
SiddhiAppContext.stopPartitionFlow();
}
id = null;
state = null;
stateHolder = null;
deserializedStateMap = null;
}
ElementStateHolder elementStateHolder = partitionIdStateHolder.queryStateHolderMap.get(incrementalSnapshotInfo.getQueryName());
if (elementStateHolder == null) {
continue;
}
stateHolder = elementStateHolder.elementHolderMap.get(incrementalSnapshotInfo.getElementId());
if (stateHolder == null) {
continue;
}
String partitionKey = null;
String groupByKey = null;
String[] keys = incrementalSnapshotInfo.getPartitionGroupByKey().split("--");
if (keys.length == 2) {
if (!keys[0].equals("null")) {
partitionKey = keys[0];
}
if (!keys[1].equals("null")) {
groupByKey = keys[1];
}
}
SiddhiAppContext.startPartitionFlow(partitionKey);
SiddhiAppContext.startGroupByFlow(groupByKey);
try {
state = stateHolder.getState();
} finally {
SiddhiAppContext.stopGroupByFlow();
SiddhiAppContext.stopPartitionFlow();
}
if (state != null) {
id = incrementalSnapshotInfo.getId();
deserializedStateMap = new HashMap<>();
}
}
if (state != null) {
for (Map.Entry<String, Object> singleIncrementSnapshotEntry : singleIncrementSnapshot.entrySet()) {
if (singleIncrementSnapshotEntry.getValue() instanceof Snapshot) {
Snapshot snapshot = (Snapshot) singleIncrementSnapshotEntry.getValue();
SnapshotStateList snapshotStateList = (SnapshotStateList) deserializedStateMap.computeIfAbsent(singleIncrementSnapshotEntry.getKey(), k -> new SnapshotStateList());
if (snapshot.isIncrementalSnapshot()) {
snapshotStateList.putSnapshotState(partitionGroupByKeyStateByTimeEntry.getKey(), snapshot);
} else {
snapshotStateList.getSnapshotStates().clear();
snapshotStateList.putSnapshotState(partitionGroupByKeyStateByTimeEntry.getKey(), snapshot);
}
} else {
deserializedStateMap.put(singleIncrementSnapshotEntry.getKey(), singleIncrementSnapshotEntry.getValue());
}
}
}
}
}
}
if (id != null) {
state.restore(deserializedStateMap);
SiddhiAppContext.startPartitionFlow(id);
try {
stateHolder.returnState(state);
} finally {
SiddhiAppContext.stopPartitionFlow();
}
id = null;
state = null;
stateHolder = null;
deserializedStateMap = null;
}
}
} finally {
if (id != null && stateHolder != null && state != null) {
SiddhiAppContext.startPartitionFlow(id);
try {
stateHolder.returnState(state);
} finally {
SiddhiAppContext.stopPartitionFlow();
}
id = null;
state = null;
stateHolder = null;
}
}
}
}
use of io.siddhi.core.util.persistence.util.IncrementalSnapshotInfo in project siddhi by wso2.
the class IncrementalFileSystemPersistenceStore method getListOfRevisionsToLoad.
@Override
public List<IncrementalSnapshotInfo> getListOfRevisionsToLoad(long restoreTime, String siddhiAppName) {
File dir = new File(folder + File.separator + siddhiAppName);
File[] files = dir.listFiles();
if (files == null || files.length == 0) {
return null;
}
List<IncrementalSnapshotInfo> results = new ArrayList<>();
for (File file : files) {
String fileName = file.getName();
IncrementalSnapshotInfo snapshotInfo = PersistenceHelper.convertRevision(fileName);
if (snapshotInfo.getTime() <= restoreTime && siddhiAppName.equals(snapshotInfo.getSiddhiAppId()) && snapshotInfo.getId() != null && snapshotInfo.getQueryName() != null) {
// by the full snapshot handling
if (log.isDebugEnabled()) {
log.debug("List of revisions to load : " + fileName);
}
results.add(snapshotInfo);
}
}
return results;
}
Aggregations