ContextServiceImpl.java

/**
 * Licensed to the Austrian Association for Software Tool Integration (AASTI)
 * under one or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership. The AASTI licenses this file to you 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
 *
 * 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.openengsb.core.services.internal;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import org.openengsb.core.api.context.Context;
import org.openengsb.core.api.context.ContextCurrentService;
import org.openengsb.core.api.context.ContextHolder;
import org.openengsb.core.api.context.ContextPath;
import org.openengsb.core.api.model.ContextConfiguration;
import org.openengsb.core.api.model.ContextId;
import org.openengsb.core.api.persistence.ConfigPersistenceService;
import org.openengsb.core.api.persistence.InvalidConfigurationException;
import org.openengsb.core.api.persistence.PersistenceException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ContextServiceImpl implements ContextCurrentService {

    private static final Logger LOGGER = LoggerFactory.getLogger(ContextServiceImpl.class);

    private ConfigPersistenceService configPersistence;

    @Override
    public Context getContext(String path) {
        return getContext(path, false);
    }

    @Override
    public Context getContext() {
        String currentContextId = ContextHolder.get().getCurrentContextId();
        if (currentContextId == null) {
            return null;
        }
        return getContextById(currentContextId);
    }

    @Override
    public void createContext(String contextId) {
        LOGGER.debug("Creating context %s", contextId);
        ContextConfiguration contextConfiguration =
            new ContextConfiguration(new ContextId(contextId).toMetaData(), null);
        try {
            getConfigPersistenceService().persist(contextConfiguration);
        } catch (InvalidConfigurationException e) {
            LOGGER.error("Error storing context " + contextId + ": Invalid configuration", e);
        } catch (PersistenceException e) {
            LOGGER.error("Error storing context " + contextId + ": Persistence error", e);
        }
    }

    @Override
    public void deleteContext(String contextId) {
        LOGGER.debug("deleting context {}", contextId);
        try {
            getConfigPersistenceService().remove(new ContextId(contextId).toMetaData());
        } catch (PersistenceException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<String> getAvailableContexts() {
        List<ContextConfiguration> availableContextConfigurations =
            getContextConfigurationsOrEmptyOnError(ContextId.getContextIdWildCard());
        List<String> availableContexts = new ArrayList<String>();

        for (ContextConfiguration configuration : availableContextConfigurations) {
            availableContexts.add(ContextId.fromMetaData(configuration.getMetaData()).getId());
        }

        return availableContexts;
    }

    private Context getContextById(String currentContextId) {
        ContextId contextId = new ContextId(currentContextId);
        List<ContextConfiguration> contexts = getContextConfigurationsOrEmptyOnError(contextId.toMetaData());
        if (contexts.isEmpty()) {
            return null;
        }
        return contexts.get(0).toContext();
    }

    private Context getContext(String path, boolean create) {
        Context c = getContext();
        if (c == null) {
            return null;
        }
        Context parent = null;
        for (String pathElem : new ContextPath(path).getElements()) {
            parent = c;
            c = c.getChild(pathElem);
            if (c == null) {
                if (!create) {
                    return null;
                }
                c = parent.createChild(pathElem);
            }
        }
        return c;
    }

    private List<ContextConfiguration> getContextConfigurationsOrEmptyOnError(Map<String, String> metaData) {
        try {
            ConfigPersistenceService persistence = getConfigPersistenceService();
            return persistence.load(metaData);
        } catch (Exception e) {
            LOGGER.error("Error loading context configuration from configuration persistence", e);
            return Collections.emptyList();
        }
    }

    private ConfigPersistenceService getConfigPersistenceService() {
        return configPersistence;
    }

    public void setConfigPersistence(ConfigPersistenceService configPersistence) {
        this.configPersistence = configPersistence;
    }

}