/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at
* docs/licenses/cddl.txt
* or http://www.opensource.org/licenses/cddl1.php.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at
* docs/licenses/cddl.txt. If applicable,
* add the following below this CDDL HEADER, with the fields enclosed
* by brackets "[]" replaced with your own identifying information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2013-2016 UnboundID Corp.
*/
package com.unboundid.directory.sdk.examples;
import com.fasterxml.jackson.databind.MappingIterator;
import com.fasterxml.jackson.databind.ObjectReader;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.unboundid.directory.sdk.broker.api.StoreAdapter;
import com.unboundid.directory.sdk.broker.config.StoreAdapterConfig;
import com.unboundid.directory.sdk.broker.types.BrokerContext;
import com.unboundid.directory.sdk.broker.types.StoreCreateRequest;
import com.unboundid.directory.sdk.broker.types.StoreDeleteRequest;
import com.unboundid.directory.sdk.broker.types.StoreSearchResultListener;
import com.unboundid.directory.sdk.broker.types.StoreRetrieveRequest;
import com.unboundid.directory.sdk.broker.types.StoreSearchRequest;
import com.unboundid.directory.sdk.broker.types.StoreUpdateRequest;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.scim2.common.GenericScimResource;
import com.unboundid.scim2.common.exceptions.ResourceNotFoundException;
import com.unboundid.scim2.common.exceptions.ScimException;
import com.unboundid.scim2.common.exceptions.ServerErrorException;
import com.unboundid.scim2.common.filters.Filter;
import com.unboundid.scim2.common.messages.PatchRequest;
import com.unboundid.scim2.common.utils.FilterEvaluator;
import com.unboundid.scim2.common.utils.JsonUtils;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.args.ArgumentException;
import com.unboundid.util.args.ArgumentParser;
import com.unboundid.util.args.FileArgument;
import java.io.BufferedInputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
/**
* This example provides an implementation of a flat-file StoreAdapter
* which stores entries in JSON format. Note that this is a simplistic
* implementation for the sake of example; production StoreAdapter
* implementations must store their data in persistent storage that is
* accessible to all Identity Broker instances.
*/
public class ExampleStoreAdapter extends StoreAdapter
{
// Handle to the ServerContext object.
private BrokerContext serverContext;
// The name of the argument that will be used to specify the path to the JSON
// file containing the entries.
private static final String ARG_NAME_JSON_FILE_PATH = "json-file-path";
// Handle to the JSON file containing the entries.
private File jsonFile;
// An in-memory map of SCIM resources based on their ID attribute.
private final ConcurrentHashMap<String, GenericScimResource> resources =
new ConcurrentHashMap<String, GenericScimResource>();
/**
* {@inheritDoc}
*/
@Override
public String getExtensionName()
{
return "Example Store Adapter";
}
/**
* {@inheritDoc}
*/
@Override
public String[] getExtensionDescription()
{
return new String[]
{
"This example provides an implementation of a flat-file StoreAdapter " +
"which stores entries in JSON format. Note that this is a simplistic " +
"implementation for the sake of example; production StoreAdapter " +
"implementations must store their data in persistent storage that is " +
"accessible to all Data Broker instances."
};
}
/**
* {@inheritDoc}
*/
@Override
public void defineConfigArguments(final ArgumentParser parser)
throws ArgumentException
{
final String description =
"The path to the JSON file containing the entries.";
final List<File> defaultValues = new ArrayList<File>(1);
defaultValues.add(new File("resource/entry-database.json"));
final FileArgument jsonFileArg = new FileArgument(null,
ARG_NAME_JSON_FILE_PATH, true, 1, "{file-path}", description,
false, true, true, false, defaultValues);
parser.addArgument(jsonFileArg);
}
/**
* Initializes this store adapter. Any initialization should be performed
* here. This method should generally store the
* {@link BrokerContext} in
* a class member so that it can be used elsewhere in the implementation.
*
* @param serverContext A handle to the server context for the server in
* which this extension is running. Extensions should
* typically store this in a class member.
* @param config The general configuration for this object.
* @param parser The argument parser which has been initialized from
* the configuration for this store adapter.
* @throws LDAPException If a problem occurs while initializing this store
* adapter.
*/
@Override
public void initializeStoreAdapter(final BrokerContext serverContext,
final StoreAdapterConfig config,
final ArgumentParser parser)
throws LDAPException
{
this.serverContext = serverContext;
final FileArgument jsonFileArg =
(FileArgument) parser.getNamedArgument(ARG_NAME_JSON_FILE_PATH);
jsonFile = jsonFileArg.getValue();
if (!jsonFile.isAbsolute())
{
jsonFile = new File(serverContext.getServerRoot(), jsonFile.getPath());
}
// Preload the entries from the file if it already exists.
if (jsonFile.length() > 0)
{
BufferedInputStream inputStream = null;
try
{
inputStream = new BufferedInputStream(new FileInputStream(jsonFile));
final MappingIterator<GenericScimResource> nodes =
JsonUtils.getObjectReader().readValues(inputStream);
// Populate the resources map.
for (GenericScimResource r : nodes.readAll())
{
resources.put(r.getId(), r);
}
}
catch(Exception e)
{
serverContext.debugCaught(e);
throw new LDAPException(ResultCode.LOCAL_ERROR, e);
}
finally
{
safeCloseStream(inputStream);
}
}
else // Otherwise, create the file.
{
try
{
jsonFile.createNewFile();
}
catch (IOException ioe)
{
serverContext.debugCaught(ioe);
throw new LDAPException(ResultCode.LOCAL_ERROR, ioe);
}
}
}
/**
* Determines whether this Store Adapter is currently available and
* in-service. This method may return {@code false} in the case that the
* JSON file is not accessible; during this time the SCIMResourceType will
* return an appropriate 503 response code to clients.
*
* @return {@code true} if this Store Adapter is initialized and connected;
* {@code false} otherwise.
*/
@Override
public boolean isAvailable()
{
return jsonFile != null && jsonFile.canWrite();
}
/**
* Fetches the entries that match the specified criteria.
*
* @param request The search request.
* @throws ScimException if there is a problem fulfilling the search request.
*/
@Override
public void search(final StoreSearchRequest request)
throws ScimException
{
final Filter filter = Filter.fromString(request.getSCIMFilter());
final StoreSearchResultListener listener =
request.getStoreSearchResultListener();
int resultCount = 0;
for (GenericScimResource r : resources.values())
{
if (filter == null ||
FilterEvaluator.evaluate(filter, r.getObjectNode()))
{
listener.searchResultReturned(r.toString());
resultCount++;
if (request.getSizeLimit() > 0 && resultCount >= request.getSizeLimit())
{
break;
}
}
}
}
/**
* Fetches the specified entry.
*
* @param request The retrieve request.
* @return The retrieved entry.
* @throws ScimException if there is a problem fulfilling the request.
*/
@Override
public String retrieve(final StoreRetrieveRequest request)
throws ScimException
{
final Filter filter = Filter.fromString(request.getSCIMFilter());
final GenericScimResource r = retrieve(filter);
return r.toString();
}
/**
* Create the specified entry in the JSON file.
*
* @param request The create request.
* @return The entry that was just created;
* @throws ScimException if there is a problem creating the entry.
*/
@Override
public String create(final StoreCreateRequest request)
throws ScimException
{
// All write operations are synchronized to prevent concurrent modifications
// to the JSON file.
synchronized(this)
{
try
{
final GenericScimResource resourceToCreate =
new GenericScimResource(toObjectNode(request.getObjectToCreate()));
// Populate the ID attribute.
resourceToCreate.setId(UUID.randomUUID().toString());
resources.put(resourceToCreate.getId(), resourceToCreate);
// Write the new set of resources to the JSON file.
writeResources();
return resourceToCreate.toString();
}
catch (Exception e)
{
serverContext.debugCaught(e);
throw new ServerErrorException(StaticUtils.getExceptionMessage(e));
}
}
}
/**
* Update the specified entry in the JSON file.
*
* @param request The update request.
* @return The updated entry.
* @throws ScimException if there is a problem modifying the entry.
*/
@Override
public String update(final StoreUpdateRequest request)
throws ScimException
{
final Filter filter = Filter.fromString(request.getSCIMFilter());
final GenericScimResource resourceToUpdate = retrieve(filter);
// All write operations are synchronized to prevent concurrent modifications
// to the JSON file.
synchronized(this)
{
try
{
final ObjectReader reader =
JsonUtils.getObjectReader().forType(PatchRequest.class);
final PatchRequest patchOp =
reader.readValue(request.getPatchRequest());
patchOp.apply(resourceToUpdate);
// Write the updated set of resources to the JSON file.
writeResources();
return resourceToUpdate.toString();
}
catch(Exception e)
{
serverContext.debugCaught(e);
throw new ServerErrorException(StaticUtils.getExceptionMessage(e));
}
}
}
/**
* Delete the specified entry from the JSON file.
*
* @param request The delete request.
* @throws ScimException if there is a problem deleting the entry.
*/
@Override
public void delete(final StoreDeleteRequest request) throws ScimException
{
final Filter filter = Filter.fromString(request.getSCIMFilter());
final GenericScimResource resourceToDelete =
retrieve(filter);
// All write operations are synchronized to prevent concurrent modifications
// to the JSON file.
synchronized(this)
{
try
{
resources.remove(resourceToDelete.getId());
// Write the updated set of resources to the JSON file.
writeResources();
}
catch(Exception e)
{
serverContext.debugCaught(e);
throw new ServerErrorException(StaticUtils.getExceptionMessage(e));
}
}
}
/**
* Closes a stream quietly.
*
* @param stream to close
*/
private void safeCloseStream(final Closeable stream)
{
if (stream != null)
{
try
{
stream.close();
}
catch (final IOException ioe)
{
// Ignore.
}
}
}
/**
* Retrieves a resource identified by a SCIM filter.
*
* @param filter The SCIM filter identifying a resource to retrieve.
* @return The requested resource.
* @throws ScimException If the resource was not found.
*/
private GenericScimResource retrieve(final Filter filter)
throws ScimException
{
for (GenericScimResource r : resources.values())
{
if (FilterEvaluator.evaluate(filter, r.getObjectNode()))
{
return r;
}
}
throw new ResourceNotFoundException(String.format(
"No resource found matching filter '%s'", filter.toString()));
}
/**
* Writes the current resources to the JSON file.
* @throws IOException if the resources could not be written.
*/
private void writeResources()
throws IOException
{
final File file = this.jsonFile;
final File tempFile = new File(file.getAbsolutePath() + ".new");
final File oldFile = new File(file.getAbsolutePath() + ".old");
final OutputStream outputStream = new FileOutputStream(tempFile);
try
{
final ObjectWriter writer = JsonUtils.getObjectWriter();
for (GenericScimResource r : resources.values())
{
writer.writeValue(outputStream, r);
}
}
finally
{
safeCloseStream(outputStream);
}
if (oldFile.exists())
{
oldFile.delete();
}
if (file.exists())
{
file.renameTo(oldFile);
}
tempFile.renameTo(file);
}
/**
* Parse a JSON object in string form into an ObjectNode.
*
* @param jsonString The string containing a JSON object.
* @return The parsed ObjectNode.
* @throws IOException if the object could not be parsed.
*/
private ObjectNode toObjectNode(final String jsonString)
throws IOException
{
return (ObjectNode)JsonUtils.getObjectReader().readTree(jsonString);
}
}
|
