001/* 002 * Copyright 2015-2017 UnboundID Corp. 003 * All Rights Reserved. 004 */ 005/* 006 * Copyright (C) 2015-2017 UnboundID Corp. 007 * 008 * This program is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU General Public License (GPLv2 only) 010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 011 * as published by the Free Software Foundation. 012 * 013 * This program is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU General Public License for more details. 017 * 018 * You should have received a copy of the GNU General Public License 019 * along with this program; if not, see <http://www.gnu.org/licenses>. 020 */ 021package com.unboundid.util.args; 022 023 024 025import com.unboundid.ldap.sdk.LDAPException; 026import com.unboundid.ldap.sdk.LDAPURL; 027import com.unboundid.util.Debug; 028import com.unboundid.util.NotMutable; 029import com.unboundid.util.ThreadSafety; 030import com.unboundid.util.ThreadSafetyLevel; 031 032import static com.unboundid.util.args.ArgsMessages.*; 033 034 035 036/** 037 * This class provides an implementation of an argument value validator that is 038 * expected to be used with a string argument and ensures that all values for 039 * the argument are valid LDAP URLs. It can optionally indicate which elements 040 * are required to be present in the URL. 041 */ 042@NotMutable() 043@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 044public final class LDAPURLArgumentValueValidator 045 extends ArgumentValueValidator 046{ 047 // Indicates whether the attributes element is required to be present in the 048 // URL with at least one value. 049 private final boolean requireAttributes; 050 051 // Indicates whether a non-empty base DN element is required to be present in 052 // the URL. 053 private final boolean requireBaseDN; 054 055 // Indicates whether the filter element is required to be present in the URL. 056 private final boolean requireFilter; 057 058 // Indicates whether the host element is required to be present in the URL. 059 private final boolean requireHost; 060 061 // Indicates whether the port element is required to be present in the URL. 062 private final boolean requirePort; 063 064 // Indicates whether the scope element is required to be present in the URL. 065 private final boolean requireScope; 066 067 068 069 /** 070 * Creates a new instance of this LDAP URL argument value validator that will 071 * accept values that represent any valid LDAP URL. 072 */ 073 public LDAPURLArgumentValueValidator() 074 { 075 this(false, false, false, false, false, false); 076 } 077 078 079 080 /** 081 * Creates a new instance of this LDAP URL argument value validator that will 082 * accept values that represent valid LDAP URLs with the specified 083 * constraints. 084 * 085 * @param requireHost Indicates whether LDAP URL values are required 086 * to include the host element. 087 * @param requirePort Indicates whether LDAP URL values are required 088 * to include the port element. 089 * @param requireBaseDN Indicates whether LDAP URL values are required 090 * to include a non-empty base DN element. 091 * @param requireAttributes Indicates whether LDAP URL values are required 092 * to include an attribute list with at least one 093 * attribute description. 094 * @param requireScope Indicates whether LDAP URL values are required 095 * to include the scope element. 096 * @param requireFilter Indicates whether LDAP URL values are required 097 * to include the filter element. 098 */ 099 public LDAPURLArgumentValueValidator(final boolean requireHost, 100 final boolean requirePort, 101 final boolean requireBaseDN, 102 final boolean requireAttributes, 103 final boolean requireScope, 104 final boolean requireFilter) 105 { 106 this.requireHost = requireHost; 107 this.requirePort = requirePort; 108 this.requireBaseDN = requireBaseDN; 109 this.requireAttributes = requireAttributes; 110 this.requireScope = requireScope; 111 this.requireFilter = requireFilter; 112 } 113 114 115 116 /** 117 * Indicates whether LDAP URL values are required to include the host element. 118 * 119 * @return {@code true} if LDAP URL values are required to include the host 120 * element, or {@code false} if not. 121 */ 122 public boolean requireHost() 123 { 124 return requireHost; 125 } 126 127 128 129 /** 130 * Indicates whether LDAP URL values are required to include the port element. 131 * 132 * @return {@code true} if LDAP URL values are required to include the port 133 * element, or {@code false} if not. 134 */ 135 public boolean requirePort() 136 { 137 return requirePort; 138 } 139 140 141 142 /** 143 * Indicates whether LDAP URL values are required to include a non-empty base 144 * DN element. 145 * 146 * @return {@code true} if LDAP URL values are required to include a 147 * non-empty base DN element, or {@code false} if not. 148 */ 149 public boolean requireBaseDN() 150 { 151 return requireBaseDN; 152 } 153 154 155 156 /** 157 * Indicates whether LDAP URL values are required to include the attributes 158 * element with at least one attribute description. 159 * 160 * @return {@code true} if LDAP URL values are required to include the 161 * attributes element, or {@code false} if not. 162 */ 163 public boolean requireAttributes() 164 { 165 return requireAttributes; 166 } 167 168 169 170 /** 171 * Indicates whether LDAP URL values are required to include the scope 172 * element. 173 * 174 * @return {@code true} if LDAP URL values are required to include the scope 175 * element, or {@code false} if not. 176 */ 177 public boolean requireScope() 178 { 179 return requireScope; 180 } 181 182 183 184 /** 185 * Indicates whether LDAP URL values are required to include the filter 186 * element. 187 * 188 * @return {@code true} if LDAP URL values are required to include the filter 189 * element, or {@code false} if not. 190 */ 191 public boolean requireFilter() 192 { 193 return requireFilter; 194 } 195 196 197 198 /** 199 * {@inheritDoc} 200 */ 201 @Override() 202 public void validateArgumentValue(final Argument argument, 203 final String valueString) 204 throws ArgumentException 205 { 206 final LDAPURL ldapURL; 207 try 208 { 209 ldapURL = new LDAPURL(valueString); 210 } 211 catch (final LDAPException e) 212 { 213 Debug.debugException(e); 214 throw new ArgumentException( 215 ERR_LDAP_URL_VALIDATOR_VALUE_NOT_LDAP_URL.get(valueString, 216 argument.getIdentifierString(), e.getMessage()), 217 e); 218 } 219 220 if (requireHost && (! ldapURL.hostProvided())) 221 { 222 throw new ArgumentException( 223 ERR_LDAP_URL_VALIDATOR_MISSING_HOST.get(valueString, 224 argument.getIdentifierString())); 225 } 226 227 if (requirePort && (! ldapURL.portProvided())) 228 { 229 throw new ArgumentException( 230 ERR_LDAP_URL_VALIDATOR_MISSING_PORT.get(valueString, 231 argument.getIdentifierString())); 232 } 233 234 if (requireBaseDN && (! ldapURL.baseDNProvided())) 235 { 236 throw new ArgumentException( 237 ERR_LDAP_URL_VALIDATOR_MISSING_BASE_DN.get(valueString, 238 argument.getIdentifierString())); 239 } 240 241 if (requireAttributes && (! ldapURL.attributesProvided())) 242 { 243 throw new ArgumentException( 244 ERR_LDAP_URL_VALIDATOR_MISSING_ATTRIBUTES.get(valueString, 245 argument.getIdentifierString())); 246 } 247 248 if (requireScope && (! ldapURL.scopeProvided())) 249 { 250 throw new ArgumentException( 251 ERR_LDAP_URL_VALIDATOR_MISSING_SCOPE.get(valueString, 252 argument.getIdentifierString())); 253 } 254 255 if (requireFilter && (! ldapURL.filterProvided())) 256 { 257 throw new ArgumentException( 258 ERR_LDAP_URL_VALIDATOR_MISSING_FILTER.get(valueString, 259 argument.getIdentifierString())); 260 } 261 } 262 263 264 265 /** 266 * Retrieves a string representation of this argument value validator. 267 * 268 * @return A string representation of this argument value validator. 269 */ 270 @Override() 271 public String toString() 272 { 273 final StringBuilder buffer = new StringBuilder(); 274 toString(buffer); 275 return buffer.toString(); 276 } 277 278 279 280 /** 281 * Appends a string representation of this argument value validator to the 282 * provided buffer. 283 * 284 * @param buffer The buffer to which the string representation should be 285 * appended. 286 */ 287 public void toString(final StringBuilder buffer) 288 { 289 buffer.append("LDAPURLArgumentValueValidator(requireHost="); 290 buffer.append(requireHost); 291 buffer.append(", requirePort="); 292 buffer.append(requirePort); 293 buffer.append(", requireBaseDN="); 294 buffer.append(requireBaseDN); 295 buffer.append(", requireAttributes="); 296 buffer.append(requireAttributes); 297 buffer.append(", requireScope="); 298 buffer.append(requireScope); 299 buffer.append(", requireFilter="); 300 buffer.append(requireFilter); 301 buffer.append(')'); 302 } 303}