/**
* returns a rrd series data, an array of [[timestamp,data1,data2,...]]
*
* @param persistenceService
* @param item
* @param consilidationFunction
* @param timeBegin
* @param timeEnd
* @param resolution
* @return
*/
public Object getRrdSeries(
QueryablePersistenceService persistenceService,
Item item,
ConsolFun consilidationFunction,
Date timeBegin,
Date timeEnd,
long resolution) {
Map<Long, ArrayList<String>> data = new TreeMap<Long, ArrayList<String>>();
try {
List<String> itemNames = new ArrayList<String>();
if (item instanceof GroupItem) {
GroupItem groupItem = (GroupItem) item;
for (Item member : groupItem.getMembers()) {
itemNames.add(member.getName());
}
} else {
itemNames.add(item.getName());
}
for (String itemName : itemNames) {
addRrdData(data, itemName, consilidationFunction, timeBegin, timeEnd, resolution);
}
} catch (FileNotFoundException e) {
// rrd file does not exist, fallback to generic persistance service
logger.debug(
"no rrd file found '{}'", (RRD_FOLDER + File.separator + item.getName() + ".rrd"));
return getPersistenceSeries(persistenceService, item, timeBegin, timeEnd, resolution);
} catch (Exception e) {
logger.error(e.getLocalizedMessage() + ": fallback to generic persistance service");
return getPersistenceSeries(persistenceService, item, timeBegin, timeEnd, resolution);
}
return convertToRrd(data);
}
private void internalDispatchBindings(
BindingConfigReader reader, String modelName, Item item, EList<ModelBinding> bindings) {
for (ModelBinding binding : bindings) {
String bindingType = binding.getType();
String config = binding.getConfiguration();
BindingConfigReader localReader = reader;
if (reader == null) {
logger.trace(
"Given binding config reader is null > query cache to find appropriate reader!");
localReader = bindingConfigReaders.get(bindingType);
} else {
if (!localReader.getBindingType().equals(binding.getType())) {
logger.trace(
"The Readers' binding type '{}' and the Bindings' type '{}' doesn't match > continue processing next binding.",
localReader.getBindingType(),
binding.getType());
continue;
} else {
logger.debug(
"Start processing binding configuration of Item '{}' with '{}' reader.",
item,
localReader.getClass().getSimpleName());
}
}
if (localReader != null) {
try {
localReader.validateItemType(item.getType(), config);
localReader.processBindingConfiguration(
modelName, item.getType(), item.getName(), config);
} catch (BindingConfigParseException e) {
logger.error(
"Binding configuration of type '"
+ bindingType
+ "' of item '"
+ item.getName()
+ "' could not be parsed correctly.",
e);
} catch (Exception e) {
// Catch badly behaving binding exceptions and continue processing
logger.error(
"Binding configuration of type '"
+ bindingType
+ "' of item '"
+ item.getName()
+ "' could not be parsed correctly.",
e);
}
} else {
logger.trace(
"Couldn't find config reader for binding type '{}' > "
+ "parsing binding configuration of Item '{}' aborted!",
bindingType,
item);
}
}
}
/**
* Checks if a given persistence configuration entry is relevant for an item
*
* @param config the persistence configuration entry
* @param item to check if the configuration applies to
* @return true, if the configuration applies to the item
*/
protected boolean appliesToItem(PersistenceConfiguration config, Item item) {
for (EObject itemCfg : config.getItems()) {
if (itemCfg instanceof AllConfig) {
return true;
}
if (itemCfg instanceof ItemConfig) {
ItemConfig singleItemConfig = (ItemConfig) itemCfg;
if (item.getName().equals(singleItemConfig.getItem())) {
return true;
}
}
if (itemCfg instanceof GroupConfig) {
GroupConfig groupItemCfg = (GroupConfig) itemCfg;
String groupName = groupItemCfg.getGroup();
try {
Item gItem = itemRegistry.getItem(groupName);
if (gItem instanceof GroupItem) {
GroupItem groupItem = (GroupItem) gItem;
if (groupItem.getAllMembers().contains(item)) {
return true;
}
}
} catch (Exception e) {
}
}
}
return false;
}
/**
* Handles the "restoreOnStartup" strategy for the item. If the item state is still undefined when
* entering this method, all persistence configurations are checked, if they have the
* "restoreOnStartup" strategy configured for the item. If so, the item state will be set to its
* last persisted value.
*
* @param item the item to restore the state for
*/
protected void initialize(Item item) {
// get the last persisted state from the persistence service if no state is yet set
if (item.getState().equals(UnDefType.NULL) && item instanceof GenericItem) {
for (Entry<String, List<PersistenceConfiguration>> entry :
persistenceConfigurations.entrySet()) {
String serviceName = entry.getKey();
for (PersistenceConfiguration config : entry.getValue()) {
if (hasStrategy(serviceName, config, GlobalStrategies.RESTORE)) {
if (appliesToItem(config, item)) {
PersistenceService service = persistenceServices.get(serviceName);
if (service instanceof QueryablePersistenceService) {
QueryablePersistenceService queryService = (QueryablePersistenceService) service;
FilterCriteria filter =
new FilterCriteria().setItemName(item.getName()).setPageSize(1);
Iterable<HistoricItem> result = queryService.query(filter);
Iterator<HistoricItem> it = result.iterator();
if (it.hasNext()) {
HistoricItem historicItem = it.next();
GenericItem genericItem = (GenericItem) item;
genericItem.removeStateChangeListener(this);
genericItem.setState(historicItem.getState());
genericItem.addStateChangeListener(this);
logger.debug(
"Restored item state from '{}' for item '{}' -> '{}'",
new Object[] {
DateFormat.getDateTimeInstance().format(historicItem.getTimestamp()),
item.getName(),
historicItem.getState().toString()
});
return;
}
} else if (service != null) {
logger.warn(
"Failed to restore item states as persistence service '{}' can not be queried.",
serviceName);
}
}
}
}
}
}
}
public Object getPersistenceSeries(
QueryablePersistenceService persistenceService,
Item item,
Date timeBegin,
Date timeEnd,
long resolution) {
Map<Long, ArrayList<String>> data = new HashMap<Long, ArrayList<String>>();
// Define the data filter
FilterCriteria filter = new FilterCriteria();
filter.setBeginDate(timeBegin);
filter.setEndDate(timeEnd);
filter.setItemName(item.getName());
filter.setOrdering(Ordering.ASCENDING);
// Get the data from the persistence store
Iterable<HistoricItem> result = persistenceService.query(filter);
Iterator<HistoricItem> it = result.iterator();
// Iterate through the data
int dataCounter = 0;
while (it.hasNext()) {
dataCounter++;
HistoricItem historicItem = it.next();
org.eclipse.smarthome.core.types.State state = historicItem.getState();
if (state instanceof DecimalType) {
ArrayList<String> vals = new ArrayList<String>();
vals.add(formatDouble(((DecimalType) state).doubleValue(), "null", true));
data.put(historicItem.getTimestamp().getTime(), vals);
}
}
logger.debug(
"'{}' querying item '{}' from '{}' to '{}' => '{}' results",
persistenceService.getId(),
filter.getItemName(),
filter.getBeginDate(),
filter.getEndDate(),
dataCounter);
return convertToRrd(data);
}