/*
* 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.chemistry.opencmis.client.bindings.impl;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import org.apache.chemistry.opencmis.client.bindings.cache.TypeDefinitionCache;
import org.apache.chemistry.opencmis.client.bindings.spi.BindingSession;
import org.apache.chemistry.opencmis.client.bindings.spi.CmisSpi;
import org.apache.chemistry.opencmis.client.bindings.spi.http.HttpInvoker;
import org.apache.chemistry.opencmis.commons.SessionParameter;
import org.apache.chemistry.opencmis.commons.enums.CmisVersion;
import org.apache.chemistry.opencmis.commons.exceptions.CmisBaseException;
import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException;
import org.apache.chemistry.opencmis.commons.impl.ClassLoaderUtil;
import org.apache.chemistry.opencmis.commons.spi.AuthenticationProvider;
/**
* A collection of static methods that are used in multiple places within the
* bindings implementation.
*/
public final class CmisBindingsHelper {
public static final String REPOSITORY_INFO_CACHE = "org.apache.chemistry.opencmis.binding.repositoryInfoCache";
public static final String TYPE_DEFINTION_CACHE = "org.apache.chemistry.opencmis.binding.typeDefintionCache";
public static final String SPI_OBJECT = "org.apache.chemistry.opencmis.binding.spi.object";
public static final String HTTP_INVOKER_OBJECT = "org.apache.chemistry.opencmis.binding.httpinvoker.object";
public static final String AUTHENTICATION_PROVIDER_OBJECT = "org.apache.chemistry.opencmis.binding.auth.object";
public static final String ACCEPT_LANGUAGE = "org.apache.chemistry.opencmis.binding.acceptLanguage";
public static final String FORCE_CMIS_VERSION = "org.apache.chemistry.opencmis.cmisversion";
/**
* Private constructor.
*/
private CmisBindingsHelper() {
}
/**
* Gets the SPI object for the given session. If there is already a SPI
* object in the session it will be returned. If there is no SPI object it
* will be created and put into the session.
*
* @param session
* the session object
*
* @return the SPI object
*/
public static CmisSpi getSPI(BindingSession session) {
assert session != null;
// fetch from session
CmisSpi spi = (CmisSpi) session.get(SPI_OBJECT);
if (spi != null) {
return spi;
}
session.writeLock();
try {
// try again
spi = (CmisSpi) session.get(SPI_OBJECT);
if (spi != null) {
return spi;
}
// ok, we have to create it...
try {
String spiName = (String) session.get(SessionParameter.BINDING_SPI_CLASS);
Constructor<?> c = ClassLoaderUtil.loadClass(spiName).getConstructor(BindingSession.class);
spi = (CmisSpi) c.newInstance(session);
} catch (CmisBaseException e) {
throw e;
} catch (InvocationTargetException ite) {
throw new CmisRuntimeException("SPI cannot be initialized: " + ite.getCause().getMessage(), ite);
} catch (Exception e) {
throw new CmisRuntimeException("SPI cannot be initialized: " + e.getMessage(), e);
}
// we have a SPI object -> put it into the session
session.put(SPI_OBJECT, spi, true);
} finally {
session.writeUnlock();
}
assert spi != null;
return spi;
}
/**
* Gets the HTTP Invoker object from the session.
*/
public static HttpInvoker getHttpInvoker(BindingSession session) {
assert session != null;
HttpInvoker invoker = (HttpInvoker) session.get(HTTP_INVOKER_OBJECT);
if (invoker != null) {
return invoker;
}
session.writeLock();
try {
// try again
invoker = (HttpInvoker) session.get(HTTP_INVOKER_OBJECT);
if (invoker != null) {
return invoker;
}
// ok, we have to create it...
try {
String invokerName = (String) session.get(SessionParameter.HTTP_INVOKER_CLASS);
invoker = (HttpInvoker) ClassLoaderUtil.loadClass(invokerName).newInstance();
} catch (CmisBaseException e) {
throw e;
} catch (Exception e) {
throw new CmisRuntimeException("HTTP invoker cannot be initialized: " + e.getMessage(), e);
}
// we have an Invoker object -> put it into the session
session.put(HTTP_INVOKER_OBJECT, invoker, true);
} finally {
session.writeUnlock();
}
assert invoker != null;
return invoker;
}
/**
* Returns a CMIS version if the user set one, <code>null</code> otherwise.
*/
public static CmisVersion getForcedCmisVersion(BindingSession session) {
assert session != null;
return (CmisVersion) session.get(FORCE_CMIS_VERSION);
}
/**
* Returns the authentication provider from the session or <code>null</code>
* if no authentication provider is set.
*/
public static AuthenticationProvider getAuthenticationProvider(BindingSession session) {
assert session != null;
return (AuthenticationProvider) session.get(AUTHENTICATION_PROVIDER_OBJECT);
}
/**
* Returns the repository info cache from the session.
*/
public static RepositoryInfoCache getRepositoryInfoCache(BindingSession session) {
assert session != null;
return (RepositoryInfoCache) session.get(REPOSITORY_INFO_CACHE);
}
/**
* Returns the type definition cache from the session.
*/
public static TypeDefinitionCache getTypeDefinitionCache(BindingSession session) {
assert session != null;
TypeDefinitionCache cache = (TypeDefinitionCache) session.get(TYPE_DEFINTION_CACHE);
if (cache != null) {
return cache;
}
session.writeLock();
try {
// try again
cache = (TypeDefinitionCache) session.get(TYPE_DEFINTION_CACHE);
if (cache != null) {
return cache;
}
// ok, we have to create it...
try {
String cacheName = (String) session.get(SessionParameter.TYPE_DEFINITION_CACHE_CLASS);
cache = (TypeDefinitionCache) ClassLoaderUtil.loadClass(cacheName).newInstance();
cache.initialize(session);
} catch (CmisBaseException e) {
throw e;
} catch (Exception e) {
throw new CmisRuntimeException("Type definition cache cannot be initialized: " + e.getMessage(), e);
}
// we have a cache object -> put it into the session
session.put(TYPE_DEFINTION_CACHE, cache);
} finally {
session.writeUnlock();
}
assert cache != null;
return cache;
}
}