Java tutorial
/******************************************************************************* * Copyright (c) 2006-2010 eBay Inc. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 *******************************************************************************/ /** * */ package org.ebayopensource.turmeric.eclipse.resources.util; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.ArrayList; import java.util.Collection; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.apache.commons.io.FileUtils; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.ebayopensource.turmeric.eclipse.core.logging.SOALogger; import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOAProjectConstants; import org.ebayopensource.turmeric.eclipse.resources.model.AssetInfo; import org.ebayopensource.turmeric.eclipse.resources.model.ISOAConsumerProject; import org.ebayopensource.turmeric.eclipse.resources.model.ISOAConsumerProject.SOAClientConfig; import org.ebayopensource.turmeric.eclipse.resources.model.ISOAConsumerProject.SOAClientEnvironment; import org.ebayopensource.turmeric.eclipse.resources.model.ISOAProject.SOAProjectSourceDirectory; import org.ebayopensource.turmeric.eclipse.resources.model.SOAConsumerProject; import org.ebayopensource.turmeric.eclipse.resources.model.SOAIntfMetadata; import org.ebayopensource.turmeric.eclipse.utils.collections.ListUtil; import org.ebayopensource.turmeric.eclipse.utils.io.PropertiesFileUtil; import org.ebayopensource.turmeric.eclipse.utils.lang.StringUtil; import org.ebayopensource.turmeric.eclipse.utils.plugin.EclipseMessageUtils; import org.ebayopensource.turmeric.eclipse.utils.plugin.JDTUtil; import org.ebayopensource.turmeric.eclipse.utils.plugin.WorkspaceUtil; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IFolder; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jdt.core.IClasspathEntry; import org.jdom.JDOMException; /** * The Class SOAConsumerUtil. * * @author yayu * @since 1.0.0 */ public final class SOAConsumerUtil { private static final SOALogger logger = SOALogger.getLogger(); /** * */ private SOAConsumerUtil() { super(); } /** * Removes the client config files. * * @param project the project * @param monitor the monitor * @param serviceNames the service names * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static void removeClientConfigFiles(final IProject project, IProgressMonitor monitor, final String... serviceNames) throws CoreException, IOException { IFolder parentFolder = project.getFolder(SOAConsumerProject.META_SRC_ClIENT_CONFIG); if (parentFolder != null && parentFolder.exists() && serviceNames != null) { final String clientName = getClientName(project); parentFolder = parentFolder.getFolder(clientName); if (parentFolder.exists()) { for (IResource envResource : parentFolder.members()) { if (envResource.exists()) { IFolder envFolder = (IFolder) envResource; for (final String serviceName : serviceNames) { final IFolder folder = envFolder.getFolder(serviceName); if (folder != null && folder.exists()) { final File file = new File(folder.getLocation().toString()); FileUtils.deleteDirectory(file); // folder.delete(true, new NullProgressMonitor()); TODO } } } } } parentFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor); } } /** * The Class ModifyConsumerIDResult. */ public static class ModifyConsumerIDResult { /** The client configs. */ final List<SOAClientConfig> clientConfigs = new ArrayList<SOAClientConfig>(); /** The old client configs. */ final List<SOAClientConfig> oldClientConfigs = new ArrayList<SOAClientConfig>(); private Properties properties = null; /** * Gets the client configs. * * @return the client configs */ public List<SOAClientConfig> getClientConfigs() { return clientConfigs; } /** * Gets the old client configs. * * @return the old client configs */ public List<SOAClientConfig> getOldClientConfigs() { return oldClientConfigs; } /** * Gets the properties. * * @return the properties */ public Properties getProperties() { return properties; } } /** * Update consumer id. * * @param consumerId the consumer id * @param consumerProject the consumer project * @return the modify consumer id result * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. * @throws JDOMException the jDOM exception */ public static ModifyConsumerIDResult updateConsumerId(String consumerId, IProject consumerProject) throws CoreException, IOException, JDOMException { final Properties props = SOAConsumerUtil.loadConsumerProperties(consumerProject); final String conId = props.getProperty(SOAProjectConstants.PROPS_KEY_CONSUMER_ID); if (consumerId.equals(conId) == false && props.containsKey(SOAProjectConstants.PROPS_KEY_SCPP_VERSION)) { //the consumer ID being entered and the version of scpp is new. final ModifyConsumerIDResult result = new ModifyConsumerIDResult(); result.properties = props; //modify the consumer-id tag in the CC.xml files as well for (IFile configFile : SOAConsumerUtil.getClientConfigFiles(consumerProject).values()) { final SOAClientConfig clientConfig = SOAClientConfigUtil.parseClientConfig(configFile); clientConfig.setConsumerId(consumerId); result.clientConfigs.add(clientConfig); if (clientConfig.getInvocationUseCase() != null) { //old client config result.oldClientConfigs.add(clientConfig); } } return result; } return null; } /** * Removes the environments. * * @param project the project * @param monitor the monitor * @param envrionmentNames the envrionment names * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static void removeEnvironments(final IProject project, IProgressMonitor monitor, final String... envrionmentNames) throws CoreException, IOException { IFolder parentFolder = project.getFolder(SOAConsumerProject.META_SRC_ClIENT_CONFIG); if (parentFolder != null && parentFolder.exists() && envrionmentNames != null) { final String clientName = getClientName(project); if (clientName == null) return; parentFolder = parentFolder.getFolder(clientName); if (parentFolder.exists()) { for (final String envName : envrionmentNames) { final IFolder folder = parentFolder.getFolder(envName); if (folder != null && folder.exists()) { final File file = new File(folder.getLocation().toString()); FileUtils.deleteDirectory(file); // folder.delete(true, new NullProgressMonitor()); TODO } } } parentFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor); } } /** * Gets the consumed service list. * * @param project the project * @return the consumed service list * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static List<String> getConsumedServiceList(IProject project) throws CoreException, IOException { final List<String> result = new ArrayList<String>(); final List<EnvironmentItem> items = SOAConsumerUtil.getClientConfigStructure(project); if (items.isEmpty() == false) { result.addAll(items.get(0).getServices()); } return result; } /** * <p> * Get all client config files of the underlying consumer project. * The key would be the environment name, and the values would be the client * config files belong to this enviroment.</p> * * <p>Note. this method would be able to handle both old and new dir structure for * ClientConfig.xml files. For the old dir structure, the environment name would * be <b>default</b>.</p> * * @param project the project * @return all client configs of the underlying consumer project * @throws CoreException the core exception */ public static Map<SOAClientEnvironment, IFile> getClientConfigFiles(final IProject project) throws CoreException { final Map<SOAClientEnvironment, IFile> result = new LinkedHashMap<SOAClientEnvironment, IFile>(); final IFolder folder = getClientConfigClientFolder(project); if (folder != null && folder.exists()) { if (isOldClientConfigDirStructure(project) == false) { //the new client config dir structure for (final IResource res : folder.members()) { if (res instanceof IFolder) { //string environment name String envName = res.getName(); for (IResource clientFolder : ((IFolder) res).members()) { if (clientFolder instanceof IFolder && ((IFolder) clientFolder) .getFile(ISOAConsumerProject.FILE_ClIENT_CONFIG).isAccessible()) { //the sub folder contains valid ClientConfig.xml file result.put(new SOAClientEnvironment(envName, clientFolder.getName()), ((IFolder) clientFolder).getFile(ISOAConsumerProject.FILE_ClIENT_CONFIG)); } } } } } else { //the OLD client config dir structure Map<String, String> svcClientMap = new ConcurrentHashMap<String, String>(); ; try { svcClientMap = SOAConsumerUtil.getMappedServiceNamesFromPropsFile(project); } catch (IOException e) { throw new CoreException(EclipseMessageUtils.createErrorStatus(e)); } for (final IResource clientFolder : folder.getParent().members()) { if (clientFolder instanceof IFolder) { //service name if (clientFolder instanceof IFolder && ((IFolder) clientFolder) .getFile(ISOAConsumerProject.FILE_ClIENT_CONFIG).isAccessible()) { //the sub folder contains valid ClientConfig.xml file final String clientFolderName = clientFolder.getName(); final String serviceName = svcClientMap.containsKey(clientFolderName) ? svcClientMap.get(clientFolderName) : clientFolderName; result.put( new SOAClientEnvironment(SOAProjectConstants.DEFAULT_CLIENT_CONFIG_ENVIRONMENT, serviceName), ((IFolder) clientFolder).getFile(ISOAConsumerProject.FILE_ClIENT_CONFIG)); } } } } } return result; } /** * Save impl metadata props. * * @param consumerProject the consumer project * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static void saveImplMetadataProps(final SOAConsumerProject consumerProject) throws IOException, CoreException { Properties properties = loadConsumerProperties(consumerProject.getProject()); PropertiesFileUtil.writeToFile(properties, consumerProject.getProject().getFile(SOAProjectConstants.PROPS_FILE_SERVICE_CONSUMER), SOAProjectConstants.PROPS_COMMENTS); } /** * Load client configs. * * @param consumerProject the consumer project * @throws Exception the exception */ public static void loadClientConfigs(final SOAConsumerProject consumerProject) throws Exception { final Map<SOAClientEnvironment, IFile> clientConfigFiles = getClientConfigFiles( consumerProject.getProject()); final Set<String> serviceNames = new LinkedHashSet<String>(); for (SOAClientEnvironment cliEnv : clientConfigFiles.keySet()) { final IFile configFile = clientConfigFiles.get(cliEnv); final SOAClientConfig config = SOAClientConfigUtil.parseClientConfig(configFile); consumerProject.getClientConfigs().put(cliEnv, config); serviceNames.add(cliEnv.getServiceName()); } fillMetadata(consumerProject, ListUtil.arrayList(serviceNames)); } /** * Fill metadata. * * @param consumerProject the consumer project * @param serviceNames the service names * @return the sOA consumer project * @throws Exception the exception */ public static SOAConsumerProject fillMetadata(final SOAConsumerProject consumerProject, final List<String> serviceNames) throws Exception { final List<SOAProjectSourceDirectory> entries = new ArrayList<SOAProjectSourceDirectory>(); for (final IClasspathEntry entry : JDTUtil.rawClasspath(consumerProject.getProject(), false)) { if (entry == null || entry.getEntryKind() != IClasspathEntry.CPE_SOURCE) continue; final String path = entry.getPath().removeFirstSegments(1).toString(); entries.add(new SOAProjectSourceDirectory(path)); } consumerProject.setSourceDirectories(entries); if (serviceNames != null) { if (consumerProject instanceof SOAConsumerProject) { ((SOAConsumerProject) consumerProject).getMetadata().setServiceNames(serviceNames); } for (final String serviceName : serviceNames) { final IProject intfProject = WorkspaceUtil.getProject(serviceName); if (intfProject != null && intfProject.isAccessible()) { SOAIntfMetadata intfMetadata = SOAServiceUtil .getSOAIntfMetadata(SOAServiceUtil.getSOAEclipseMetadata(intfProject)); intfMetadata.setServiceName(serviceName); SOAIntfUtil.fillMetadata(intfProject, intfMetadata); consumerProject.getRequiredServices().put(serviceName, intfMetadata); } } } return consumerProject; } /** * Gets the client config. * @param project * @param serviceName * @return * @throws CoreException * @throws IOException * @deprecated This is only used for the old dir structure which * does not have environment in the path. Please use another overloaded * version which has environmentName as input option. */ public static IFile getClientConfig(final IProject project, final String serviceName) throws CoreException, IOException { return getClientConfig(project, null, serviceName); } /** * Gets the client config. * * @param project the project * @param environmentName null means loading client config from old dir structure * @param serviceName the service name * @return the client config * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static IFile getClientConfig(final IProject project, final String environmentName, final String serviceName) throws CoreException, IOException { if (project == null || serviceName == null) return null; if (StringUtils.isBlank(environmentName)) { //loading old client config logger.warning("Loading client config from deprecated dir structure->" + project); return project.getFile(StringUtil.toString(SOAConsumerProject.META_SRC_ClIENT_CONFIG, serviceName, WorkspaceUtil.PATH_SEPERATOR, ISOAConsumerProject.FILE_ClIENT_CONFIG)); } else { String clientName = getClientName(project); if (StringUtils.isNotBlank(clientName)) { return project.getFile(StringUtil.toString(SOAConsumerProject.META_SRC_ClIENT_CONFIG, clientName, WorkspaceUtil.PATH_SEPERATOR, environmentName, WorkspaceUtil.PATH_SEPERATOR, serviceName, WorkspaceUtil.PATH_SEPERATOR, ISOAConsumerProject.FILE_ClIENT_CONFIG)); } } return null; } /** * Load client config. * * @param project the project * @param environmentName the environment name * @param serviceName the service name * @return the sOA client config * @throws IOException Signals that an I/O exception has occurred. * @throws JDOMException the jDOM exception * @throws CoreException the core exception */ public static SOAClientConfig loadClientConfig(final IProject project, final String environmentName, final String serviceName) throws IOException, JDOMException, CoreException { final IFile clientConfigFile = getClientConfig(project, environmentName, serviceName); if (clientConfigFile != null && clientConfigFile.isAccessible()) { return SOAClientConfigUtil.parseClientConfig(clientConfigFile); } return null; } /** * Gets the consumer properties file. * * @param project the project * @return the consumer properties file */ public static IFile getConsumerPropertiesFile(IProject project) { return project.getFile(SOAProjectConstants.PROPS_FILE_SERVICE_CONSUMER); } /** * Load consumer properties. * * @param project the project * @return the properties * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static Properties loadConsumerProperties(IProject project) throws CoreException, IOException { final Properties properties = new Properties(); InputStream ins = null; try { ins = getConsumerPropertiesFile(project).getContents(); properties.load(ins); } finally { IOUtils.closeQuietly(ins); } return properties; } /** * Gets the env mapper from consumer properties. * * @param project the project * @return the env mapper from consumer properties * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static String getEnvMapperFromConsumerProperties(IProject project) throws CoreException, IOException { return StringUtils.trim(loadConsumerProperties(project).getProperty(SOAProjectConstants.PROPS_ENV_MAPPER)); } /** * This function returns the mapped value. Lets say the client config folder * name is "a" and if a has an entry in the the properties file map,then * that entry is returned otherwise a. the format of the String in the props * file is {[a,b],[d,e]} * * @param project the project * @param clientNames the client names * @return the mapped service names from props file * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static Map<String, String> getMappedServiceNamesFromPropsFile(IProject project, String... clientNames) throws IOException, CoreException { final Map<String, String> svcClientNameMap = new ConcurrentHashMap<String, String>(); // This is a hot fix for consumers. Impls wont have this props file // This is not a very nice approach. Impls also should have // consumer properties if its a consumer. IFile consumerPropsFile = getConsumerPropertiesFile(project); if (consumerPropsFile != null && consumerPropsFile.isAccessible()) { //this should be a consumer project final Properties properties = loadConsumerProperties(project); Object objMapStr = properties.get(SOAProjectConstants.PROPS_KEY_CONSUMER_SVC_CLIENT_NAME_MAPPING); if (objMapStr != null && objMapStr instanceof String && StringUtils.isNotEmpty((String) objMapStr)) { String strMap = (String) objMapStr; strMap = StringUtils.substringBetween(strMap, "{", "}"); for (String tempStr : StringUtils.substringsBetween(strMap, "[", "]")) { String[] tempArr = StringUtils.split(tempStr, SOAProjectConstants.DELIMITER_COMMA); svcClientNameMap.put(tempArr[0], tempArr[1]); } } } if (clientNames != null) { for (String clientName : clientNames) { String svcName = svcClientNameMap.get(clientName); if (StringUtils.isEmpty(svcName)) { svcClientNameMap.put(clientName, clientName); } } } return svcClientNameMap; } /** * Gets the service client name. * * @param project the project * @return the service client name * @throws CoreException the core exception */ public static String getServiceClientName(IProject project) throws CoreException { if (isOldClientConfigDirStructure(project) == true) { return project.getName(); } else { final IFolder parentFolder = project.getFolder(SOAConsumerProject.META_SRC_ClIENT_CONFIG); if (parentFolder != null && parentFolder.exists() && parentFolder.members().length == 1) { //the correct directory structure return parentFolder.members()[0].getName(); } else if (project.getFile(SOAProjectConstants.PROPS_FILE_SERVICE_IMPL).isAccessible()) { //this is an impl project that has not consumed any services yet //this is a dirty fix, but we could not get the service name at this point final String serviceName = StringUtils.removeEnd(project.getName(), SOAProjectConstants.IMPL_PROJECT_SUFFIX); return serviceName + SOAProjectConstants.CLIENT_PROJECT_SUFFIX; } } return project.getName(); } /** * Starting from SOA v2.3.0, we have deployed a new multi client config directory strucutre. * The new path format would be <b>meta-src/META-INF/soa/client/config/<client name>/<environment>/<service name>/ClientConfig.xml</b> * * @param project the project * @return True is old client config directory structure or False otherwise * @throws CoreException the core exception * @since 1.0.0 */ public static boolean isOldClientConfigDirStructure(IProject project) throws CoreException { final IFolder parentFolder = project.getFolder(SOAConsumerProject.META_SRC_ClIENT_CONFIG); if (parentFolder != null && parentFolder.exists()) { for (final IResource res : parentFolder.members()) { if (res instanceof IFolder) { IFile file = ((IFolder) res).getFile(ISOAConsumerProject.FILE_ClIENT_CONFIG); if (file.exists() == true) { logger.warning("Project ", project, " is using the old deprecated directory structure for client config->", file.getLocation()); return true; } } } } return false; } /** * Gets the client config structure. * * @param project the project * @param availableServices the available services * @return the client config structure * @throws CoreException the core exception */ public static List<EnvironmentItem> getClientConfigStructure(IProject project, List<String> availableServices) throws CoreException { final List<EnvironmentItem> result = getClientConfigEnvironments(project, null); for (EnvironmentItem item : result) { item.setServices(availableServices); } return result; } /** * Gets the client config structure. * * @param project the project * @return the client config structure * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static List<EnvironmentItem> getClientConfigStructure(IProject project) throws CoreException, IOException { return getClientConfigStructure(project, (IProgressMonitor) null); } /** * Gets the client environment list. * * @param project the project * @param monitor the monitor * @return the client environment list * @throws CoreException the core exception */ public static List<String> getClientEnvironmentList(IProject project, IProgressMonitor monitor) throws CoreException { final List<String> clients = new ArrayList<String>(); if (project == null) return clients; final IFolder clientConfigFolder = project.getFolder(SOAConsumerProject.META_SRC_ClIENT_CONFIG); //lets do a refresh to ensure we can have the latest change, //because the user might have modified the file in an external text //editor clientConfigFolder.refreshLocal(IResource.DEPTH_ONE, monitor); if (clientConfigFolder.isAccessible() == false) { logger.warning("Client config folder is not accessible->", clientConfigFolder.getLocation()); return clients; } if (isOldClientConfigDirStructure(project) == true) { //the old dir structure clients.add(SOAProjectConstants.DEFAULT_CLIENT_CONFIG_ENVIRONMENT); } else { for (final IResource res : clientConfigFolder.members()) { if (res instanceof IFolder) { //this should be the client name for (final IResource folder : ((IFolder) res).members()) { if (folder instanceof IFolder) { //this should be the environment clients.add(folder.getName()); } } } } } return clients; } /** * Gets the client config environments. * * @param project the project * @param monitor the monitor * @return the client config environments * @throws CoreException the core exception */ public static List<EnvironmentItem> getClientConfigEnvironments(IProject project, IProgressMonitor monitor) throws CoreException { final List<EnvironmentItem> clients = new ArrayList<EnvironmentItem>(); for (String envName : getClientEnvironmentList(project, monitor)) { clients.add(new EnvironmentItem(envName)); } return clients; } /** * Gets the client name. * * @param project the project * @return the client name * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static String getClientName(IProject project) throws IOException, CoreException { final IFile file = getConsumerPropertiesFile(project); //the default name is same as the project name String clientName = project.getName(); if (file.exists() == true) { final Properties props = loadConsumerProperties(project); clientName = StringUtils.trim(props.getProperty(SOAProjectConstants.PROPS_KEY_CLIENT_NAME, clientName)); } else { logger.warning("service_consumer_project.properties file is missing, so use the project name instead->", project.getName()); } return clientName; } public static boolean isZeroConfigEnabled(IProject project) throws IOException, CoreException { final IFile file = getConsumerPropertiesFile(project); //the default name is same as the project name boolean isZeroConfig = Boolean.FALSE; if (file.exists() == true) { final Properties props = loadConsumerProperties(project); isZeroConfig = Boolean.valueOf(StringUtils.trim( props.getProperty(SOAProjectConstants.PROPS_SUPPORT_ZERO_CONFIG, Boolean.FALSE.toString()))); } else { logger.warning( "service_consumer_project.properties file is missing, so use the support_zero_config=false instead"); } return isZeroConfig; } /** * Gets the client config client folder. * * @param project the project * @return the client config client folder * @throws CoreException the core exception */ public static IFolder getClientConfigClientFolder(IProject project) throws CoreException { final IFolder clientConfigFolder = project.getFolder(SOAConsumerProject.META_SRC_ClIENT_CONFIG); //lets do a refresh to ensure we can have the latest change, //because the user might have modified the file in an external text //editor clientConfigFolder.refreshLocal(IResource.DEPTH_ONE, null); if (clientConfigFolder.isAccessible() == false) { logger.warning("Client config folder is not accessible->", clientConfigFolder.getLocation()); return null; } for (final IResource res : clientConfigFolder.members()) { if (res instanceof IFolder) { //this should be the client name return (IFolder) res; } } return null; } /** * Clone environment. * * @param project the project * @param existingEnvName the existing env name * @param newEnvName the new env name * @param monitor the monitor * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static void cloneEnvironment(IProject project, String existingEnvName, String newEnvName, IProgressMonitor monitor) throws CoreException, IOException { final IFolder clientFolder = getClientConfigClientFolder(project); if (clientFolder != null) { IFolder srcFolder = clientFolder.getFolder(existingEnvName); if (srcFolder.exists()) { IFolder targetFolder = clientFolder.getFolder(newEnvName); FileUtils.copyDirectory(srcFolder.getLocation().toFile(), targetFolder.getLocation().toFile(), true); monitor.worked(10); clientFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor); } } } /** * Add an admin name into the consumer_project.props file to indicate that the base * consumer should not be generated in the consumer project. * * @param project the project * @param addedAdminNames the added admin names * @param removedAdminNames the removed admin names * @param monitor the monitor * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static void modifyNotGenerateBaseConsumers(final IProject project, final Collection<String> addedAdminNames, final Collection<String> removedAdminNames, IProgressMonitor monitor) throws CoreException, IOException { final Properties props = loadConsumerProperties(project); final List<String> adminNames = ListUtil.arrayList( StringUtils.split(props.getProperty(SOAProjectConstants.PROPS_NOT_GENERATE_BASE_CONSUMER, ""), SOAProjectConstants.DELIMITER_COMMA)); for (String adminName : addedAdminNames) { if (adminNames.contains(adminName) == false) { adminNames.add(adminName); } else { logger.warning("Admin name already exist in the not_genreate_base_consumer propery->", adminName); } } for (String adminName : removedAdminNames) { if (adminNames.contains(adminName) == true) { adminNames.remove(adminName); } else { logger.debug("The admin name does not exist in the not_genreate_base_consumer property->", adminName); } } props.setProperty(SOAProjectConstants.PROPS_NOT_GENERATE_BASE_CONSUMER, StringUtils.join(adminNames, SOAProjectConstants.DELIMITER_COMMA)); savePropsFileForConsumer(project, props, monitor); } /** * Save props file for consumer. * * @param project the project * @param props the props * @param monitor the monitor * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static void savePropsFileForConsumer(IProject project, final Properties props, IProgressMonitor monitor) throws IOException, CoreException { final IFile file = SOAConsumerUtil.getConsumerPropertiesFile(project); OutputStream output = null; try { output = new ByteArrayOutputStream(); props.store(output, SOAProjectConstants.PROPS_COMMENTS); WorkspaceUtil.writeToFile(output.toString(), file, monitor); } finally { IOUtils.closeQuietly(output); } } /** * Gets the client config structure. * * @param project the project * @param monitor the monitor * @return the client config structure * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static List<EnvironmentItem> getClientConfigStructure(IProject project, IProgressMonitor monitor) throws CoreException, IOException { final List<EnvironmentItem> clients = getClientConfigEnvironments(project, monitor); if (clients.isEmpty()) return clients; IFolder clientConfigFolder = project.getFolder(SOAConsumerProject.META_SRC_ClIENT_CONFIG); if (isOldClientConfigDirStructure(project) == true) { //the old dir structure EnvironmentItem item = clients.get(0); for (final IResource res : clientConfigFolder.members()) { if (res instanceof IFolder) { // each service should have a corresponding folder in here // using its service name String svcName = res.getName(); item.addService(svcName); } } } else { final String clientName = getClientName(project); clientConfigFolder = clientConfigFolder.getFolder(clientName); if (clientConfigFolder.exists() == false) { logger.warning("Client Config folder is missing->", clientConfigFolder.getLocation()); return clients; } for (final EnvironmentItem item : clients) { for (final IResource child : clientConfigFolder.getFolder(item.getName()).members()) { //this should be the service names if (child instanceof IFolder) { final IFolder folder = (IFolder) child; final IFile clientFile = folder.getFile(ISOAConsumerProject.FILE_ClIENT_CONFIG); if (clientFile.isAccessible() == true) { item.addService(folder.getName()); if (clients.contains(item) == false) { //we only add the environment if and //only if it contains valid ClientConfig.xml files clients.add(item); } } } } } } return clients; } /** * The Class EnvironmentItem. */ public static class EnvironmentItem { private String name; private List<String> services = new ArrayList<String>(); private Map<String, AssetInfo> serviceData = new ConcurrentHashMap<String, AssetInfo>(); /** * Instantiates a new environment item. * * @param name the name */ public EnvironmentItem(String name) { super(); this.name = name; } /** * Gets the name. * * @return the name */ public String getName() { return name; } /** * Sets the name. * * @param name the new name */ public void setName(String name) { this.name = name; } /** * Gets the services. * * @return the services */ public List<String> getServices() { return services; } /** * Removes the service. * * @param service the service */ public void removeService(String service) { services.remove(service); serviceData.remove(service); } /** * Adds the service. * * @param service the service * @return true, if successful */ public boolean addService(String service) { return services.add(service); } /** * Sets the services. * * @param services the new services */ public void setServices(List<String> services) { this.services = services; } /** * Gets the service data. * * @param serviceName the service name * @return the service data */ public AssetInfo getServiceData(String serviceName) { return serviceData.get(serviceName); } /** * Gets the service data. * * @return the service data */ public Map<String, AssetInfo> getServiceData() { return serviceData; } /** * Sets the service data. * * @param serviceData the service data */ public void setServiceData(Map<String, AssetInfo> serviceData) { this.serviceData = serviceData; } /** * Adds the service data. * * @param svcData the svc data */ public void addServiceData(AssetInfo svcData) { if (services.contains(svcData.getName()) == false) services.add(svcData.getName()); serviceData.put(svcData.getName(), svcData); } /** * {@inheritDoc} */ @Override public String toString() { return this.name; } } }