org.eclipse.epp.mpc.core/src/org/eclipse/epp/internal/mpc/core/service/MarketplaceStorageService.java - mpc/org.eclipse.epp.mpc - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010 The Eclipse Foundation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     The Eclipse Foundation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.epp.internal.mpc.core.service;

 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CopyOnWriteArrayList;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.epp.internal.mpc.core.MarketplaceClientCore;
 import org.eclipse.epp.internal.mpc.core.util.ServiceUtil;
 import org.eclipse.epp.mpc.core.service.IMarketplaceStorageService;
 import org.eclipse.equinox.security.storage.ISecurePreferences;
 import org.eclipse.equinox.security.storage.StorageException;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.userstorage.IBlob;
 import org.eclipse.userstorage.IStorage;
 import org.eclipse.userstorage.IStorageService;
 import org.eclipse.userstorage.StorageFactory;
 import org.eclipse.userstorage.internal.StorageService;
 import org.eclipse.userstorage.oauth.EclipseOAuthCredentialsProvider;
 import org.eclipse.userstorage.spi.Credentials;
 import org.eclipse.userstorage.spi.ICredentialsProvider;
 import org.eclipse.userstorage.spi.ISettings;
 import org.eclipse.userstorage.util.FileStorageCache;
 import org.eclipse.userstorage.util.Settings;
 import org.osgi.framework.BundleContext;

 @SuppressWarnings("restriction")
 public class MarketplaceStorageService implements IMarketplaceStorageService {

 	private static final String DEFAULT_STORAGE_SERVICE_NAME = Messages.MarketplaceStorageService_defaultStorageServiceName;

 	static final String DEFAULT_APPLICATION_TOKEN = "MZ04RMOpksKN5GpxKXafq2MSjSP"; //$NON-NLS-1$

 	private static final String[] MIGRATE_SECURE_STORAGE_KEYS = { "username", "password", "termsOfUseAgreed" }; //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$

 	private String applicationToken = DEFAULT_APPLICATION_TOKEN;

 	private URI serviceUri;

 	private StorageFactory storageFactory;

 	private IStorage storage;

 	private IStorageService.Dynamic customStorageService;

 	private List<LoginListener> loginListeners;

 	private EclipseOAuthCredentialsProvider credentialsProvider;

 	private StorageConfigurer configurer;

 	public URI getServiceUri() {
 		return serviceUri;
 	}

 	public synchronized void setServiceUri(URI serviceUri) {
 		if ((this.serviceUri == null && serviceUri != null)
 				|| (this.serviceUri != null && !this.serviceUri.equals(serviceUri))) {
 			this.serviceUri = serviceUri;
 			storageFactory = null;
 			storage = null;
 		}
 	}

 	public synchronized StorageFactory getStorageFactory() {
 		if (storageFactory == null) {
 			storageFactory = createStorageFactory();
 		}
 		return storageFactory;
 	}

 	public synchronized void setStorageFactory(StorageFactory storageFactory) {
 		this.storageFactory = storageFactory;
 	}

 	protected StorageFactory createStorageFactory() {
 		if (serviceUri == null) {
 			return StorageFactory.DEFAULT;
 		}
 		Map<String, String> settingsMap = new HashMap<String, String>();
 		settingsMap.put(applicationToken, serviceUri.toString());
 		ISettings storageFactorySettings = new Settings.MemorySettings(settingsMap);
 		return new StorageFactory(storageFactorySettings);
 	}

 	protected IStorage createStorage() {
 		IStorage storage = getStorageFactory().create(applicationToken,
 				new FileStorageCache.SingleApplication(this.applicationToken));
 		try {
 			configurer = StorageConfigurer.get();
 			configurer.configure(storage);
 			configurer.setInteractive(storage, false);
 		} catch (CoreException e) {
 			configurer = null;
 			MarketplaceClientCore.error(e);
 		}
 		return storage;
 	}

 	public synchronized IStorage getStorage() {
 		if (storage == null) {
 			storage = createStorage();
 		}
 		return storage;
 	}

 	public void setStorage(IStorage storage) {
 		this.storage = storage;
 	}

 	public IBlob getBlob(String key) {
 		return getStorage().getBlob(key);
 	}

 	public String getRegisteredUser() {
 		Credentials credentials = getStorageCredentials();
 		return credentials == null ? null : credentials.getUsername();
 	}

 	public <T> T runWithLogin(Callable<T> c) throws Exception {
 		String oldUser = getCurrentUser();
 		try {
 			T result = configurer != null ? configurer.runWithLogin(storage, c) : c.call();
 			return result;
 		} finally {
 			String newUser = getCurrentUser();//TODO the OAuth token might change with the user staying the same - this would cause an unnecessary refresh event
 			notifyLoginChanged(oldUser, newUser);
 		}
 	}

 	private void notifyLoginChanged(String oldUser, String newUser) {
 		if ((newUser == null && oldUser != null) || (newUser != null && !newUser.equals(oldUser))) {
 			List<LoginListener> loginListeners = this.loginListeners;
 			if (loginListeners != null && !loginListeners.isEmpty()) {
 				for (LoginListener loginListener : loginListeners) {
 					loginListener.loginChanged(oldUser, newUser);
 				}
 			}
 		}
 	}

 	public synchronized void addLoginListener(LoginListener listener) {
 		if (loginListeners == null) {
 			loginListeners = new CopyOnWriteArrayList<LoginListener>();
 		}
 		if (!loginListeners.contains(listener)) {
 			loginListeners.add(listener);
 		}
 	}

 	public synchronized void removeLoginListener(LoginListener listener) {
 		if (loginListeners != null) {
 			loginListeners.remove(listener);
 		}
 	}

 	private String getCurrentUser() {
 		Credentials credentials = getStorageCredentials();
 		if (credentials != null && credentials.getPassword() != null) {
 			return credentials.getUsername();
 		}
 		return null;
 	}

 	private Credentials getStorageCredentials() {
 		ICredentialsProvider provider = getStorage().getCredentialsProvider();
 		if (provider == null) {
 			return null;
 		}
 		IStorageService service = getStorage().getService();
 		//return provider.hasCredentials(service) ? provider.getCredentials(service) : null;
 		return ((StorageService) service).getCredentials();
 	}

 	public void activate(BundleContext context, Map<?, ?> properties) {
 		Object serviceUrlValue = ServiceUtil.getOverridablePropertyValue(properties, STORAGE_SERVICE_URL_PROPERTY);
 		if (serviceUrlValue != null) {
 			URI serviceUri = URI.create(serviceUrlValue.toString());
 			String serviceName = getProperty(properties, STORAGE_SERVICE_NAME_PROPERTY, DEFAULT_STORAGE_SERVICE_NAME);
 			IStorageService registered = registerStorageService(serviceUri, serviceName);
 			setServiceUri(registered.getServiceURI());
 		}
 		String applicationToken = getProperty(properties, APPLICATION_TOKEN_PROPERTY, DEFAULT_APPLICATION_TOKEN);
 		this.applicationToken = applicationToken;
 	}

 	private IStorageService registerStorageService(URI serviceUri, String serviceName) {
 		customStorageService = null;
 		URI normalizedUri = normalizePath(serviceUri);
 		URI denormalizedUri = normalizePath(serviceUri, false);
 		IStorageService service = IStorageService.Registry.INSTANCE.getService(normalizedUri);
 		IStorageService extraService = IStorageService.Registry.INSTANCE.getService(denormalizedUri);
 		if (service == null) {
 			if (extraService != null) {
 				return extraService;
 			}
 			customStorageService = IStorageService.Registry.INSTANCE.addService(serviceName, normalizedUri);
 			service = customStorageService;
 			return service;
 		}
 		if (extraService != null && extraService != service) {
 			service = cleanupExtraStorageService(service, extraService);
 		}

 		return service;
 	}

 	private static IStorageService cleanupExtraStorageService(IStorageService service, IStorageService extraService) {
 		IStorageService.Dynamic removeDynamic;
 		IStorageService keepService;
 		if (extraService instanceof IStorageService.Dynamic) {
 			removeDynamic = (IStorageService.Dynamic) extraService;
 			keepService = service;
 		} else if (service instanceof IStorageService.Dynamic) {
 			removeDynamic = (IStorageService.Dynamic) service;
 			keepService = extraService;
 		} else {
 			return service;
 		}
 		if (removeDynamic instanceof StorageService && keepService instanceof StorageService) {
 			StorageService removeImpl = (StorageService) removeDynamic;
 			StorageService keepImpl = (StorageService) keepService;
 			ISecurePreferences removeSecurePreferences = removeImpl.getSecurePreferences();
 			ISecurePreferences keepSecurePreferences = keepImpl.getSecurePreferences();
 			try {
 				copySecurePreferences(removeSecurePreferences, keepSecurePreferences);
 			} catch (Exception e) {
 				MarketplaceClientCore.error(NLS.bind("Failed to migrate secure storage values from {0} to {1}",
 						removeDynamic.getServiceURI(), keepService.getServiceURI()), e);
 			}
 		}
 		removeDynamic.remove();
 		return keepService;
 	}

 	private static void copySecurePreferences(ISecurePreferences source, ISecurePreferences target)
 			throws StorageException, IOException {
 		Set<String> sourceKeys = new HashSet<String>(Arrays.asList(source.keys()));
 		Set<String> targetKeys = new HashSet<String>(Arrays.asList(target.keys()));
 		boolean changed = false;
 		for (String key : MIGRATE_SECURE_STORAGE_KEYS) {
 			if (sourceKeys.contains(key) && !targetKeys.contains(key)) {
 				boolean encrypted = source.isEncrypted(key);
 				target.put(key, source.get(key, null), encrypted);
 				changed = true;
 			}
 		}
 		if (changed) {
 			target.flush();
 		}
 	}

 	private static URI normalizePath(URI uri) {
 		return normalizePath(uri, true);
 	}

 	private static URI normalizePath(URI uri, boolean trailingSlash) {
 		if (uri.isOpaque()) {
 			return uri;
 		}
 		String path = uri.getPath();
 		String normalizedPath;
 		if (path == null) {
 			if (trailingSlash) {
 				normalizedPath = "/"; //$NON-NLS-1$
 			} else {
 				return uri;
 			}
 		} else if (path.endsWith("/")) { //$NON-NLS-1$
 			if (trailingSlash) {
 				return uri;
 			} else {
 				normalizedPath = path.length() == 1 ? null : path.substring(0, path.length() - 1);
 			}
 		} else {
 			if (trailingSlash) {
 				normalizedPath = path + "/"; //$NON-NLS-1$
 			} else {
 				return uri;
 			}
 		}
 		try {
 			return new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), normalizedPath,
 					uri.getQuery(), uri.getFragment());
 		} catch (URISyntaxException e) {
 			return uri;
 		}
 	}

 	private static String getProperty(Map<?, ?> properties, String key, String defaultValue) {
 		Object value = properties.get(key);
 		if (value == null) {
 			return defaultValue;
 		}
 		return value.toString();
 	}

 	public void deactivate() {
 		if (customStorageService != null) {
 			customStorageService.remove();
 		}
 		customStorageService = null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2010 The Eclipse Foundation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* The Eclipse Foundation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.epp.internal.mpc.core.service;

	import java.io.IOException;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.concurrent.Callable;
	import java.util.concurrent.CopyOnWriteArrayList;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.epp.internal.mpc.core.MarketplaceClientCore;
	import org.eclipse.epp.internal.mpc.core.util.ServiceUtil;
	import org.eclipse.epp.mpc.core.service.IMarketplaceStorageService;
	import org.eclipse.equinox.security.storage.ISecurePreferences;
	import org.eclipse.equinox.security.storage.StorageException;
	import org.eclipse.osgi.util.NLS;
	import org.eclipse.userstorage.IBlob;
	import org.eclipse.userstorage.IStorage;
	import org.eclipse.userstorage.IStorageService;
	import org.eclipse.userstorage.StorageFactory;
	import org.eclipse.userstorage.internal.StorageService;
	import org.eclipse.userstorage.oauth.EclipseOAuthCredentialsProvider;
	import org.eclipse.userstorage.spi.Credentials;
	import org.eclipse.userstorage.spi.ICredentialsProvider;
	import org.eclipse.userstorage.spi.ISettings;
	import org.eclipse.userstorage.util.FileStorageCache;
	import org.eclipse.userstorage.util.Settings;
	import org.osgi.framework.BundleContext;

	@SuppressWarnings("restriction")
	public class MarketplaceStorageService implements IMarketplaceStorageService {

	private static final String DEFAULT_STORAGE_SERVICE_NAME = Messages.MarketplaceStorageService_defaultStorageServiceName;

	static final String DEFAULT_APPLICATION_TOKEN = "MZ04RMOpksKN5GpxKXafq2MSjSP"; //$NON-NLS-1$

	private static final String[] MIGRATE_SECURE_STORAGE_KEYS = { "username", "password", "termsOfUseAgreed" }; //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$

	private String applicationToken = DEFAULT_APPLICATION_TOKEN;

	private URI serviceUri;

	private StorageFactory storageFactory;

	private IStorage storage;

	private IStorageService.Dynamic customStorageService;

	private List<LoginListener> loginListeners;

	private EclipseOAuthCredentialsProvider credentialsProvider;

	private StorageConfigurer configurer;

	public URI getServiceUri() {
	return serviceUri;
	}

	public synchronized void setServiceUri(URI serviceUri) {
	if ((this.serviceUri == null && serviceUri != null)
	\|\| (this.serviceUri != null && !this.serviceUri.equals(serviceUri))) {
	this.serviceUri = serviceUri;
	storageFactory = null;
	storage = null;
	}
	}

	public synchronized StorageFactory getStorageFactory() {
	if (storageFactory == null) {
	storageFactory = createStorageFactory();
	}
	return storageFactory;
	}

	public synchronized void setStorageFactory(StorageFactory storageFactory) {
	this.storageFactory = storageFactory;
	}

	protected StorageFactory createStorageFactory() {
	if (serviceUri == null) {
	return StorageFactory.DEFAULT;
	}
	Map<String, String> settingsMap = new HashMap<String, String>();
	settingsMap.put(applicationToken, serviceUri.toString());
	ISettings storageFactorySettings = new Settings.MemorySettings(settingsMap);
	return new StorageFactory(storageFactorySettings);
	}

	protected IStorage createStorage() {
	IStorage storage = getStorageFactory().create(applicationToken,
	new FileStorageCache.SingleApplication(this.applicationToken));
	try {
	configurer = StorageConfigurer.get();
	configurer.configure(storage);
	configurer.setInteractive(storage, false);
	} catch (CoreException e) {
	configurer = null;
	MarketplaceClientCore.error(e);
	}
	return storage;
	}

	public synchronized IStorage getStorage() {
	if (storage == null) {
	storage = createStorage();
	}
	return storage;
	}

	public void setStorage(IStorage storage) {
	this.storage = storage;
	}

	public IBlob getBlob(String key) {
	return getStorage().getBlob(key);
	}

	public String getRegisteredUser() {
	Credentials credentials = getStorageCredentials();
	return credentials == null ? null : credentials.getUsername();
	}

	public <T> T runWithLogin(Callable<T> c) throws Exception {
	String oldUser = getCurrentUser();
	try {
	T result = configurer != null ? configurer.runWithLogin(storage, c) : c.call();
	return result;
	} finally {
	String newUser = getCurrentUser();//TODO the OAuth token might change with the user staying the same - this would cause an unnecessary refresh event
	notifyLoginChanged(oldUser, newUser);
	}
	}

	private void notifyLoginChanged(String oldUser, String newUser) {
	if ((newUser == null && oldUser != null) \|\| (newUser != null && !newUser.equals(oldUser))) {
	List<LoginListener> loginListeners = this.loginListeners;
	if (loginListeners != null && !loginListeners.isEmpty()) {
	for (LoginListener loginListener : loginListeners) {
	loginListener.loginChanged(oldUser, newUser);
	}
	}
	}
	}

	public synchronized void addLoginListener(LoginListener listener) {
	if (loginListeners == null) {
	loginListeners = new CopyOnWriteArrayList<LoginListener>();
	}
	if (!loginListeners.contains(listener)) {
	loginListeners.add(listener);
	}
	}

	public synchronized void removeLoginListener(LoginListener listener) {
	if (loginListeners != null) {
	loginListeners.remove(listener);
	}
	}

	private String getCurrentUser() {
	Credentials credentials = getStorageCredentials();
	if (credentials != null && credentials.getPassword() != null) {
	return credentials.getUsername();
	}
	return null;
	}

	private Credentials getStorageCredentials() {
	ICredentialsProvider provider = getStorage().getCredentialsProvider();
	if (provider == null) {
	return null;
	}
	IStorageService service = getStorage().getService();
	//return provider.hasCredentials(service) ? provider.getCredentials(service) : null;
	return ((StorageService) service).getCredentials();
	}

	public void activate(BundleContext context, Map<?, ?> properties) {
	Object serviceUrlValue = ServiceUtil.getOverridablePropertyValue(properties, STORAGE_SERVICE_URL_PROPERTY);
	if (serviceUrlValue != null) {
	URI serviceUri = URI.create(serviceUrlValue.toString());
	String serviceName = getProperty(properties, STORAGE_SERVICE_NAME_PROPERTY, DEFAULT_STORAGE_SERVICE_NAME);
	IStorageService registered = registerStorageService(serviceUri, serviceName);
	setServiceUri(registered.getServiceURI());
	}
	String applicationToken = getProperty(properties, APPLICATION_TOKEN_PROPERTY, DEFAULT_APPLICATION_TOKEN);
	this.applicationToken = applicationToken;
	}

	private IStorageService registerStorageService(URI serviceUri, String serviceName) {
	customStorageService = null;
	URI normalizedUri = normalizePath(serviceUri);
	URI denormalizedUri = normalizePath(serviceUri, false);
	IStorageService service = IStorageService.Registry.INSTANCE.getService(normalizedUri);
	IStorageService extraService = IStorageService.Registry.INSTANCE.getService(denormalizedUri);
	if (service == null) {
	if (extraService != null) {
	return extraService;
	}
	customStorageService = IStorageService.Registry.INSTANCE.addService(serviceName, normalizedUri);
	service = customStorageService;
	return service;
	}
	if (extraService != null && extraService != service) {
	service = cleanupExtraStorageService(service, extraService);
	}

	return service;
	}

	private static IStorageService cleanupExtraStorageService(IStorageService service, IStorageService extraService) {
	IStorageService.Dynamic removeDynamic;
	IStorageService keepService;
	if (extraService instanceof IStorageService.Dynamic) {
	removeDynamic = (IStorageService.Dynamic) extraService;
	keepService = service;
	} else if (service instanceof IStorageService.Dynamic) {
	removeDynamic = (IStorageService.Dynamic) service;
	keepService = extraService;
	} else {
	return service;
	}
	if (removeDynamic instanceof StorageService && keepService instanceof StorageService) {
	StorageService removeImpl = (StorageService) removeDynamic;
	StorageService keepImpl = (StorageService) keepService;
	ISecurePreferences removeSecurePreferences = removeImpl.getSecurePreferences();
	ISecurePreferences keepSecurePreferences = keepImpl.getSecurePreferences();
	try {
	copySecurePreferences(removeSecurePreferences, keepSecurePreferences);
	} catch (Exception e) {
	MarketplaceClientCore.error(NLS.bind("Failed to migrate secure storage values from {0} to {1}",
	removeDynamic.getServiceURI(), keepService.getServiceURI()), e);
	}
	}
	removeDynamic.remove();
	return keepService;
	}

	private static void copySecurePreferences(ISecurePreferences source, ISecurePreferences target)
	throws StorageException, IOException {
	Set<String> sourceKeys = new HashSet<String>(Arrays.asList(source.keys()));
	Set<String> targetKeys = new HashSet<String>(Arrays.asList(target.keys()));
	boolean changed = false;
	for (String key : MIGRATE_SECURE_STORAGE_KEYS) {
	if (sourceKeys.contains(key) && !targetKeys.contains(key)) {
	boolean encrypted = source.isEncrypted(key);
	target.put(key, source.get(key, null), encrypted);
	changed = true;
	}
	}
	if (changed) {
	target.flush();
	}
	}

	private static URI normalizePath(URI uri) {
	return normalizePath(uri, true);
	}

	private static URI normalizePath(URI uri, boolean trailingSlash) {
	if (uri.isOpaque()) {
	return uri;
	}
	String path = uri.getPath();
	String normalizedPath;
	if (path == null) {
	if (trailingSlash) {
	normalizedPath = "/"; //$NON-NLS-1$
	} else {
	return uri;
	}
	} else if (path.endsWith("/")) { //$NON-NLS-1$
	if (trailingSlash) {
	return uri;
	} else {
	normalizedPath = path.length() == 1 ? null : path.substring(0, path.length() - 1);
	}
	} else {
	if (trailingSlash) {
	normalizedPath = path + "/"; //$NON-NLS-1$
	} else {
	return uri;
	}
	}
	try {
	return new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), normalizedPath,
	uri.getQuery(), uri.getFragment());
	} catch (URISyntaxException e) {
	return uri;
	}
	}

	private static String getProperty(Map<?, ?> properties, String key, String defaultValue) {
	Object value = properties.get(key);
	if (value == null) {
	return defaultValue;
	}
	return value.toString();
	}

	public void deactivate() {
	if (customStorageService != null) {
	customStorageService.remove();
	}
	customStorageService = null;
	}
	}