DataSourceManager.java

package org.jvalue.ods.data;


import com.google.inject.Inject;

import org.ektorp.DocumentNotFoundException;
import org.jvalue.commons.couchdb.DbConnectorFactory;
import org.jvalue.commons.utils.Assert;
import org.jvalue.commons.utils.Cache;
import org.jvalue.ods.api.sources.DataSource;
import org.jvalue.ods.db.DataRepository;
import org.jvalue.ods.db.DataSourceRepository;
import org.jvalue.ods.db.RepositoryFactory;
import org.jvalue.ods.notifications.NotificationManager;
import org.jvalue.ods.processor.ProcessorChainManager;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import io.dropwizard.lifecycle.Managed;

public final class DataSourceManager implements Managed {

	private final DataSourceRepository dataSourceRepository;
	private final Cache<DataRepository> dataRepositoryCache;
	private final DbConnectorFactory dbConnectorFactory;
	private final RepositoryFactory repositoryFactory;
	private final ProcessorChainManager processorChainManager;
	private final DataViewManager dataViewManager;
	private final NotificationManager notificationManager;

	@Inject
	public DataSourceManager(
			DataSourceRepository dataSourceRepository,
			Cache<DataRepository> dataRepositoryCache,
			DbConnectorFactory dbConnectorFactory,
			RepositoryFactory repositoryFactory,
			ProcessorChainManager processorChainManager,
			DataViewManager dataViewManager,
			NotificationManager notificationManager) {

		this.dataSourceRepository = dataSourceRepository;
		this.dataRepositoryCache = dataRepositoryCache;
		this.dbConnectorFactory = dbConnectorFactory;
		this.repositoryFactory = repositoryFactory;
		this.processorChainManager = processorChainManager;
		this.dataViewManager = dataViewManager;
		this.notificationManager = notificationManager;
	}


	public void add(DataSource source) {
		Assert.assertNotNull(source);

		// create data repository
		createDataRepository(source);

		// store source
		dataSourceRepository.add(source);
	}


	public void remove(DataSource source) {
		Assert.assertNotNull(source);

		// delete source
		dataSourceRepository.remove(source);

		// delete source db
		dataRepositoryCache.remove(source.getId());
		processorChainManager.removeAll(source);
		dataViewManager.removeAll(source);
		notificationManager.removeAll(source);
		dbConnectorFactory.deleteDatabase(source.getId());
	}


	public List<DataSource> getAll() {
		return dataSourceRepository.getAll();
	}


	public DataSource findBySourceId(String sourceId) throws DocumentNotFoundException {
		return dataSourceRepository.findById(sourceId);
	}


	public DataRepository getDataRepository(DataSource source) {
		Assert.assertNotNull(source);
		return dataRepositoryCache.get(source.getId());
	}


	public boolean isValidSourceId(String sourceId) {
		try {
			findBySourceId(sourceId);
			return true;
		} catch (DocumentNotFoundException dnfe) {
			return false;
		}
	}


	@Override
	public void start() {
		// create data repositories
		Map<DataSource, DataRepository> sources = new HashMap<>();
		for (DataSource source : dataSourceRepository.getAll()) {
			sources.put(source, createDataRepository(source));
		}

		// start filter chains
		processorChainManager.startAllProcessorChains(sources);
	}


	@Override
	public void stop() {
		processorChainManager.stopAllProcessorChains();
	}


	private DataRepository createDataRepository(DataSource source) {
		DataRepository dataRepository = repositoryFactory.createSourceDataRepository(source.getId(), source.getDomainIdKey());
		dataRepositoryCache.put(source.getId(), dataRepository);
		return dataRepository;
	}

}