CmisBindingFactory xref

This project has retired. For details please refer to its Attic page.

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   * http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.chemistry.opencmis.client.bindings;
20  
21  import java.util.HashMap;
22  import java.util.Map;
23  
24  import org.apache.chemistry.opencmis.client.bindings.impl.CmisBindingImpl;
25  import org.apache.chemistry.opencmis.commons.SessionParameter;
26  import org.apache.chemistry.opencmis.commons.spi.AuthenticationProvider;
27  import org.apache.chemistry.opencmis.commons.spi.CmisBinding;
28  
29  /**
30   * Default factory for a CMIS binding instance.
31   */
32  public class CmisBindingFactory {
33  
34      /** Default CMIS AtomPub binding SPI implementation */
35      public static final String BINDING_SPI_ATOMPUB = "org.apache.chemistry.opencmis.client.bindings.spi.atompub.CmisAtomPubSpi";
36      /** Default CMIS Web Services binding SPI implementation */
37      public static final String BINDING_SPI_WEBSERVICES = "org.apache.chemistry.opencmis.client.bindings.spi.webservices.CmisWebServicesSpi";
38      /** Default CMIS Browser binding SPI implementation */
39      public static final String BINDING_SPI_BROWSER = "org.apache.chemistry.opencmis.client.bindings.spi.browser.CmisBrowserBindingSpi";
40      /** Default CMIS local binding SPI implementation */
41      public static final String BINDING_SPI_LOCAL = "org.apache.chemistry.opencmis.client.bindings.spi.local.CmisLocalSpi";
42  
43      /** Standard authentication provider class */
44      public static final String STANDARD_AUTHENTICATION_PROVIDER = "org.apache.chemistry.opencmis.client.bindings.spi.StandardAuthenticationProvider";
45      /** NTLM authentication provider class */
46      public static final String NTLM_AUTHENTICATION_PROVIDER = "org.apache.chemistry.opencmis.client.bindings.spi.NTLMAuthenticationProvider";
47  
48      private Map<String, String> defaults;
49  
50      /**
51       * Constructor.
52       */
53      public CmisBindingFactory() {
54          defaults = createNewDefaultParameters();
55      }
56  
57      /**
58       * Creates a new factory instance.
59       */
60      public static CmisBindingFactory newInstance() {
61          return new CmisBindingFactory();
62      }
63  
64      /**
65       * Returns the default session parameters.
66       */
67      public Map<String, String> getDefaultSessionParameters() {
68          return defaults;
69      }
70  
71      /**
72       * Sets the default session parameters.
73       */
74      public void setDefaultSessionParameters(Map<String, String> sessionParameters) {
75          if (sessionParameters == null) {
76              defaults = createNewDefaultParameters();
77          } else {
78              defaults = sessionParameters;
79          }
80      }
81  
82      /**
83       * Creates a CMIS binding instance. A binding class has to be provided in
84       * the session parameters.
85       */
86      public CmisBinding createCmisBinding(Map<String, String> sessionParameters) {
87          return createCmisBinding(sessionParameters, null);
88      }
89  
90      /**
91       * Creates a CMIS binding instance. A binding class has to be provided in
92       * the session parameters.
93       */
94      public CmisBinding createCmisBinding(Map<String, String> sessionParameters,
95              AuthenticationProvider authenticationProvider) {
96          checkSessionParameters(sessionParameters, true);
97  
98          addDefaultParameters(sessionParameters);
99  
100         return new CmisBindingImpl(sessionParameters, authenticationProvider);
101     }
102 
103     /**
104      * Creates a default CMIS AtomPub binding instance.
105      */
106     public CmisBinding createCmisAtomPubBinding(Map<String, String> sessionParameters) {
107         return createCmisAtomPubBinding(sessionParameters, null);
108     }
109 
110     /**
111      * Creates a default CMIS AtomPub binding instance with a custom
112      * authentication provider.
113      */
114     public CmisBinding createCmisAtomPubBinding(Map<String, String> sessionParameters,
115             AuthenticationProvider authenticationProvider) {
116         checkSessionParameters(sessionParameters, false);
117 
118         sessionParameters.put(SessionParameter.BINDING_SPI_CLASS, BINDING_SPI_ATOMPUB);
119         if (authenticationProvider == null) {
120             if (!sessionParameters.containsKey(SessionParameter.AUTHENTICATION_PROVIDER_CLASS)) {
121                 sessionParameters.put(SessionParameter.AUTHENTICATION_PROVIDER_CLASS, STANDARD_AUTHENTICATION_PROVIDER);
122             }
123         }
124         if (!sessionParameters.containsKey(SessionParameter.AUTH_HTTP_BASIC)) {
125             sessionParameters.put(SessionParameter.AUTH_HTTP_BASIC, "true");
126         }
127         sessionParameters.put(SessionParameter.AUTH_SOAP_USERNAMETOKEN, "false");
128         addDefaultParameters(sessionParameters);
129 
130         check(sessionParameters, SessionParameter.ATOMPUB_URL);
131 
132         return new CmisBindingImpl(sessionParameters, authenticationProvider);
133     }
134 
135     /**
136      * Creates a default CMIS Web Services binding instance.
137      */
138     public CmisBinding createCmisWebServicesBinding(Map<String, String> sessionParameters) {
139         return createCmisWebServicesBinding(sessionParameters, null);
140     }
141 
142     /**
143      * Creates a default CMIS Web Services binding instance with a custom
144      * authentication provider.
145      */
146     public CmisBinding createCmisWebServicesBinding(Map<String, String> sessionParameters,
147             AuthenticationProvider authenticationProvider) {
148         checkSessionParameters(sessionParameters, false);
149 
150         sessionParameters.put(SessionParameter.BINDING_SPI_CLASS, BINDING_SPI_WEBSERVICES);
151         if (authenticationProvider == null) {
152             if (!sessionParameters.containsKey(SessionParameter.AUTHENTICATION_PROVIDER_CLASS)) {
153                 sessionParameters.put(SessionParameter.AUTHENTICATION_PROVIDER_CLASS, STANDARD_AUTHENTICATION_PROVIDER);
154             }
155         }
156         if (!sessionParameters.containsKey(SessionParameter.AUTH_SOAP_USERNAMETOKEN)) {
157             sessionParameters.put(SessionParameter.AUTH_SOAP_USERNAMETOKEN, "true");
158         }
159         if (!sessionParameters.containsKey(SessionParameter.AUTH_HTTP_BASIC)) {
160             sessionParameters.put(SessionParameter.AUTH_HTTP_BASIC, "true");
161         }
162         addDefaultParameters(sessionParameters);
163 
164         check(sessionParameters, SessionParameter.WEBSERVICES_ACL_SERVICE);
165         check(sessionParameters, SessionParameter.WEBSERVICES_DISCOVERY_SERVICE);
166         check(sessionParameters, SessionParameter.WEBSERVICES_MULTIFILING_SERVICE);
167         check(sessionParameters, SessionParameter.WEBSERVICES_NAVIGATION_SERVICE);
168         check(sessionParameters, SessionParameter.WEBSERVICES_OBJECT_SERVICE);
169         check(sessionParameters, SessionParameter.WEBSERVICES_POLICY_SERVICE);
170         check(sessionParameters, SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE);
171         check(sessionParameters, SessionParameter.WEBSERVICES_REPOSITORY_SERVICE);
172         check(sessionParameters, SessionParameter.WEBSERVICES_VERSIONING_SERVICE);
173 
174         return new CmisBindingImpl(sessionParameters, authenticationProvider);
175     }
176 
177     /**
178      * Creates a default CMIS Browser binding instance.
179      */
180     public CmisBinding createCmisBrowserBinding(Map<String, String> sessionParameters) {
181         return createCmisBrowserBinding(sessionParameters, null);
182     }
183 
184     /**
185      * Creates a default CMIS Browser binding instance with a custom
186      * authentication provider.
187      */
188     public CmisBinding createCmisBrowserBinding(Map<String, String> sessionParameters,
189             AuthenticationProvider authenticationProvider) {
190         checkSessionParameters(sessionParameters, false);
191 
192         sessionParameters.put(SessionParameter.BINDING_SPI_CLASS, BINDING_SPI_BROWSER);
193         if (authenticationProvider == null) {
194             if (!sessionParameters.containsKey(SessionParameter.AUTHENTICATION_PROVIDER_CLASS)) {
195                 sessionParameters.put(SessionParameter.AUTHENTICATION_PROVIDER_CLASS, STANDARD_AUTHENTICATION_PROVIDER);
196             }
197         }
198         if (!sessionParameters.containsKey(SessionParameter.AUTH_HTTP_BASIC)) {
199             sessionParameters.put(SessionParameter.AUTH_HTTP_BASIC, "true");
200         }
201         sessionParameters.put(SessionParameter.AUTH_SOAP_USERNAMETOKEN, "false");
202         addDefaultParameters(sessionParameters);
203 
204         check(sessionParameters, SessionParameter.BROWSER_URL);
205 
206         return new CmisBindingImpl(sessionParameters, authenticationProvider);
207     }
208 
209     /**
210      * Creates a default CMIS local binding instance.
211      */
212     public CmisBinding createCmisLocalBinding(Map<String, String> sessionParameters) {
213         checkSessionParameters(sessionParameters, false);
214 
215         sessionParameters.put(SessionParameter.BINDING_SPI_CLASS, BINDING_SPI_LOCAL);
216         addDefaultParameters(sessionParameters);
217 
218         check(sessionParameters, SessionParameter.LOCAL_FACTORY);
219 
220         return new CmisBindingImpl(sessionParameters);
221     }
222 
223     // ---- internal ----
224 
225     /**
226      * Checks the passed session parameters.
227      */
228     private static void checkSessionParameters(Map<String, String> sessionParameters, boolean mustContainSPI) {
229         // don't accept null
230         if (sessionParameters == null) {
231             throw new IllegalArgumentException("Session parameter map not set!");
232         }
233 
234         // check binding entry
235         String SPIClass = sessionParameters.get(SessionParameter.BINDING_SPI_CLASS);
236         if (mustContainSPI) {
237             if ((SPIClass == null) || (SPIClass.trim().length() == 0)) {
238                 throw new IllegalArgumentException("SPI class entry (" + SessionParameter.BINDING_SPI_CLASS
239                         + ") is missing!");
240             }
241         }
242     }
243 
244     /**
245      * Checks if the given parameter is present. If not, throw an
246      * <code>IllegalArgumentException</code>.
247      */
248     private static void check(Map<String, String> sessionParameters, String parameter) {
249         if (!sessionParameters.containsKey(parameter)) {
250             throw new IllegalArgumentException("Parameter '" + parameter + "' is missing!");
251         }
252     }
253 
254     /**
255      * Add the default session parameters to the given map without override
256      * existing entries.
257      */
258     private void addDefaultParameters(Map<String, String> sessionParameters) {
259         for (String key : defaults.keySet()) {
260             if (!sessionParameters.containsKey(key)) {
261                 sessionParameters.put(key, defaults.get(key));
262             }
263         }
264     }
265 
266     /**
267      * Creates a default session parameters map with some reasonable defaults.
268      */
269     private static Map<String, String> createNewDefaultParameters() {
270         Map<String, String> result = new HashMap<String, String>();
271 
272         result.put(SessionParameter.CACHE_SIZE_REPOSITORIES, "10");
273         result.put(SessionParameter.CACHE_SIZE_TYPES, "100");
274         result.put(SessionParameter.CACHE_SIZE_LINKS, "400");
275 
276         return result;
277     }
278 }