org.opencastproject.search.remote.SearchServiceRemoteImpl.java Source code

Java tutorial

Introduction

Here is the source code for org.opencastproject.search.remote.SearchServiceRemoteImpl.java

Source

/**
 *  Copyright 2009, 2010 The Regents of the University of California
 *  Licensed under the Educational Community 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.osedu.org/licenses/ECL-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.opencastproject.search.remote;

import org.opencastproject.job.api.Job;
import org.opencastproject.job.api.JobParser;
import org.opencastproject.mediapackage.MediaPackage;
import org.opencastproject.mediapackage.MediaPackageElementFlavor;
import org.opencastproject.mediapackage.MediaPackageParser;
import org.opencastproject.search.api.SearchException;
import org.opencastproject.search.api.SearchQuery;
import org.opencastproject.search.api.SearchResult;
import org.opencastproject.search.api.SearchResultImpl;
import org.opencastproject.search.api.SearchService;
import org.opencastproject.security.api.UnauthorizedException;
import org.opencastproject.serviceregistry.api.RemoteBase;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
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.client.utils.URLEncodedUtils;
import org.apache.http.message.BasicNameValuePair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

/**
 * A proxy to a remote search service.
 */
public class SearchServiceRemoteImpl extends RemoteBase implements SearchService {
    private static final Logger logger = LoggerFactory.getLogger(SearchServiceRemoteImpl.class);

    public SearchServiceRemoteImpl() {
        super(JOB_TYPE);
    }

    /**
     * {@inheritDoc}
     * 
     * @see org.opencastproject.search.api.SearchService#add(org.opencastproject.mediapackage.MediaPackage)
     */
    @Override
    public Job add(MediaPackage mediaPackage) throws SearchException {
        HttpPost post = new HttpPost("/add");
        try {
            List<BasicNameValuePair> params = new ArrayList<BasicNameValuePair>();
            params.add(new BasicNameValuePair("mediapackage", MediaPackageParser.getAsXml(mediaPackage)));
            post.setEntity(new UrlEncodedFormEntity(params));
        } catch (Exception e) {
            throw new SearchException("Unable to assemble a remote search request for mediapackage " + mediaPackage,
                    e);
        }

        HttpResponse response = getResponse(post);
        try {
            if (response != null) {
                Job job = JobParser.parseJob(response.getEntity().getContent());
                logger.info("Publishing mediapackage '{}' using a remote search service",
                        mediaPackage.getIdentifier());
                return job;
            }
        } catch (Exception e) {
            throw new SearchException(
                    "Unable to publish " + mediaPackage.getIdentifier() + " using a remote search service", e);
        } finally {
            closeConnection(response);
        }

        throw new SearchException(
                "Unable to publish " + mediaPackage.getIdentifier() + " using a remote search service");
    }

    /**
     * {@inheritDoc}
     * 
     * @see org.opencastproject.search.api.SearchService#delete(java.lang.String)
     */
    @Override
    public Job delete(String mediaPackageId) throws SearchException {
        HttpDelete del = new HttpDelete(mediaPackageId);
        HttpResponse response = getResponse(del);
        try {
            if (response != null) {
                Job job = JobParser.parseJob(response.getEntity().getContent());
                logger.info("Removing mediapackage '{}' from a remote search service", mediaPackageId);
                return job;
            }
        } catch (Exception e) {
            throw new SearchException("Unable to remove " + mediaPackageId + " from a remote search service", e);
        } finally {
            closeConnection(response);
        }

        throw new SearchException("Unable to remove " + mediaPackageId + " from a remote search service");
    }

    /**
     * {@inheritDoc}
     * 
     * @see org.opencastproject.search.api.SearchService#getByQuery(org.opencastproject.search.api.SearchQuery)
     */
    @Override
    public SearchResult getByQuery(SearchQuery q) throws SearchException {
        HttpGet get = new HttpGet(getSearchUrl(q, false));
        HttpResponse response = getResponse(get);
        try {
            if (response != null)
                return SearchResultImpl.valueOf(response.getEntity().getContent());
        } catch (Exception e) {
            throw new SearchException("Unable to parse results of a getByQuery request from remote search index: ",
                    e);
        } finally {
            closeConnection(response);
        }
        throw new SearchException("Unable to perform getByQuery from remote search index");
    }

