Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.chemistry.opencmis.tools.main.ObjGenApp Maven / Gradle / Ivy
/*
* 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.tools.main;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import joptsimple.OptionParser;
import joptsimple.OptionSet;
import joptsimple.OptionSpec;
import org.apache.chemistry.opencmis.client.bindings.CmisBindingFactory;
import org.apache.chemistry.opencmis.commons.SessionParameter;
import org.apache.chemistry.opencmis.commons.data.ContentStream;
import org.apache.chemistry.opencmis.commons.data.RepositoryInfo;
import org.apache.chemistry.opencmis.commons.enums.BaseTypeId;
import org.apache.chemistry.opencmis.commons.enums.BindingType;
import org.apache.chemistry.opencmis.commons.exceptions.CmisBaseException;
import org.apache.chemistry.opencmis.commons.impl.IOUtils;
import org.apache.chemistry.opencmis.commons.spi.CmisBinding;
import org.apache.chemistry.opencmis.commons.spi.RepositoryService;
import org.apache.chemistry.opencmis.tools.filecopy.FileCopier;
import org.apache.chemistry.opencmis.util.repository.MultiThreadedObjectGenerator;
import org.apache.chemistry.opencmis.util.repository.ObjectGenerator;
import org.apache.chemistry.opencmis.util.repository.ObjectGenerator.ContentKind;
import org.apache.chemistry.opencmis.util.repository.TimeLogger;
public class ObjGenApp {
private static final int BUFSIZE = 64 * 1024;
private static final String PROP_USER = SessionParameter.USER;
private static final String PROP_PASSWORD = SessionParameter.PASSWORD;
private static final String DEFAULT_USER = "user";
private static final String DEFAULT_PASSWORD = "dummy";
private static final String PROP_ATOMPUB_URL = SessionParameter.ATOMPUB_URL;
private static final String PROP_WS_URL = "org.apache.chemistry.opencmis.binding.webservices.url";
private static final String PROP_BROWSER_URL = SessionParameter.BROWSER_URL;
private static final String PROP_BINDING = SessionParameter.BINDING_TYPE;
private static final String PROP_CUSTOM = "org.apache.chemistry.opencmis.binding.header.";
private static final String DEFAULT_ATOMPUB_URL = "http://localhost:8080/inmemory/atom";
private static final String DEFAULT_WS_URL = "http://localhost:8080/inmemory/services/";
private static final String DEFAULT_BROWSER_BINDING_URL = "http://localhost:8080/inmemory/browser/";
private static final String DEFAULT_BINDING = "atompub";
private static final String CMD = "Command";
private static final String REPOSITORY_ID = "RepositoryId";
private static final String FILLER_DOCUMENT_TYPE_ID = "DocumentTypeId";
private static final String FILLER_FOLDER_TYPE_ID = "FolderTypeId";
private static final String FILLER_DOCS_PER_FOLDER = "DocsPerFolder";
private static final String FILLER_FOLDERS_PER_FOLDER = "FoldersPerFolder";
private static final String FILLER_DEPTH = "Depth";
private static final String FILLER_CONTENT_SIZE = "ContentSizeInKB";
private static final String COUNT = "Count";
private static final String CLEANUP = "Cleanup";
private static final String ROOTFOLDER = "RootFolder";
private static final String THREADS = "Threads";
private static final String CONTENT_KIND = "ContentKind";
private static final String FILE_NAME_PATTERN = "FileName";
private static final String LOCAL_FILE = "File";
private static final String LOCAL_DIR = "Dir";
private static final String BINDING_ATOM = "atompub";
private static final String BINDING_WS = "webservices";
private static final String BINDING_BROWSER = "browser";
private BindingType bindingType;
private ContentKind contentKind;
private CmisBinding binding;
private String cmd;
private Integer depth;
private Integer contentSize;
private Integer folderPerFolder;
private Integer docsPerFolder;
private String folderType;
private String docType;
private String repositoryId;
private Integer count;
private Boolean cleanup;
private String rootFolder;
private Integer threads;
private String contentKindStr;
private String fileNamePattern;
private String localDir;
private String localFile;
public static void main(String[] args) {
ObjGenApp app = new ObjGenApp();
try {
app.processCmdLine(args);
} catch (CmisBaseException ce) {
System.out.println("Error: Could not process command. " + ce);
System.out.println("Extended error: " + ce.getErrorContent());
ce.printStackTrace();
} catch (Exception e) {
System.out.println("Could not fill repository " + e);
e.printStackTrace();
}
}
private void processCmdLine(String[] args) {
OptionSpec optCmd;
OptionSpec optDepth;
OptionSpec optContentSize;
OptionSpec optFolderPerFolder;
OptionSpec optDocsPerFolder;
OptionSpec optFolderType;
OptionSpec optDocType;
OptionSpec optRepoId;
OptionSpec optCount;
OptionSpec optCleanup;
OptionSpec optRootFolder;
OptionSpec optThreads;
OptionSpec optContentKindStr;
OptionSpec optFileNamePattern;
OptionSpec optLocalDir;
OptionSpec optLocalFile;
OptionParser parser = new OptionParser();
optCmd = parser.accepts(CMD).withRequiredArg().describedAs("Command to perform (see below)");
optRepoId = parser.accepts(REPOSITORY_ID).withOptionalArg().describedAs("Repository used");
optDocType = parser.accepts(FILLER_DOCUMENT_TYPE_ID).withOptionalArg()
.defaultsTo(BaseTypeId.CMIS_DOCUMENT.value()).describedAs("Document type created");
optFolderType = parser.accepts(FILLER_FOLDER_TYPE_ID).withOptionalArg()
.defaultsTo(BaseTypeId.CMIS_FOLDER.value()).describedAs("Folder type created");
optDocsPerFolder = parser.accepts(FILLER_DOCS_PER_FOLDER).withOptionalArg().ofType(Integer.class)
.describedAs("Documents on each level").defaultsTo(1);
optFolderPerFolder = parser.accepts(FILLER_FOLDERS_PER_FOLDER).withOptionalArg().ofType(Integer.class)
.describedAs(" Folders on each level").defaultsTo(0);
optDepth = parser.accepts(FILLER_DEPTH).withOptionalArg().ofType(Integer.class).describedAs("Levels of folders")
.defaultsTo(1);
optContentSize = parser.accepts(FILLER_CONTENT_SIZE).withOptionalArg().ofType(Integer.class)
.describedAs("Content size of each doc").defaultsTo(0);
optCount = parser.accepts(COUNT).withOptionalArg().ofType(Integer.class).defaultsTo(1)
.describedAs("Repeat a command n times (partially implemented)");
optCleanup = parser.accepts(CLEANUP).withOptionalArg().ofType(Boolean.class).defaultsTo(false)
.describedAs("Clean all created objects at the end");
optRootFolder = parser.accepts(ROOTFOLDER).withOptionalArg().ofType(String.class)
.describedAs("folder id used as root to create objects (default repository root folder)");
optThreads = parser.accepts(THREADS).withOptionalArg().ofType(Integer.class).defaultsTo(1)
.describedAs("Number of threads to start in parallel");
optContentKindStr = parser.accepts(CONTENT_KIND).withOptionalArg().ofType(String.class).defaultsTo("lorem/text")
.describedAs("kind of content: static/text, lorem/text, lorem/html, fractal/jpeg");
optFileNamePattern = parser.accepts(FILE_NAME_PATTERN).withOptionalArg().ofType(String.class)
.defaultsTo("ContentData-%03d.bin").describedAs("file name pattern to be used with CreateFiles action");
optLocalDir = parser.accepts(LOCAL_DIR).withOptionalArg().ofType(String.class).defaultsTo(".")
.describedAs("name of a directory to be recursively copied to the repository");
optLocalFile = parser.accepts(LOCAL_FILE).withOptionalArg().ofType(String.class)
.describedAs("file name of a file to be copied to the repository");
OptionSet options = parser.parse(args);
if (cmd == null || options.has("?")) {
usage(parser);
}
String bindingStr = getBindingProperty();
if (bindingStr.equals(BINDING_WS)) {
bindingType = BindingType.WEBSERVICES;
} else if (bindingStr.equals(BINDING_ATOM)) {
bindingType = BindingType.ATOMPUB;
} else if (bindingStr.equals(BINDING_BROWSER)) {
bindingType = BindingType.BROWSER;
} else {
System.out.println("Error: Unknown binding: " + bindingStr + " allowed values: " + BINDING_WS + " or "
+ BINDING_ATOM + " or " + BINDING_BROWSER);
return;
}
String kind = options.valueOf(optContentKindStr);
if (null == kind) {
if (options.valueOf(optContentSize) > 0) {
contentKind = ObjectGenerator.ContentKind.STATIC_TEXT;
} else {
contentKind = null;
}
} else if (kind.equals("static/text")) {
contentKind = ObjectGenerator.ContentKind.STATIC_TEXT;
} else if (kind.equals("lorem/text")) {
contentKind = ObjectGenerator.ContentKind.LOREM_IPSUM_TEXT;
} else if (kind.equals("lorem/html")) {
contentKind = ObjectGenerator.ContentKind.LOREM_IPSUM_HTML;
} else if (kind.equals("fractal/jpeg")) {
contentKind = ObjectGenerator.ContentKind.IMAGE_FRACTAL_JPEG;
} else {
System.out.println("Unknown content kind: " + options.valueOf(optContentKindStr));
System.out.println(" must be one of static/text, lorem/text, lorem/html, fractal/jpeg");
usage(parser);
}
repositoryId = options.valueOf(optRepoId);
cmd = options.valueOf(optCmd);
depth = options.valueOf(optDepth);
contentSize = options.valueOf(optContentSize);
folderPerFolder = options.valueOf(optFolderPerFolder);
docsPerFolder = options.valueOf(optDocsPerFolder);
folderType = options.valueOf(optFolderType);
docType = options.valueOf(optDocType);
count = options.valueOf(optCount);
cleanup = options.valueOf(optCleanup);
rootFolder = options.valueOf(optRootFolder);
threads = options.valueOf(optThreads);
contentKindStr = options.valueOf(optContentKindStr);
fileNamePattern = options.valueOf(optFileNamePattern);
localDir = options.valueOf(optLocalDir);
localFile = options.valueOf(optLocalFile);
initClientBindings();
if (null == cmd) {
System.out.println("No command given.");
usage(parser);
} else if (cmd.equals("FillRepository")) {
fillRepository(options);
} else if (cmd.equals("CreateDocument")) {
createSingleDocument(options);
} else if (cmd.equals("CreateFolder")) {
createFolders(options);
} else if (cmd.equals("RepositoryInfo")) {
repositoryInfo(options);
} else if (cmd.equals("CreateFiles")) {
createFiles(options);
} else if (cmd.equals("CopyFiles")) {
transferFiles(options);
} else if (cmd.equals("CopyFilesTest")) { // undocumented
transferFilesTest(options);
} else {
System.out.println("Unknown cmd: " + cmd);
usage(parser);
}
}
private static void usage(OptionParser parser) {
try {
System.out.println();
System.out.println("ObjGenApp is a command line tool for testing a CMIS repository.");
System.out.println("Usage:");
parser.printHelpOn(System.out);
System.out.println();
System.out
.println("Command is one of [CreateDocument, CreateFolder, FillRepository, RepositoryInfo, CreateFiles, "
+ "CopyFiles, CopyFilesTest]");
System.out.println("JVM system properties: " + PROP_ATOMPUB_URL + ", " + PROP_WS_URL + ", "
+ PROP_BROWSER_URL);
System.out.println(" " + PROP_USER + ", " + PROP_PASSWORD);
System.out.println();
System.out.println("Example: ");
System.out
.println("java -D"
+ PROP_ATOMPUB_URL
+ "=http://localhost:8080/inmemory/atom -cp ... "
+ "org.apache.chemistry.opencmis.util.repository.ObjGenApp --Binding=AtomPub --Command=CreateDocument "
+ "--RepositoryId=A1 --ContentSizeInKB=25 --ContentKind=lorem/text");
return;
} catch (IOException e) {
e.printStackTrace();
}
}
private void fillRepository(String repoId, int docsPerFolder, int foldersPerFolders, int depth,
String documentType, String folderType, int contentSizeInKB, String rootFolderId, boolean doCleanup) {
MultiThreadedObjectGenerator.ObjectGeneratorRunner runner = MultiThreadedObjectGenerator.prepareForCreateTree(
binding, repoId, docsPerFolder, foldersPerFolders, depth, documentType, folderType, contentSizeInKB,
rootFolderId, contentKind, doCleanup);
ObjectGenerator gen = runner.getObjectGenerator();
runner.doCreateTree();
System.out.println();
System.out.println("Result:");
System.out.println("Filling repository succeeded.");
System.out.println("Folder used as root for creation (null=rootFolderId): " + rootFolderId);
System.out.println("Number of documents created: " + gen.getDocumentsInTotal());
System.out.println("Number of folders created: " + gen.getFoldersInTotal());
gen.printTimings();
}
private void fillRepositoryMT(int noThreads, String repoId, int docsPerFolder, int foldersPerFolders, int depth,
String documentType, String folderType, int contentSizeInKB, String rootFolderId, boolean doCleanup) {
// Step 1: create a root folder for each thread
MultiThreadedObjectGenerator.ObjectGeneratorRunner runner = MultiThreadedObjectGenerator
.prepareForCreateFolder(binding, repoId, folderType, rootFolderId, noThreads, doCleanup);
String[] folderIds = runner.doCreateFolder();
// Step 2: fill each root folder with an object tree
MultiThreadedObjectGenerator.ObjectGeneratorRunner[] runners = MultiThreadedObjectGenerator
.prepareForCreateTreeMT(binding, repoId, docsPerFolder, foldersPerFolders, depth, documentType,
folderType, contentSizeInKB, folderIds, contentKind, doCleanup);
MultiThreadedObjectGenerator.runMultiThreaded(runners);
System.out.println("Filling repository succeeded.");
}
private void printParameters(OptionSet options) {
if (bindingType == BindingType.ATOMPUB) {
System.out.println("Using AtomPub, connecting to " + getAtomPubUrl());
} else if (bindingType == BindingType.WEBSERVICES) {
System.out.println("Using WebService, connecting to " + getWsUrl());
} else if (bindingType == BindingType.BROWSER) {
System.out.println("Using Browser binding, connecting to " + getBrowserUrl());
} else {
System.out.println("Unknown binding type.");
}
System.out.println("Repository id is: " + repositoryId);
System.out.println("Content size: " + contentSize);
System.out.println("Document Type: " + docType);
System.out.println("Folder id used as root: " + rootFolder);
System.out.println("Delete all objects after creation: " + cleanup);
System.out.println("Number of actions to perform: " + count);
System.out.println("Number of threads to start: " + threads);
System.out.println("Kind of created content: " + contentKindStr);
}
private void createSingleDocument(OptionSet options) {
System.out.println();
System.out.println("Creating document with parameters:");
printParameters(options);
int noThreads = threads;
if (noThreads <= 1) {
createSingleDocument(repositoryId, docType, contentSize,
rootFolder, count, cleanup);
} else {
createSingleDocumentMT(noThreads, repositoryId, docType,
contentSize, rootFolder, count,
cleanup);
}
}
private void fillRepository(OptionSet options) {
System.out.println();
printParameters(options);
System.out.println("Creating object tree with folowing parameters: ");
System.out.println("Documents per folder: " + docsPerFolder);
System.out.println("Folder per folder: " + folderPerFolder);
System.out.println("Depth: " + depth);
System.out.println("Folder Type: " + folderType);
int noThreads = threads;
if (noThreads <= 1) {
fillRepository(repositoryId, docsPerFolder,
folderPerFolder, depth, docType,
folderType, contentSize, rootFolder,
cleanup);
} else {
fillRepositoryMT(noThreads, repositoryId, docsPerFolder,
folderPerFolder, depth, docType,
folderType, contentSize, rootFolder,
cleanup);
}
}
private void createFolders(OptionSet options) {
System.out.println();
System.out.println("Creating folder with parameters:");
printParameters(options);
System.out.println("Folder Type: " + folderType);
int noThreads = threads;
if (noThreads <= 1) {
createFolders(repositoryId, folderType, rootFolder,
count, cleanup);
} else {
createFoldersMT(noThreads, repositoryId, folderType,
rootFolder, count, cleanup);
}
}
private void createSingleDocument(String repoId, String documentType, int contentSizeInKB, String rootFolderId,
int docCount, boolean doCleanup) {
MultiThreadedObjectGenerator.ObjectGeneratorRunner runner = MultiThreadedObjectGenerator
.prepareForCreateDocument(binding, repoId, documentType, contentSizeInKB, rootFolderId, docCount,
contentKind, doCleanup);
ObjectGenerator gen = runner.getObjectGenerator();
String[] ids = runner.doCreateDocument();
System.out.println();
System.out.println("Result:");
System.out.println("Document creation succeeded.");
System.out.println("Folder used as root for creation: " + rootFolderId);
System.out.println("Ids of created documents: ");
if (null == ids) {
System.out.println("");
} else {
for (int i = 0; i < ids.length; i++) {
System.out.println(ids[i]);
}
}
gen.printTimings();
gen.resetCounters();
}
private void createSingleDocumentMT(int noThreads, String repoId, String documentType, int contentSizeInKB,
String rootFolderId, int docCount, boolean doCleanup) {
MultiThreadedObjectGenerator.ObjectGeneratorRunner[] runners = MultiThreadedObjectGenerator
.prepareForCreateDocumentMT(noThreads, binding, repoId, documentType, contentSizeInKB, rootFolderId,
docCount, contentKind, doCleanup);
MultiThreadedObjectGenerator.runMultiThreaded(runners);
System.out.println("Document creation succeeded. All threads terminated.");
}
private void createFolders(String repoId, String folderType, String rootFolderId, int noFolders, boolean doCleanup) {
MultiThreadedObjectGenerator.ObjectGeneratorRunner runner = MultiThreadedObjectGenerator
.prepareForCreateFolder(binding, repoId, folderType, rootFolderId, noFolders, doCleanup);
ObjectGenerator gen = runner.getObjectGenerator();
String[] ids = runner.doCreateFolder();
System.out.println();
System.out.println("Result:");
System.out.println("Folder creation succeeded.");
System.out.println("Ids of created folders: ");
if (null == ids) {
System.out.println("");
} else {
for (int i = 0; i < ids.length; i++) {
System.out.println(ids[i]);
}
}
gen.printTimings();
gen.resetCounters();
}
private void createFoldersMT(int noThreads, String repoId, String folderType, String rootFolderId, int noFolders,
boolean doCleanup) {
MultiThreadedObjectGenerator.ObjectGeneratorRunner[] runners = MultiThreadedObjectGenerator
.prepareForCreateFolderMT(noThreads, binding, repoId, folderType, rootFolderId, noFolders, doCleanup);
MultiThreadedObjectGenerator.runMultiThreaded(runners);
System.out.println("Folder creation succeeded.");
}
private void callRepoInfo(String repositoryId, int count) {
RepositoryService repSvc = binding.getRepositoryService();
TimeLogger timeLogger = new TimeLogger("RepoInfoTest");
RepositoryInfo repoInfo = null;
for (int i = 0; i < count; i++) {
binding.clearRepositoryCache(repositoryId);
timeLogger.start();
repoInfo = repSvc.getRepositoryInfo(repositoryId, null);
timeLogger.stop();
}
System.out.println("Root Folder id is: " + (repoInfo == null ? "" : repoInfo.getRootFolderId()));
timeLogger.printTimes();
}
private void repositoryInfo(OptionSet options) {
callRepoInfo(repositoryId, count);
}
private void createFiles(OptionSet options) {
ContentStream contentStream = null;
System.out.println("Creating local files with content: ");
System.out.println("Kind: " + docsPerFolder);
System.out.println("Number of files: " + count);
System.out.println("File name pattern: " + fileNamePattern);
System.out.println("Kind of content: " + contentKindStr);
System.out.println("Size of content (text only): " + contentSize);
ObjectGenerator objGen = new ObjectGenerator(null, null, null, null, null, contentKind);
objGen.setContentSizeInKB(contentSize);
InputStream is = null;
FileOutputStream os = null;
try {
for (int i = 0; i < count; i++) {
String fileName = String.format(fileNamePattern, i);
System.out.println("Generating file: " + fileName);
if (contentSize > 0) {
switch (contentKind) {
case STATIC_TEXT:
contentStream = objGen.createContentStaticText();
break;
case LOREM_IPSUM_TEXT:
contentStream = objGen.createContentLoremIpsumText();
break;
case LOREM_IPSUM_HTML:
contentStream = objGen.createContentLoremIpsumHtml();
break;
case IMAGE_FRACTAL_JPEG:
contentStream = objGen.createContentFractalimageJpeg();
break;
}
}
// write to a file:
is = contentStream.getStream();
os = new FileOutputStream(fileName);
IOUtils.copy(is, os, BUFSIZE);
is.close();
is = null;
os.close();
os = null;
}
} catch (Exception e) {
System.err.println("Error generating file: " + e);
e.printStackTrace();
} finally {
IOUtils.closeQuietly(is);
IOUtils.closeQuietly(os);
}
}
private void transferFiles(OptionSet options) {
String fileName = localFile;
String dirName = localDir;
String folderId = rootFolder;
String name = fileName;
if ((null == fileName || fileName.length() == 0) && (null == dirName || dirName.length() == 0)) {
System.out.println("Error: You either have to provide a --file or a --dir option to copy file(s).");
return;
}
// if no file name is provided there must be a directory
if (null == name || name.length() == 0) {
name = dirName;
}
System.out.println("Copying files to a repository: ");
System.out.println("Repository id is: " + (repositoryId == null ? "not set!" : repositoryId));
System.out.println("Folder id used as root: " + rootFolder);
Map parameters = getConnectionParameters(getBindingProperty(), repositoryId);
FileCopier fc = new FileCopier();
fc.connect(parameters);
fc.copyRecursive(name, folderId);
}
private void transferFilesTest(OptionSet options) {
String fileName = localFile;
if ((null == fileName || fileName.length() == 0)) {
System.out.println("Error: You have to provide a --file option to test metadata extraction.");
return;
}
System.out.println("Testing metadata extraction: ");
FileCopier fc = new FileCopier();
fc.listMetadata(fileName);
}
private Map getConnectionParameters(String binding, String repoId) {
Map parameters = new HashMap();
parameters.put(SessionParameter.REPOSITORY_ID, repoId);
parameters.put(SessionParameter.BINDING_TYPE, binding);
if (binding.equals(BindingType.ATOMPUB.value())) {
parameters.put(SessionParameter.ATOMPUB_URL, getAtomPubUrl());
filLoginParams(parameters, getUser(), getPassword());
} else if (binding.equals(BindingType.WEBSERVICES.value())) {
fillWSParameters(parameters, getWsUrl(), isPrefix(getWsUrl()), getUser(), getPassword());
} else if (binding.equals(BindingType.BROWSER.value())) {
parameters.put(SessionParameter.BROWSER_URL, getBrowserUrl());
filLoginParams(parameters, getUser(), getPassword());
} else {
System.out.println("Error unknown binding: " + binding);
}
fillCustomHeaders(parameters);
return parameters;
}
private void initClientBindings() {
if (binding == null) {
if (bindingType == BindingType.ATOMPUB) {
binding = createAtomBinding(getAtomPubUrl(), getUser(), getPassword());
}
if (bindingType == BindingType.WEBSERVICES) {
String url = getWsUrl();
binding = createWSBinding(url, isPrefix(url), getUser(), getPassword());
} else if (bindingType == BindingType.BROWSER) {
binding = createBrowserBinding(getBrowserUrl(), getUser(), getPassword());
}
RepositoryInfo repoInfo = binding.getRepositoryService().getRepositoryInfo(null, null);
if (null == repositoryId) {
repositoryId = repoInfo.getId();
}
}
}
private static void filLoginParams(Map parameters, String user, String password) {
if (user != null && user.length() > 0) {
parameters.put(SessionParameter.USER, user);
}
if (user != null && user.length() > 0) {
parameters.put(SessionParameter.PASSWORD, password);
}
}
private static void fillCustomHeaders(Map parameters) {
Map customHeaders = getCustomHeaders();
for (Map.Entry entry : customHeaders.entrySet()) {
parameters.put(entry.getKey(), entry.getValue());
}
}
private static CmisBinding createAtomBinding(String url, String user, String password) {
// gather parameters
Map parameters = new HashMap();
filLoginParams(parameters, user, password);
fillCustomHeaders(parameters);
// get factory and create binding
CmisBindingFactory factory = CmisBindingFactory.newInstance();
parameters.put(SessionParameter.ATOMPUB_URL, url);
CmisBinding binding = factory.createCmisAtomPubBinding(parameters);
return binding;
}
private static CmisBinding createBrowserBinding(String url, String user, String password) {
// gather parameters
Map parameters = new HashMap();
filLoginParams(parameters, user, password);
fillCustomHeaders(parameters);
// get factory and create binding
CmisBindingFactory factory = CmisBindingFactory.newInstance();
parameters.put(SessionParameter.BROWSER_URL, url);
CmisBinding binding = factory.createCmisBrowserBinding(parameters);
return binding;
}
private static boolean isPrefix(String url) {
boolean isPrefix = true;
String urlLower = url.toLowerCase();
if (urlLower.endsWith("?wsdl")) {
isPrefix = false;
} else if (urlLower.endsWith(".wsdl")) {
isPrefix = false;
} else if (urlLower.endsWith(".xml")) {
isPrefix = false;
}
return isPrefix;
}
public static CmisBinding createWSBinding(String url, boolean isPrefix, String username, String password) {
Map parameters = new HashMap();
fillWSParameters(parameters, url, isPrefix, username, password);
fillCustomHeaders(parameters);
// get factory and create provider
CmisBindingFactory factory = CmisBindingFactory.newInstance();
CmisBinding binding = factory.createCmisWebServicesBinding(parameters);
return binding;
}
public static void fillWSParameters(Map parameters, String url, boolean isPrefix, String username,
String password) {
// gather parameters
parameters.put(SessionParameter.USER, username);
parameters.put(SessionParameter.PASSWORD, password);
if (!isPrefix) {
parameters.put(SessionParameter.WEBSERVICES_REPOSITORY_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_NAVIGATION_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_OBJECT_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_VERSIONING_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_DISCOVERY_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_MULTIFILING_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_POLICY_SERVICE, url);
parameters.put(SessionParameter.WEBSERVICES_ACL_SERVICE, url);
} else {
parameters.put(SessionParameter.WEBSERVICES_REPOSITORY_SERVICE, url + "RepositoryService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_NAVIGATION_SERVICE, url + "NavigationService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_OBJECT_SERVICE, url + "ObjectService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_VERSIONING_SERVICE, url + "VersioningService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_DISCOVERY_SERVICE, url + "DiscoveryService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE, url + "RelationshipService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_MULTIFILING_SERVICE, url + "MultiFilingService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_POLICY_SERVICE, url + "PolicyService?wsdl");
parameters.put(SessionParameter.WEBSERVICES_ACL_SERVICE, url + "ACLService?wsdl");
}
}
private static String getBindingProperty() {
return System.getProperty(PROP_BINDING, DEFAULT_BINDING);
}
private static String getAtomPubUrl() {
return System.getProperty(PROP_ATOMPUB_URL, DEFAULT_ATOMPUB_URL);
}
private static String getWsUrl() {
return System.getProperty(PROP_WS_URL, DEFAULT_WS_URL);
}
private static String getBrowserUrl() {
return System.getProperty(PROP_BROWSER_URL, DEFAULT_BROWSER_BINDING_URL);
}
private static String getUser() {
return System.getProperty(PROP_USER, DEFAULT_USER);
}
private static String getPassword() {
return System.getProperty(PROP_PASSWORD, DEFAULT_PASSWORD);
}
private static Map getCustomHeaders() {
int i = 0;
Map customHeaders = new HashMap();
while (true) {
String val = System.getProperty(PROP_CUSTOM + i, null);
if (null == val) {
break;
} else {
customHeaders.put(PROP_CUSTOM + i++, val);
}
}
return customHeaders;
}
}
