client/marmotta-client-java/src/main/java/org/apache/marmotta/client/clients/ConfigurationClient.java

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF 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.apache.marmotta.client.clients;

import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentProducer;
import org.apache.http.entity.EntityTemplate;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.marmotta.client.ClientConfiguration;
import org.apache.marmotta.client.exception.MarmottaClientException;
import org.apache.marmotta.client.exception.NotFoundException;
import org.apache.marmotta.client.model.config.Configuration;
import org.apache.marmotta.client.util.HTTPUtil;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A client that supports accessing the configuration webservice of the Apache Marmotta. May be used for
 * retrieving as well as changing properties.
 *
 * <p/>
 * Author: Sebastian Schaffert
 */
public class ConfigurationClient {
    private static Logger log = LoggerFactory.getLogger(ConfigurationClient.class);

    private static final String URL_CONFIG_SERVICE = "/config";


    private ClientConfiguration config;

    public ConfigurationClient(ClientConfiguration config) {
        this.config = config;
    }

    /**
     * Return a list of all configuration keys that are currently set in the Marmotta configuration.
     * @return
     * @throws IOException
     * @throws MarmottaClientException
     */
    public Set<String> listConfigurationKeys() throws IOException, MarmottaClientException {
        HttpGet get = new HttpGet(config.getMarmottaUri() + URL_CONFIG_SERVICE + "/list");
        get.setHeader("Accept", "application/json");

        try(CloseableHttpClient httpClient = HTTPUtil.createClient(config)) {
            
            HttpResponse response = httpClient.execute(get);

            switch(response.getStatusLine().getStatusCode()) {
                case 200:
                    log.debug("configurations listed successfully");
                    ObjectMapper mapper = new ObjectMapper();
                    Map<String,Map<String,Object>> result =
                            mapper.readValue(response.getEntity().getContent(),new TypeReference<Map<String,Map<String,Object>>>(){});
                    return result.keySet();
                default:
                    log.error("error retrieving list of configuration keys: {} {}",new Object[] {response.getStatusLine().getStatusCode(),response.getStatusLine().getReasonPhrase()});
                    throw new MarmottaClientException("error retrieving list of configuration keys: "+response.getStatusLine().getStatusCode() + " " + response.getStatusLine().getReasonPhrase());
            }

        } finally {
            get.releaseConnection();
        }
    }

    /**
     * Return a list of all configurations (keys and values) that are currently set in the Marmotta configuration.
     * @return
     * @throws IOException
     * @throws MarmottaClientException
     */
    public Set<Configuration> listConfigurations(String prefix) throws IOException, MarmottaClientException {

        String serviceUrl = config.getMarmottaUri() + URL_CONFIG_SERVICE + "/list" + (prefix != null? "?prefix="+ URLEncoder.encode(prefix,"utf-8") : "");

        HttpGet get = new HttpGet(serviceUrl);
        get.setHeader("Accept", "application/json");
        
        try(CloseableHttpClient httpClient = HTTPUtil.createClient(config)) {

            HttpResponse response = httpClient.execute(get);

            switch(response.getStatusLine().getStatusCode()) {
                case 200:
                    log.debug("configurations listed successfully");
                    ObjectMapper mapper = new ObjectMapper();
                    Map<String,Map<String,Object>> resultMap =
                            mapper.readValue(response.getEntity().getContent(),new TypeReference<Map<String,Map<String,Object>>>(){});
                    
                    Set<Configuration> result = new HashSet<Configuration>();
                    for(Map.Entry<String,Map<String,Object>> entry : resultMap.entrySet()) {
                        result.add(new Configuration(entry.getKey(),entry.getValue().get("value")));
                    }
                    return result;
                default:
                    log.error("error retrieving list of configuration keys: {} {}",new Object[] {response.getStatusLine().getStatusCode(),response.getStatusLine().getReasonPhrase()});
                    throw new MarmottaClientException("error retrieving list of configuration keys: "+response.getStatusLine().getStatusCode() + " " + response.getStatusLine().getReasonPhrase());
            }

        } finally {
            get.releaseConnection();
        }
    }