    /**
     * {@inheritDoc}
     * 
     * @see org.opencastproject.search.api.SearchService#getForAdministrativeRead(org.opencastproject.search.api.SearchQuery)
     */
    @Override
    public SearchResult getForAdministrativeRead(SearchQuery q) throws SearchException, UnauthorizedException {
        HttpGet get = new HttpGet(getSearchUrl(q, true));
        HttpResponse response = getResponse(get);
        try {
            if (response != null)
                return SearchResultImpl.valueOf(response.getEntity().getContent());
        } catch (Exception e) {
            throw new SearchException(
                    "Unable to parse results of a getForAdministrativeRead request from remote search index: ", e);
        } finally {
            closeConnection(response);
        }
        throw new SearchException("Unable to perform getForAdministrativeRead from remote search index");
    }

    /**
     * {@inheritDoc}
     * 
     * @see org.opencastproject.search.api.SearchService#getByQuery(java.lang.String, int, int)
     */
    @Override
    public SearchResult getByQuery(String query, int limit, int offset) throws SearchException {
        List<NameValuePair> queryStringParams = new ArrayList<NameValuePair>();
        queryStringParams.add(new BasicNameValuePair("q", query));
        queryStringParams.add(new BasicNameValuePair("limit", Integer.toString(limit)));
        queryStringParams.add(new BasicNameValuePair("offset", Integer.toString(offset)));
        queryStringParams.add(new BasicNameValuePair("admin", Boolean.TRUE.toString()));
        HttpGet get = new HttpGet("/lucene.xml?" + URLEncodedUtils.format(queryStringParams, "UTF-8"));
        logger.debug("Sending remote query '{}'", get.getRequestLine().toString());
        HttpResponse response = getResponse(get);
        try {
            if (response != null)
                return SearchResultImpl.valueOf(response.getEntity().getContent());
        } catch (Exception e) {
            throw new SearchException("Unable to parse getByQuery response from remote search index", e);
        } finally {
            closeConnection(response);
        }
        throw new SearchException("Unable to perform getByQuery from remote search index");
    }

    /**
     * Builds the a search URL.
     * 
     * @param q
     *          the search query
     * @param admin
     *          whether this is for an administrative read
     * @return the search URL
     */
    private String getSearchUrl(SearchQuery q, boolean admin) {
        StringBuilder url = new StringBuilder();
        List<NameValuePair> queryStringParams = new ArrayList<NameValuePair>();

        if (q.getSeriesId() != null || q.getElementFlavors() != null || q.getElementTags() != null) {
            url.append("/episode.xml?");

            if (q.getSeriesId() != null)
                queryStringParams.add(new BasicNameValuePair("sid", q.getSeriesId()));

            if (q.getElementFlavors() != null) {
                for (MediaPackageElementFlavor f : q.getElementFlavors()) {
                    queryStringParams.add(new BasicNameValuePair("flavor", f.toString()));
                }
            }

            if (q.getElementTags() != null) {
                for (String t : q.getElementTags()) {
                    queryStringParams.add(new BasicNameValuePair("tag", t));
                }
            }
        } else {
            url.append("/series.xml?");
            queryStringParams.add(new BasicNameValuePair("series", Boolean.toString(q.isIncludeSeries())));
            queryStringParams.add(new BasicNameValuePair("episodes", Boolean.toString(q.isIncludeEpisodes())));
        }

        // General query parameters
        if (q.getText() != null)
            queryStringParams.add(new BasicNameValuePair("q", q.getText()));

        if (q.getId() != null)
            queryStringParams.add(new BasicNameValuePair("id", q.getId()));

        if (admin) {
            queryStringParams.add(new BasicNameValuePair("admin", Boolean.TRUE.toString()));
        } else {
            queryStringParams.add(new BasicNameValuePair("admin", Boolean.FALSE.toString()));
        }

        queryStringParams.add(new BasicNameValuePair("limit", Integer.toString(q.getLimit())));
        queryStringParams.add(new BasicNameValuePair("offset", Integer.toString(q.getOffset())));

        url.append(URLEncodedUtils.format(queryStringParams, "UTF-8"));
        return url.toString();
    }

}