Java tutorial
/** * Licensed to JumpMind Inc under one or more contributor * license agreements. See the NOTICE file distributed * with this work for additional information regarding * copyright ownership. JumpMind Inc licenses this file * to you under the GNU General Public License, version 3.0 (GPLv3) * (the "License"); you may not use this file except in compliance * with the License. * * You should have received a copy of the GNU General Public License, * version 3.0 (GPLv3) along with this library; if not, see * <http://www.gnu.org/licenses/>. * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.jumpmind.symmetric; import static org.apache.commons.lang.StringUtils.isBlank; import java.io.File; import java.io.InputStreamReader; import java.net.MalformedURLException; import java.net.URL; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import org.apache.commons.lang.StringUtils; import org.jumpmind.db.io.DatabaseXmlUtil; import org.jumpmind.db.model.Database; import org.jumpmind.db.model.Table; import org.jumpmind.db.platform.IDatabasePlatform; import org.jumpmind.db.sql.ISqlTemplate; import org.jumpmind.db.sql.SqlException; import org.jumpmind.db.sql.SqlScript; import org.jumpmind.db.sql.SqlScriptReader; import org.jumpmind.properties.TypedProperties; import org.jumpmind.security.ISecurityService; import org.jumpmind.security.SecurityServiceFactory; import org.jumpmind.security.SecurityServiceFactory.SecurityServiceType; import org.jumpmind.symmetric.common.Constants; import org.jumpmind.symmetric.common.ParameterConstants; import org.jumpmind.symmetric.common.TableConstants; import org.jumpmind.symmetric.db.ISymmetricDialect; import org.jumpmind.symmetric.io.DefaultOfflineClientListener; import org.jumpmind.symmetric.io.IOfflineClientListener; import org.jumpmind.symmetric.io.stage.IStagingManager; import org.jumpmind.symmetric.job.DefaultOfflineServerListener; import org.jumpmind.symmetric.job.IJobManager; import org.jumpmind.symmetric.model.FileTriggerRouter; import org.jumpmind.symmetric.model.Grouplet; import org.jumpmind.symmetric.model.Node; import org.jumpmind.symmetric.model.NodeGroupLink; import org.jumpmind.symmetric.model.NodeSecurity; import org.jumpmind.symmetric.model.NodeStatus; import org.jumpmind.symmetric.model.ProcessInfo; import org.jumpmind.symmetric.model.ProcessInfo.Status; import org.jumpmind.symmetric.model.RemoteNodeStatuses; import org.jumpmind.symmetric.model.Router; import org.jumpmind.symmetric.model.TriggerRouter; import org.jumpmind.symmetric.service.IAcknowledgeService; import org.jumpmind.symmetric.service.IBandwidthService; import org.jumpmind.symmetric.service.IClusterService; import org.jumpmind.symmetric.service.IConfigurationService; import org.jumpmind.symmetric.service.IDataExtractorService; import org.jumpmind.symmetric.service.IDataLoaderService; import org.jumpmind.symmetric.service.IDataService; import org.jumpmind.symmetric.service.IExtensionService; import org.jumpmind.symmetric.service.IFileSyncService; import org.jumpmind.symmetric.service.IGroupletService; import org.jumpmind.symmetric.service.IIncomingBatchService; import org.jumpmind.symmetric.service.ILoadFilterService; import org.jumpmind.symmetric.service.INodeCommunicationService; import org.jumpmind.symmetric.service.INodeService; import org.jumpmind.symmetric.service.IOutgoingBatchService; import org.jumpmind.symmetric.service.IParameterService; import org.jumpmind.symmetric.service.IPullService; import org.jumpmind.symmetric.service.IPurgeService; import org.jumpmind.symmetric.service.IPushService; import org.jumpmind.symmetric.service.IRegistrationService; import org.jumpmind.symmetric.service.IRouterService; import org.jumpmind.symmetric.service.ISequenceService; import org.jumpmind.symmetric.service.IStatisticService; import org.jumpmind.symmetric.service.ITransformService; import org.jumpmind.symmetric.service.ITriggerRouterService; import org.jumpmind.symmetric.service.impl.AcknowledgeService; import org.jumpmind.symmetric.service.impl.BandwidthService; import org.jumpmind.symmetric.service.impl.ClusterService; import org.jumpmind.symmetric.service.impl.ConfigurationService; import org.jumpmind.symmetric.service.impl.DataExtractorService; import org.jumpmind.symmetric.service.impl.DataLoaderService; import org.jumpmind.symmetric.service.impl.DataLoaderService.ConflictNodeGroupLink; import org.jumpmind.symmetric.service.impl.DataService; import org.jumpmind.symmetric.service.impl.FileSyncService; import org.jumpmind.symmetric.service.impl.GroupletService; import org.jumpmind.symmetric.service.impl.IncomingBatchService; import org.jumpmind.symmetric.service.impl.LoadFilterService; import org.jumpmind.symmetric.service.impl.NodeCommunicationService; import org.jumpmind.symmetric.service.impl.NodeService; import org.jumpmind.symmetric.service.impl.OutgoingBatchService; import org.jumpmind.symmetric.service.impl.ParameterService; import org.jumpmind.symmetric.service.impl.PullService; import org.jumpmind.symmetric.service.impl.PurgeService; import org.jumpmind.symmetric.service.impl.PushService; import org.jumpmind.symmetric.service.impl.RegistrationService; import org.jumpmind.symmetric.service.impl.RouterService; import org.jumpmind.symmetric.service.impl.SequenceService; import org.jumpmind.symmetric.service.impl.StatisticService; import org.jumpmind.symmetric.service.impl.TransformService; import org.jumpmind.symmetric.service.impl.TransformService.TransformTableNodeGroupLink; import org.jumpmind.symmetric.service.impl.TriggerRouterService; import org.jumpmind.symmetric.statistic.IStatisticManager; import org.jumpmind.symmetric.statistic.StatisticManager; import org.jumpmind.symmetric.transport.ConcurrentConnectionManager; import org.jumpmind.symmetric.transport.IConcurrentConnectionManager; import org.jumpmind.symmetric.transport.ITransportManager; import org.jumpmind.symmetric.transport.TransportManagerFactory; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.slf4j.MDC; abstract public class AbstractSymmetricEngine implements ISymmetricEngine { private static Map<String, ISymmetricEngine> registeredEnginesByUrl = new HashMap<String, ISymmetricEngine>(); private static Map<String, ISymmetricEngine> registeredEnginesByName = new HashMap<String, ISymmetricEngine>(); protected static final Logger log = LoggerFactory.getLogger(AbstractSymmetricEngine.class); private boolean started = false; private boolean starting = false; private boolean setup = false; protected String deploymentType; protected ITypedPropertiesFactory propertiesFactory; protected IDatabasePlatform platform; protected ISecurityService securityService; protected ParameterService parameterService; protected ISymmetricDialect symmetricDialect; protected INodeService nodeService; protected IConfigurationService configurationService; protected IBandwidthService bandwidthService; protected IStatisticService statisticService; protected IStatisticManager statisticManager; protected IConcurrentConnectionManager concurrentConnectionManager; protected ITransportManager transportManager; protected IClusterService clusterService; protected IPurgeService purgeService; protected ITransformService transformService; protected ILoadFilterService loadFilterService; protected ITriggerRouterService triggerRouterService; protected IOutgoingBatchService outgoingBatchService; protected IDataService dataService; protected IRouterService routerService; protected IDataExtractorService dataExtractorService; protected IRegistrationService registrationService; protected IDataLoaderService dataLoaderService; protected IIncomingBatchService incomingBatchService; protected IAcknowledgeService acknowledgeService; protected IPushService pushService; protected IPullService pullService; protected IJobManager jobManager; protected ISequenceService sequenceService; protected IExtensionService extensionService; protected IGroupletService groupletService; protected IStagingManager stagingManager; protected INodeCommunicationService nodeCommunicationService; protected IFileSyncService fileSyncService; protected Date lastRestartTime = null; abstract protected ITypedPropertiesFactory createTypedPropertiesFactory(); abstract protected IDatabasePlatform createDatabasePlatform(TypedProperties properties); protected boolean registerEngine = true; protected AbstractSymmetricEngine(boolean registerEngine) { this.registerEngine = registerEngine; } /** * Locate a {@link StandaloneSymmetricEngine} in the same JVM */ public static ISymmetricEngine findEngineByUrl(String url) { if (registeredEnginesByUrl != null && url != null) { return registeredEnginesByUrl.get(url); } else { return null; } } /** * Locate a {@link StandaloneSymmetricEngine} in the same JVM */ public static ISymmetricEngine findEngineByName(String name) { if (registeredEnginesByName != null && name != null) { return registeredEnginesByName.get(name); } else { return null; } } public void setDeploymentType(String deploymentType) { this.deploymentType = deploymentType; } protected abstract SecurityServiceType getSecurityServiceType(); protected void init() { if (propertiesFactory == null) { this.propertiesFactory = createTypedPropertiesFactory(); } if (securityService == null) { this.securityService = SecurityServiceFactory.create(getSecurityServiceType(), propertiesFactory.reload()); } TypedProperties properties = this.propertiesFactory.reload(); MDC.put("engineName", properties.get(ParameterConstants.ENGINE_NAME)); this.platform = createDatabasePlatform(properties); this.parameterService = new ParameterService(platform, propertiesFactory, properties.get(ParameterConstants.RUNTIME_CONFIG_TABLE_PREFIX, "sym")); boolean parameterTableExists = this.platform.readTableFromDatabase(null, null, TableConstants.getTableName(properties.get(ParameterConstants.RUNTIME_CONFIG_TABLE_PREFIX), TableConstants.SYM_PARAMETER)) != null; if (parameterTableExists) { this.parameterService.setDatabaseHasBeenInitialized(true); this.parameterService.rereadParameters(); } this.platform.setMetadataIgnoreCase(this.parameterService.is(ParameterConstants.DB_METADATA_IGNORE_CASE)); this.platform.setClearCacheModelTimeoutInMs( parameterService.getLong(ParameterConstants.CACHE_TIMEOUT_TABLES_IN_MS)); this.symmetricDialect = createSymmetricDialect(); this.extensionService = createExtensionService(); this.extensionService.refresh(); this.symmetricDialect.setExtensionService(extensionService); this.parameterService.setExtensionService(extensionService); this.bandwidthService = new BandwidthService(parameterService); this.sequenceService = new SequenceService(parameterService, symmetricDialect); this.stagingManager = createStagingManager(); this.nodeService = new NodeService(parameterService, symmetricDialect, securityService, extensionService); this.configurationService = new ConfigurationService(parameterService, symmetricDialect, nodeService); this.clusterService = new ClusterService(parameterService, symmetricDialect); this.statisticService = new StatisticService(parameterService, symmetricDialect); this.statisticManager = new StatisticManager(parameterService, nodeService, configurationService, statisticService, clusterService); this.concurrentConnectionManager = new ConcurrentConnectionManager(parameterService, statisticManager); this.purgeService = new PurgeService(parameterService, symmetricDialect, clusterService, statisticManager); this.transformService = new TransformService(parameterService, symmetricDialect, configurationService, extensionService); this.loadFilterService = new LoadFilterService(parameterService, symmetricDialect, configurationService); this.groupletService = new GroupletService(this); this.triggerRouterService = new TriggerRouterService(this); this.outgoingBatchService = new OutgoingBatchService(parameterService, symmetricDialect, nodeService, configurationService, sequenceService, clusterService, extensionService); this.dataService = new DataService(this, extensionService); this.routerService = buildRouterService(); this.nodeCommunicationService = buildNodeCommunicationService(clusterService, nodeService, parameterService, symmetricDialect); this.incomingBatchService = new IncomingBatchService(parameterService, symmetricDialect, clusterService); this.dataExtractorService = new DataExtractorService(this); this.transportManager = new TransportManagerFactory(this).create(); this.dataLoaderService = buildDataLoaderService(); this.registrationService = new RegistrationService(this); this.acknowledgeService = new AcknowledgeService(this); this.pushService = buildPushService(); this.pullService = new PullService(parameterService, symmetricDialect, nodeService, dataLoaderService, registrationService, clusterService, nodeCommunicationService, configurationService, extensionService); this.fileSyncService = new FileSyncService(this); this.jobManager = createJobManager(); extensionService.addExtensionPoint( new DefaultOfflineServerListener(statisticManager, nodeService, outgoingBatchService)); IOfflineClientListener defaultlistener = new DefaultOfflineClientListener(parameterService, nodeService); extensionService.addExtensionPoint(defaultlistener); extensionService.addExtensionPoint(defaultlistener); if (registerEngine) { registerHandleToEngine(); } } protected IPushService buildPushService() { return new PushService(this); } protected IDataLoaderService buildDataLoaderService() { return new DataLoaderService(this); } protected IRouterService buildRouterService() { return new RouterService(this); } protected INodeCommunicationService buildNodeCommunicationService(IClusterService clusterService, INodeService nodeService, IParameterService parameterService, ISymmetricDialect symmetricDialect) { return new NodeCommunicationService(clusterService, nodeService, parameterService, symmetricDialect); } abstract protected IStagingManager createStagingManager(); abstract protected ISymmetricDialect createSymmetricDialect(); abstract protected IExtensionService createExtensionService(); abstract protected IJobManager createJobManager(); public String getSyncUrl() { return parameterService.getSyncUrl(); } public Properties getProperties() { Properties p = new Properties(); p.putAll(parameterService.getAllParameters()); return p; } public String getEngineName() { return parameterService.getString(ParameterConstants.ENGINE_NAME); } public void setup() { getParameterService().rereadParameters(); if (!setup) { setupDatabase(false); parameterService.setDatabaseHasBeenInitialized(true); setup = true; } } public void setupDatabase(boolean force) { log.info("Initializing SymmetricDS database"); if (parameterService.is(ParameterConstants.AUTO_CONFIGURE_DATABASE) || force) { symmetricDialect.initTablesAndDatabaseObjects(); } else { log.info("SymmetricDS is not configured to auto-create the database"); } configurationService.initDefaultChannels(); clusterService.init(); sequenceService.init(); autoConfigRegistrationServer(); parameterService.rereadParameters(); log.info("Done initializing SymmetricDS database"); } protected void autoConfigRegistrationServer() { Node node = nodeService.findIdentity(); if (node == null) { buildTablesFromDdlUtilXmlIfProvided(); loadFromScriptIfProvided(); } node = nodeService.findIdentity(); if (node == null && parameterService.isRegistrationServer() && parameterService.is(ParameterConstants.AUTO_INSERT_REG_SVR_IF_NOT_FOUND, false)) { log.info("Inserting rows for node, security, identity and group for registration server"); String nodeId = parameterService.getExternalId(); node = new Node(parameterService, symmetricDialect); node.setNodeId(node.getExternalId()); nodeService.save(node); nodeService.insertNodeIdentity(nodeId); node = nodeService.findIdentity(); nodeService.insertNodeGroup(node.getNodeGroupId(), null); NodeSecurity nodeSecurity = nodeService.findNodeSecurity(nodeId, true); nodeSecurity.setInitialLoadTime(new Date()); nodeSecurity.setRegistrationTime(new Date()); nodeSecurity.setInitialLoadEnabled(false); nodeSecurity.setRegistrationEnabled(false); nodeService.updateNodeSecurity(nodeSecurity); } } protected boolean buildTablesFromDdlUtilXmlIfProvided() { boolean loaded = false; String xml = parameterService.getString(ParameterConstants.AUTO_CONFIGURE_REG_SVR_DDLUTIL_XML); if (!StringUtils.isBlank(xml)) { File file = new File(xml); URL fileUrl = null; if (file.isFile()) { try { fileUrl = file.toURI().toURL(); } catch (MalformedURLException e) { throw new RuntimeException(e); } } else { fileUrl = getClass().getResource(xml); } if (fileUrl != null) { try { log.info("Building database schema from: {}", xml); Database database = DatabaseXmlUtil.read(new InputStreamReader(fileUrl.openStream())); IDatabasePlatform platform = symmetricDialect.getPlatform(); platform.createDatabase(database, true, true); loaded = true; } catch (Exception e) { log.error("", e); } } } return loaded; } /** * Give the end user the option to provide a script that will load a * registration server with an initial SymmetricDS setup. * * Look first on the file system, then in the classpath for the SQL file. * * @return true if the script was executed */ protected boolean loadFromScriptIfProvided() { boolean loaded = false; String sqlScripts = parameterService.getString(ParameterConstants.AUTO_CONFIGURE_REG_SVR_SQL_SCRIPT); if (!StringUtils.isBlank(sqlScripts)) { String[] sqlScriptList = sqlScripts.split(","); for (String sqlScript : sqlScriptList) { sqlScript = sqlScript.trim(); if (StringUtils.isNotBlank(sqlScript)) { File file = new File(sqlScript); URL fileUrl = null; if (file.isFile()) { try { fileUrl = file.toURI().toURL(); } catch (MalformedURLException e) { throw new RuntimeException(e); } } else { fileUrl = getClass().getResource(sqlScript); if (fileUrl == null) { fileUrl = Thread.currentThread().getContextClassLoader().getResource(sqlScript); } } if (fileUrl != null) { new SqlScript(fileUrl, symmetricDialect.getPlatform().getSqlTemplate(), true, SqlScriptReader.QUERY_ENDS, getSymmetricDialect().getPlatform().getSqlScriptReplacementTokens()).execute(); loaded = true; } else { log.info( "Could not find the sql script: {} to execute. We would have run it if we had found it"); } } } } return loaded; } public synchronized boolean start() { return start(true); } public synchronized boolean start(boolean startJobs) { if (!starting && !started) { try { starting = true; symmetricDialect.verifyDatabaseIsCompatible(); setup(); if (isConfigured()) { Node node = nodeService.findIdentity(); if (node != null && (!node.getExternalId().equals(getParameterService().getExternalId()) || !node.getNodeGroupId().equals(getParameterService().getNodeGroupId()))) { if (parameterService.is(ParameterConstants.NODE_COPY_MODE_ENABLED, false)) { registrationService.requestNodeCopy(); } else { throw new SymmetricException( "The configured state does not match recorded database state. The recorded external id is %s while the configured external id is %s. The recorded node group id is %s while the configured node group id is %s", new Object[] { node.getExternalId(), getParameterService().getExternalId(), node.getNodeGroupId(), getParameterService().getNodeGroupId() }); } } else if (node != null) { log.info("Starting registered node [group={}, id={}, externalId={}]", new Object[] { node.getNodeGroupId(), node.getNodeId(), node.getExternalId() }); if (parameterService.is(ParameterConstants.AUTO_SYNC_TRIGGERS_AT_STARTUP, true)) { triggerRouterService.syncTriggers(); } else { log.info(ParameterConstants.AUTO_SYNC_TRIGGERS_AT_STARTUP + " is turned off"); } if (parameterService.is(ParameterConstants.HEARTBEAT_SYNC_ON_STARTUP, false) || isBlank(node.getDatabaseType()) || !StringUtils.equals(node.getSyncUrl(), parameterService.getSyncUrl())) { heartbeat(false); } } else { log.info("Starting unregistered node [group={}, externalId={}]", parameterService.getNodeGroupId(), parameterService.getExternalId()); } pushService.start(); dataLoaderService.start(); if (startJobs && jobManager != null) { jobManager.startJobs(); } log.info("Started SymmetricDS"); lastRestartTime = new Date(); started = true; } else { log.error("Did not start SymmetricDS. It has not been configured properly"); } } catch (Throwable ex) { log.error("An error occurred while starting SymmetricDS", ex); /* Don't leave SymmetricDS in a half started state */ stop(); } finally { starting = false; } } log.info( "SymmetricDS: type={}, name={}, version={}, groupId={}, externalId={}, databaseName={}, databaseVersion={}, driverName={}, driverVersion={}", new Object[] { getDeploymentType(), getEngineName(), Version.version(), getParameterService().getNodeGroupId(), getParameterService().getExternalId(), symmetricDialect.getName(), symmetricDialect.getVersion(), symmetricDialect.getDriverName(), symmetricDialect.getDriverVersion() }); return started; } public synchronized void uninstall() { log.warn("Attempting an uninstall of all SymmetricDS database objects from the database"); stop(); log.info("Just cleaned {} files in the staging area during the uninstall.", getStagingManager().clean(0)); try { Table table = platform.readTableFromDatabase(null, null, TableConstants .getTableName(parameterService.getTablePrefix(), TableConstants.SYM_TRIGGER_ROUTER)); if (table != null) { List<Grouplet> grouplets = groupletService.getGrouplets(true); for (Grouplet grouplet : grouplets) { groupletService.deleteGrouplet(grouplet); } List<TriggerRouter> triggerRouters = triggerRouterService.getTriggerRouters(false, true); for (TriggerRouter triggerRouter : triggerRouters) { triggerRouterService.deleteTriggerRouter(triggerRouter); } List<FileTriggerRouter> fileTriggerRouters = fileSyncService.getFileTriggerRouters(); for (FileTriggerRouter fileTriggerRouter : fileTriggerRouters) { fileSyncService.deleteFileTriggerRouter(fileTriggerRouter); } List<Router> routers = triggerRouterService.getRouters(true); for (Router router : routers) { triggerRouterService.deleteRouter(router); } } table = platform.readTableFromDatabase(null, null, TableConstants.getTableName(parameterService.getTablePrefix(), TableConstants.SYM_CONFLICT)); if (table != null) { // need to remove all conflicts before we can remove the node // group links List<ConflictNodeGroupLink> conflicts = dataLoaderService.getConflictSettingsNodeGroupLinks(); for (ConflictNodeGroupLink conflict : conflicts) { dataLoaderService.delete(conflict); } } table = platform.readTableFromDatabase(null, null, TableConstants .getTableName(parameterService.getTablePrefix(), TableConstants.SYM_TRANSFORM_TABLE)); if (table != null) { // need to remove all transforms before we can remove the node // group links List<TransformTableNodeGroupLink> transforms = transformService.getTransformTables(false); for (TransformTableNodeGroupLink transformTable : transforms) { transformService.deleteTransformTable(transformTable.getTransformId()); } } table = platform.readTableFromDatabase(null, null, TableConstants.getTableName(parameterService.getTablePrefix(), TableConstants.SYM_ROUTER)); if (table != null) { List<Router> objects = triggerRouterService.getRouters(true); for (Router router : objects) { triggerRouterService.deleteRouter(router); } } table = platform.readTableFromDatabase(null, null, TableConstants.getTableName(parameterService.getTablePrefix(), TableConstants.SYM_CONFLICT)); if (table != null) { List<ConflictNodeGroupLink> objects = dataLoaderService.getConflictSettingsNodeGroupLinks(); for (ConflictNodeGroupLink obj : objects) { dataLoaderService.delete(obj); } } table = platform.readTableFromDatabase(null, null, TableConstants .getTableName(parameterService.getTablePrefix(), TableConstants.SYM_NODE_GROUP_LINK)); if (table != null) { // remove the links so the symmetric table trigger will be // removed List<NodeGroupLink> links = configurationService.getNodeGroupLinks(false); for (NodeGroupLink nodeGroupLink : links) { configurationService.deleteNodeGroupLink(nodeGroupLink); } } if (table != null) { // this should remove all triggers because we have removed all the // trigger configuration triggerRouterService.syncTriggers(); } } catch (SqlException ex) { log.warn("Error while trying remove triggers on tables", ex); } // remove any additional triggers that may remain because they were not in trigger history symmetricDialect.cleanupTriggers(); symmetricDialect.dropTablesAndDatabaseObjects(); // force cache to be cleared nodeService.deleteIdentity(); parameterService.setDatabaseHasBeenInitialized(false); log.warn("Finished uninstalling SymmetricDS database objects from the database"); } public synchronized void stop() { log.info("Stopping SymmetricDS externalId={} version={} database={}", new Object[] { parameterService == null ? "?" : parameterService.getExternalId(), Version.version(), symmetricDialect == null ? "?" : symmetricDialect.getName() }); if (jobManager != null) { jobManager.stopJobs(); } if (routerService != null) { routerService.stop(); } if (nodeCommunicationService != null) { nodeCommunicationService.stop(); } if (pushService != null) { pushService.stop(); } if (dataLoaderService != null) { dataLoaderService.stop(); } if (statisticManager != null) { List<ProcessInfo> infos = statisticManager.getProcessInfos(); for (ProcessInfo processInfo : infos) { Thread thread = processInfo.getThread(); if (processInfo.getStatus() != Status.OK && thread.isAlive()) { log.info("Trying to interrupt thread '{}' ", thread.getName()); try { thread.interrupt(); } catch (Exception e) { log.info("Caught exception while attempting to interrupt thread", e); } } } Thread.interrupted(); } started = false; starting = false; } public synchronized void destroy() { removeMeFromMap(registeredEnginesByName); removeMeFromMap(registeredEnginesByUrl); if (parameterService != null) { parameterService.setDatabaseHasBeenInitialized(false); registeredEnginesByName.remove(getEngineName()); registeredEnginesByUrl.remove(getSyncUrl()); } stop(); if (jobManager != null) { jobManager.destroy(); } } public String reloadNode(String nodeId, String createBy) { return dataService.reloadNode(nodeId, false, createBy); } public String sendSQL(String nodeId, String catalogName, String schemaName, String tableName, String sql) { return dataService.sendSQL(nodeId, catalogName, schemaName, tableName, sql); } public RemoteNodeStatuses push() { MDC.put("engineName", getEngineName()); return pushService.push(true); } public void syncTriggers() { MDC.put("engineName", getEngineName()); triggerRouterService.syncTriggers(); } public void forceTriggerRebuild() { MDC.put("engineName", getEngineName()); triggerRouterService.syncTriggers(true); } public NodeStatus getNodeStatus() { return nodeService.getNodeStatus(); } public void removeAndCleanupNode(String nodeId) { log.info("Removing node {}", nodeId); nodeService.deleteNode(nodeId, false); log.info("Done removing node ID {}", nodeId); } public RemoteNodeStatuses pull() { MDC.put("engineName", getEngineName()); return pullService.pullData(true); } public void route() { MDC.put("engineName", getEngineName()); routerService.routeData(true); } public void purge() { MDC.put("engineName", getEngineName()); purgeService.purgeOutgoing(true); purgeService.purgeIncoming(true); } public boolean isConfigured() { boolean configurationValid = false; boolean isRegistrationServer = getNodeService().isRegistrationServer(); boolean isSelfConfigurable = isRegistrationServer && (getParameterService() .is(ParameterConstants.AUTO_INSERT_REG_SVR_IF_NOT_FOUND, false) || StringUtils.isNotBlank( getParameterService().getString(ParameterConstants.AUTO_CONFIGURE_REG_SVR_SQL_SCRIPT))); Table symNodeTable = symmetricDialect.getPlatform().readTableFromDatabase(null, null, TableConstants.getTableName(parameterService.getTablePrefix(), TableConstants.SYM_NODE)); Node node = symNodeTable != null ? getNodeService().findIdentity() : null; long offlineNodeDetectionPeriodSeconds = getParameterService() .getLong(ParameterConstants.OFFLINE_NODE_DETECTION_PERIOD_MINUTES) * 60; long heartbeatSeconds = getParameterService().getLong(ParameterConstants.HEARTBEAT_SYNC_ON_PUSH_PERIOD_SEC); String registrationUrl = getParameterService().getRegistrationUrl(); if (!isSelfConfigurable && node == null && isRegistrationServer) { log.warn( "This node is configured as a registration server, but it is missing its node_identity. It probably needs configured.", ParameterConstants.REGISTRATION_URL); } else if (!isSelfConfigurable && node == null && StringUtils.isBlank(getParameterService().getRegistrationUrl())) { log.warn( "Please set the property {} so this node may pull registration or manually insert configuration into the configuration tables", ParameterConstants.REGISTRATION_URL); } else if (Constants.PLEASE_SET_ME.equals(registrationUrl)) { log.warn("Please set the registration.url for the node"); } else if (Constants.PLEASE_SET_ME.equals(getParameterService().getNodeGroupId())) { log.warn("Please set the group.id for the node"); } else if (Constants.PLEASE_SET_ME.equals(getParameterService().getExternalId())) { log.warn("Please set the external.id for the node"); } else if (offlineNodeDetectionPeriodSeconds > 0 && offlineNodeDetectionPeriodSeconds <= heartbeatSeconds) { // Offline node detection is not disabled (-1) and the value is too // small (less than the heartbeat) log.warn( "The {} property must be a longer period of time than the {} property. Otherwise, nodes will be taken offline before the heartbeat job has a chance to run", ParameterConstants.OFFLINE_NODE_DETECTION_PERIOD_MINUTES, ParameterConstants.HEARTBEAT_SYNC_ON_PUSH_PERIOD_SEC); } else if (node != null && Version.isOlderMinorVersion(Version.version(), node.getSymmetricVersion())) { log.warn( "SymmetricDS does not support automatic downgrading. The current version running version of {} is older than the last running version of {}", Version.version(), node.getSymmetricVersion()); } else { if (node != null && Version.isOlderMinorVersion(node.getSymmetricVersion(), Version.version())) { log.debug("The current version of {} is newer than the last running version of {}", Version.version(), node.getSymmetricVersion()); } configurationValid = true; } return configurationValid; } public void heartbeat(boolean force) { MDC.put("engineName", getEngineName()); dataService.heartbeat(force); } public void openRegistration(String nodeGroupId, String externalId) { MDC.put("engineName", getEngineName()); registrationService.openRegistration(nodeGroupId, externalId); } public void clearCaches() { getTriggerRouterService().clearCache(); getParameterService().rereadParameters(); getTransformService().clearCache(); getDataLoaderService().clearCache(); getConfigurationService().clearCache(); getNodeService().flushNodeAuthorizedCache(); } public void reOpenRegistration(String nodeId) { MDC.put("engineName", getEngineName()); registrationService.reOpenRegistration(nodeId); } public boolean isRegistered() { return nodeService.findIdentity() != null; } public boolean isStarted() { return started; } public boolean isStarting() { return starting; } public IConfigurationService getConfigurationService() { return configurationService; } public IParameterService getParameterService() { return parameterService; } public INodeService getNodeService() { return nodeService; } public IRegistrationService getRegistrationService() { return registrationService; } public IClusterService getClusterService() { return clusterService; } public IPurgeService getPurgeService() { return purgeService; } public IDataService getDataService() { return dataService; } public ISymmetricDialect getSymmetricDialect() { return symmetricDialect; } public IJobManager getJobManager() { return this.jobManager; } public IOutgoingBatchService getOutgoingBatchService() { return outgoingBatchService; } public IAcknowledgeService getAcknowledgeService() { return this.acknowledgeService; } public IBandwidthService getBandwidthService() { return bandwidthService; } public IDataExtractorService getDataExtractorService() { return this.dataExtractorService; } public IDataLoaderService getDataLoaderService() { return this.dataLoaderService; } public IIncomingBatchService getIncomingBatchService() { return this.incomingBatchService; } public IPullService getPullService() { return this.pullService; } public IPushService getPushService() { return this.pushService; } public IRouterService getRouterService() { return this.routerService; } public ISecurityService getSecurityService() { return securityService; } public IStatisticService getStatisticService() { return statisticService; } public IStatisticManager getStatisticManager() { return statisticManager; } public ITriggerRouterService getTriggerRouterService() { return triggerRouterService; } public String getDeploymentType() { return deploymentType; } public ITransformService getTransformService() { return this.transformService; } public ILoadFilterService getLoadFilterService() { return this.loadFilterService; } public IConcurrentConnectionManager getConcurrentConnectionManager() { return concurrentConnectionManager; } public String getTablePrefix() { return parameterService.getTablePrefix(); } public ITransportManager getTransportManager() { return transportManager; } public IExtensionService getExtensionService() { return extensionService; } public IStagingManager getStagingManager() { return stagingManager; } public ISequenceService getSequenceService() { return sequenceService; } public INodeCommunicationService getNodeCommunicationService() { return nodeCommunicationService; } public IGroupletService getGroupletService() { return groupletService; } private void removeMeFromMap(Map<String, ISymmetricEngine> map) { Set<String> keys = new HashSet<String>(map.keySet()); for (String key : keys) { if (this.equals(map.get(key))) { map.remove(key); } } } /** * Register this instance of the engine so it can be found by other * processes in the JVM. * * @see #findEngineByUrl(String) */ private void registerHandleToEngine() { String url = getSyncUrl(); ISymmetricEngine alreadyRegister = registeredEnginesByUrl.get(url); if (alreadyRegister == null || alreadyRegister.equals(this)) { if (url != null) { registeredEnginesByUrl.put(url, this); } } else { log.warn("Could not register engine. There was already an engine registered under the url: {}", getSyncUrl()); } alreadyRegister = registeredEnginesByName.get(getEngineName()); if (alreadyRegister == null || alreadyRegister.equals(this)) { registeredEnginesByName.put(getEngineName(), this); } else { throw new EngineAlreadyRegisteredException( "Could not register engine. There was already an engine registered under the name: " + getEngineName()); } } public Date getLastRestartTime() { return lastRestartTime; } public ISqlTemplate getSqlTemplate() { return getSymmetricDialect().getPlatform().getSqlTemplate(); } public Logger getLog() { return log; } @SuppressWarnings("unchecked") public <T> T getDataSource() { return (T) getSymmetricDialect().getPlatform().getDataSource(); } public IDatabasePlatform getDatabasePlatform() { return getSymmetricDialect().getPlatform(); } public IFileSyncService getFileSyncService() { return fileSyncService; } }