    /**
     * Return the configuration with the given key, or null if it does not exist
     * @param key
     * @return
     * @throws IOException
     * @throws MarmottaClientException
     */
    public Configuration getConfiguration(String key) throws IOException, MarmottaClientException {
        String serviceUrl = config.getMarmottaUri() + URL_CONFIG_SERVICE + "/data/" + URLEncoder.encode(key,"utf-8");

        HttpGet get = new HttpGet(serviceUrl);
        get.setHeader("Accept", "application/json");
        
        try(CloseableHttpClient httpClient = HTTPUtil.createClient(config)) {

            HttpResponse response = httpClient.execute(get);

            switch(response.getStatusLine().getStatusCode()) {
                case 200:
                    log.debug("configuration {} retrieved successfully",key);
                    ObjectMapper mapper = new ObjectMapper();
                    Map<String,Object> resultMap =
                            mapper.readValue(response.getEntity().getContent(),new TypeReference<Map<String,Object>>(){});

                    if(resultMap.isEmpty()) {
                        return null;
                    } else {
                        return new Configuration(key,resultMap.get(key));
                    }
                case 404:
                    log.info("configuration with key {} does not exist", key);
                    return null;
                default:
                    log.error("error retrieving configuration {}: {} {}",new Object[] {key,response.getStatusLine().getStatusCode(),response.getStatusLine().getReasonPhrase()});
                    throw new MarmottaClientException("error retrieving configuration "+key+": "+response.getStatusLine().getStatusCode() + " " + response.getStatusLine().getReasonPhrase());
            }

        } finally {
            get.releaseConnection();
        }
    }

    /**
     * Update the configuration "key" with the given value. Value can be either a list of values or one of the
     * primitive types String, Boolean, Integer, Double
     * @param key
     * @param value
     * @throws IOException
     * @throws MarmottaClientException
     */
    public void setConfiguration(String key, final Object value) throws IOException, MarmottaClientException {
        String serviceUrl = config.getMarmottaUri() + URL_CONFIG_SERVICE + "/data/" + URLEncoder.encode(key,"utf-8");

        HttpPost post = new HttpPost(serviceUrl);
        post.setHeader("Content-Type", "application/json");
        ContentProducer cp = new ContentProducer() {
            @Override
            public void writeTo(OutputStream outstream) throws IOException {
                ObjectMapper mapper = new ObjectMapper();
                if(value instanceof Collection) {
                    mapper.writeValue(outstream,value);
                } else {
                    mapper.writeValue(outstream, Collections.singletonList(value.toString()));
                }
            }
        };
        post.setEntity(new EntityTemplate(cp));
        
        try(CloseableHttpClient httpClient = HTTPUtil.createClient(config)) {
            HttpResponse response = httpClient.execute(post);

            switch(response.getStatusLine().getStatusCode()) {
                case 200:
                    log.debug("configuration {} updated successfully",key);
                    break;
                case 404:
                    log.error("configuration with key {} does not exist",key);
                    throw new NotFoundException("configuration with key "+key+" does not exist");
                default:
                    log.error("error updating configuration {}: {} {}",new Object[] {key,response.getStatusLine().getStatusCode(),response.getStatusLine().getReasonPhrase()});
                    throw new MarmottaClientException("error updating configuration "+key+": "+response.getStatusLine().getStatusCode() + " " + response.getStatusLine().getReasonPhrase());
            }

        } finally {
            post.releaseConnection();
        }        
    }

    /**
     * Remove the configuration with the given key.
     *
     * @param key
     * @throws IOException
     * @throws MarmottaClientException
     */
    public void deleteConfiguration(String key) throws IOException, MarmottaClientException {
        String serviceUrl = config.getMarmottaUri() + URL_CONFIG_SERVICE + "/data/" + URLEncoder.encode(key,"utf-8");

        HttpDelete delete = new HttpDelete(serviceUrl);
            
        try(CloseableHttpClient httpClient = HTTPUtil.createClient(config)) {
            HttpResponse response = httpClient.execute(delete);

            switch(response.getStatusLine().getStatusCode()) {
                case 200:
                    log.debug("configuration {} deleted successfully",key);
                    break;
                case 404:
                    log.error("configuration with key {} does not exist",key);
                    throw new NotFoundException("configuration with key "+key+" does not exist");
                default:
                    log.error("error deleting configuration {}: {} {}",new Object[] {key,response.getStatusLine().getStatusCode(),response.getStatusLine().getReasonPhrase()});
                    throw new MarmottaClientException("error deleting configuration "+key+": "+response.getStatusLine().getStatusCode() + " " + response.getStatusLine().getReasonPhrase());
            }

        } finally {
            delete.releaseConnection();
        }
    }

}