Java tutorial
/** * * Copyright (c) 2009-2016 Freedomotic team http://freedomotic.com * * This file is part of Freedomotic * * This Program is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 2, or (at your option) any later version. * * This Program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License along with * Freedomotic; see the file COPYING. If not, see * <http://www.gnu.org/licenses/>. */ package com.freedomotic.environment.impl; import com.freedomotic.app.Freedomotic; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.UUID; import org.apache.commons.io.FileUtils; import org.apache.shiro.authz.annotation.RequiresPermissions; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.freedomotic.environment.EnvironmentLogic; import com.freedomotic.environment.EnvironmentRepository; import com.freedomotic.exceptions.RepositoryException; import com.freedomotic.model.environment.Environment; import com.freedomotic.model.environment.Zone; import com.freedomotic.persistence.FreedomXStream; import com.freedomotic.persistence.XmlPreprocessor; import com.freedomotic.settings.AppConfig; import com.freedomotic.settings.Info; import com.freedomotic.things.EnvObjectLogic; import com.freedomotic.things.ThingRepository; import com.freedomotic.util.SerialClone; import com.freedomotic.util.UidGenerator; import com.google.inject.Inject; import com.thoughtworks.xstream.XStream; import com.thoughtworks.xstream.XStreamException; /** * Repository to manage the {@link Environment} loaded from filesystem * * @author Enrico Nicoletti */ class EnvironmentRepositoryImpl implements EnvironmentRepository { private static final Logger LOG = LoggerFactory.getLogger(EnvironmentRepositoryImpl.class.getName()); // Dependencies private final AppConfig appConfig; private final EnvironmentPersistenceFactory environmentPersistenceFactory; private final ThingRepository thingsRepository; private File defaultEnvironmentFile; private static final String ENVIRONMENT_FILE_EXTENSION = ".xenv"; // The Environments cache private static final List<EnvironmentLogic> environments = new ArrayList<>(); /** * Creates a new repository * * @param appConfig needed to get the default environment * @param environmentPersistenceFactory creates the right environment loader * to manage the environment persistence * @throws com.freedomotic.exceptions.RepositoryException */ @Inject EnvironmentRepositoryImpl(AppConfig appConfig, ThingRepository thingsRepository, EnvironmentPersistenceFactory environmentPersistenceFactory) throws RepositoryException { this.appConfig = appConfig; this.thingsRepository = thingsRepository; this.environmentPersistenceFactory = environmentPersistenceFactory; } @Override public void initFromDefaultFolder() throws RepositoryException { String envFilePath = appConfig.getProperty("KEY_ROOM_XML_PATH"); this.defaultEnvironmentFile = new File(Info.PATHS.PATH_ENVIRONMENTS_FOLDER + File.separator + envFilePath); File defaultEnvironmentFolder = getDefaultEnvironmentFolder(); this.init(defaultEnvironmentFolder); } /** * Reads environment data from filesystem using the * {@link EnvironmentPersistence} class * * @throws RepositoryException */ @Override public synchronized void init(File folder) throws RepositoryException { EnvironmentPersistence environmentPersistence = environmentPersistenceFactory.create(folder); Collection<Environment> loadedPojo = environmentPersistence.loadAll(); this.deleteAll(); for (Environment env : loadedPojo) { EnvironmentLogic envLogic = new EnvironmentLogic(); envLogic.setPojo(env); envLogic.setSource(new File(folder + "/" + env.getUUID() + ENVIRONMENT_FILE_EXTENSION)); // activate this environment this.create(envLogic); } List<EnvObjectLogic> loadedThings = thingsRepository.loadAll(findAll().get(0).getObjectFolder()); for (EnvObjectLogic thing : loadedThings) { // stores the thing in repository. Important, otherwise it will be not visible in the environment thingsRepository.create(thing); } } /** * * * @return @throws RepositoryException */ private File getDefaultEnvironmentFolder() throws RepositoryException { File folder = this.defaultEnvironmentFile.getParentFile(); if (folder == null) { throw new RepositoryException( "Application configuration does not specify the default environment to load." + " A 'KEY_ROOM_XML_PATH' property is expected"); } if (!folder.exists()) { throw new RepositoryException("Folder \"" + folder + "\" doesn't exist. Cannot load default " + "environment from \"" + this.defaultEnvironmentFile.getAbsolutePath() + "\""); } else if (!folder.isDirectory()) { throw new RepositoryException( "Environment folder \"" + folder.getAbsolutePath() + "\" is supposed to be a directory"); } return folder; } /** * * @param folder * @throws RepositoryException */ @RequiresPermissions("environments:save") @Override public void saveEnvironmentsToFolder(File folder) throws RepositoryException { if (environments.isEmpty()) { LOG.warn("There is no environment to persist. Folder \"{}\" will not be altered", folder.getAbsolutePath()); return; } if (folder.exists() && !folder.isDirectory()) { throw new RepositoryException( "\"" + folder.getAbsoluteFile() + "\" is not a valid environment folder. Skipped"); } try { for (EnvironmentLogic environment : environments) { String uuid = environment.getPojo().getUUID(); if ((uuid == null) || uuid.isEmpty()) { environment.getPojo().setUUID(UUID.randomUUID().toString()); } String fileName = environment.getPojo().getUUID() + ENVIRONMENT_FILE_EXTENSION; save(environment, new File(folder + "/" + fileName)); } } catch (IOException e) { throw new RepositoryException(e.getCause()); } // save environment's things if (appConfig.getBooleanProperty("KEY_OVERRIDE_OBJECTS_ON_EXIT", false)) { try { thingsRepository.saveAll(findAll().get(0).getObjectFolder()); } catch (RepositoryException ex) { LOG.error("Cannot save objects into \"{}\"", findAll().get(0).getObjectFolder().getAbsolutePath(), Freedomotic.getStackTraceInfo(ex)); } } } /** * * * @param folder * @throws RepositoryException */ private static void deleteEnvFiles(File folder) throws RepositoryException { if ((folder == null) || !folder.isDirectory()) { throw new IllegalArgumentException("Unable to delete environment files in a null or not valid folder"); } // this filter only returns thing files FileFilter objectFileFileter = new FileFilter() { @Override public boolean accept(File file) { if (file.isFile() && file.getName().endsWith(ENVIRONMENT_FILE_EXTENSION)) { return true; } else { return false; } } }; File[] files = folder.listFiles(objectFileFileter); for (File file : files) { boolean deleted = file.delete(); if (!deleted) { throw new RepositoryException("Unable to delete file " + file.getAbsoluteFile()); } } } /** * Loads all objects file filesystem folder and adds the objects to the * list. * * @param folder * @param makeUnique * @return * @throws com.freedomotic.exceptions.RepositoryException * @deprecated */ @Deprecated private boolean loadEnvironmentsFromDir(File folder, boolean makeUnique) throws RepositoryException { if (folder == null) { throw new RepositoryException("Cannot load environments from a null folder"); } environments.clear(); // This filter only returns env files FileFilter envFileFilter = new FileFilter() { @Override public boolean accept(File file) { return file.isFile() && file.getName().endsWith(ENVIRONMENT_FILE_EXTENSION); } }; File[] files = folder.listFiles(envFileFilter); for (File file : files) { try { EnvironmentLogic envLogic = loadEnvironmentFromFile(file); if (envLogic != null) { add(envLogic, false); } } catch (RepositoryException re) { LOG.error("Cannot add environment from file \"{}\"", file.getAbsolutePath(), Freedomotic.getStackTraceInfo(re)); } } // Load all objects in this environment thingsRepository.loadAll(EnvironmentRepositoryImpl.getEnvironments().get(0).getObjectFolder()); // TODO: this return value makes no sense return true; } /** * Adds an environment. You can use EnvObjectPersistance.MAKE_UNIQUE to * create an object that will surely be unique. Beware this means it is * created with defensive copy of the object in input and name, protocol, * address and UUID are reset to a default value. * * @param obj the environment to add * @param MAKE_UNIQUE can be true or false. Creates a defensive copy * reference to the object in input. * @return a pointer to the newly created environment object */ @RequiresPermissions("environments:create") @Deprecated private static EnvironmentLogic add(final EnvironmentLogic obj, boolean MAKE_UNIQUE) { if ((obj == null) || (obj.getPojo() == null) || (obj.getPojo().getName() == null) || obj.getPojo().getName().isEmpty()) { throw new IllegalArgumentException("This is not a valid environment"); } EnvironmentLogic envLogic = obj; if (MAKE_UNIQUE) { envLogic = new EnvironmentLogic(); //defensive copy to not affect the passed object with the changes Environment pojoCopy = SerialClone.clone(obj.getPojo()); pojoCopy.setName(obj.getPojo().getName() + "-" + UidGenerator.getNextStringUid()); pojoCopy.setUUID(""); // force to assign a new random and unique UUID // force to assign a new random and unique UUID to every zone for (Zone z : pojoCopy.getZones()) { z.setUuid(UUID.randomUUID().toString()); } //should be the last called after using setters on envLogic.getPojo() envLogic.setPojo(pojoCopy); } envLogic.init(); environments.add(envLogic); return envLogic; } /** * * @param input */ @RequiresPermissions("environments:delete") @Deprecated private void remove(EnvironmentLogic input) { for (EnvObjectLogic obj : thingsRepository.findByEnvironment(input)) { thingsRepository.delete(obj); } environments.remove(input); this.removeEnvironmentFile(input.getSource()); input.clear(); } private boolean removeEnvironmentFile(File environmentFile) { if (environmentFile == null) { LOG.warn("No file defined in this environment, so no deletion occurs."); return false; } if (environmentFile.exists()) { try { FileUtils.forceDelete(environmentFile); return true; } catch (IOException e) { LOG.warn("Error while removing file \"{}\", please try manually.", environmentFile.getAbsolutePath(), Freedomotic.getStackTraceInfo(e)); return false; } } else { LOG.warn("File \"{}\" does not exist", environmentFile.getAbsolutePath()); return false; } } /** * */ @RequiresPermissions("environments:delete") @Override public void deleteAll() { try { for (EnvironmentLogic el : environments) { delete(el); } } catch (Exception e) { LOG.error(Freedomotic.getStackTraceInfo(e)); } finally { environments.clear(); } } /** * Saves an environment to file. * * @param env environment to save * @param file file to save the environment * @throws IOException */ private void save(EnvironmentLogic env, File file) throws IOException { try { EnvironmentPersistence environmentPersistence = environmentPersistenceFactory .create(file.getParentFile()); environmentPersistence.persist(env.getPojo()); } catch (RepositoryException ex) { LOG.error(Freedomotic.getStackTraceInfo(ex)); } } /** * * @param env * @param folder * @throws IOException */ @RequiresPermissions("environments:save") @Override public void saveAs(EnvironmentLogic env, File folder) throws IOException { LOG.info("Serializing new environment to \"{}\"", folder); save(env, new File(folder + "/" + env.getPojo().getUUID() + ENVIRONMENT_FILE_EXTENSION)); } /** * * @param file * @throws RepositoryException * @deprecated */ @Deprecated @Override public EnvironmentLogic loadEnvironmentFromFile(final File file) throws RepositoryException { LOG.info("Loading environment from file \"{}\"", file.getAbsolutePath()); XStream xstream = FreedomXStream.getXstream(); //validate the object against a predefined DTD String xml; try { xml = XmlPreprocessor.validate(file, Info.PATHS.PATH_CONFIG_FOLDER + "/validator/environment.dtd"); } catch (IOException ex) { throw new RepositoryException(ex.getMessage(), ex); } Environment pojo = null; try { pojo = (Environment) xstream.fromXML(xml); } catch (XStreamException e) { throw new RepositoryException("XML parsing error. Readed XML is \n" + xml, e); } EnvironmentLogic envLogic = new EnvironmentLogic(); if (pojo == null) { throw new IllegalStateException("Object data cannot be null at this stage"); } envLogic.setPojo(pojo); envLogic.setSource(file); LOG.info("Environment \"" + envLogic.getPojo().getName() + "\" loaded"); return envLogic; } /** * * @return */ @Deprecated @RequiresPermissions("environments:read") private static List<EnvironmentLogic> getEnvironments() { return environments; } /** * * @param UUID * @return */ @RequiresPermissions("environments:read") @Deprecated private static EnvironmentLogic getEnvByUUID(String UUID) { // if (auth.isPermitted("environments:read:" + UUID)) { for (EnvironmentLogic env : environments) { if (env.getPojo().getUUID().equals(UUID)) { return env; } } // } return null; } @Override @RequiresPermissions("environments:read") public List<EnvironmentLogic> findAll() { return getEnvironments(); } @Override @RequiresPermissions("environments:read") public List<EnvironmentLogic> findByName(String name) { List<EnvironmentLogic> el = new ArrayList<>(); for (EnvironmentLogic e : findAll()) { if (e.getPojo().getName().equalsIgnoreCase(name)) { el.add(e); } } return el; } @Override @RequiresPermissions("environments:read") public EnvironmentLogic findOne(String uuid) { return getEnvByUUID(uuid); } @Override @RequiresPermissions("environments:create") public boolean create(EnvironmentLogic item) { try { add(item, false); return true; } catch (Exception e) { LOG.error(Freedomotic.getStackTraceInfo(e)); return false; } } @Override @RequiresPermissions("environments:delete") public boolean delete(EnvironmentLogic item) { if (environments.isEmpty()) { LOG.warn("There are no environments to delete"); return false; } if (item.getSource() != null && environments.contains(item) && this.defaultEnvironmentFile.getAbsolutePath() .equalsIgnoreCase(item.getSource().getAbsolutePath())) { LOG.info("Default environment cannot be deleted \"{}\"", item.getSource().getAbsolutePath()); return false; } try { remove(item); return true; } catch (Exception e) { LOG.error(Freedomotic.getStackTraceInfo(e)); return false; } } @Override @RequiresPermissions("environments:delete") public boolean delete(String uuid) { return delete(findOne(uuid)); } @Override @RequiresPermissions("environments:update") public EnvironmentLogic modify(String uuid, EnvironmentLogic data) { try { delete(uuid); data.getPojo().setUUID(uuid); create(data); return data; } catch (Exception e) { LOG.error(Freedomotic.getStackTraceInfo(e)); return null; } } @Override @RequiresPermissions("environments:create") public EnvironmentLogic copy(EnvironmentLogic env) { return add(env, true); } }