001 /* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.extensions; 028 029 030 031 import java.util.LinkedHashSet; 032 import java.util.List; 033 import java.util.UUID; 034 035 import org.opends.messages.Message; 036 import org.opends.server.admin.std.server.EntryUUIDVirtualAttributeCfg; 037 import org.opends.server.api.VirtualAttributeProvider; 038 import org.opends.server.config.ConfigException; 039 import org.opends.server.core.SearchOperation; 040 import org.opends.server.loggers.debug.DebugTracer; 041 import org.opends.server.types.AttributeValue; 042 import org.opends.server.types.ByteString; 043 import org.opends.server.types.ByteStringFactory; 044 import org.opends.server.types.ConditionResult; 045 import org.opends.server.types.DebugLogLevel; 046 import org.opends.server.types.Entry; 047 import org.opends.server.types.InitializationException; 048 import org.opends.server.types.ResultCode; 049 import org.opends.server.types.VirtualAttributeRule; 050 051 import static org.opends.messages.ExtensionMessages.*; 052 import static org.opends.server.loggers.debug.DebugLogger.*; 053 import static org.opends.server.util.ServerConstants.*; 054 import static org.opends.server.util.StaticUtils.*; 055 056 057 058 /** 059 * This class implements a virtual attribute provider that is meant to serve the 060 * entryUUID operational attribute as described in RFC 4530. Note that this 061 * should only be used for entries used in conjuntion with data in private 062 * backends (e.g., those holding the configuration, schema, monitor, and root 063 * DSE entries). Real user data should have entry UUID values generated at the 064 * time the entries are added or imported. 065 */ 066 public class EntryUUIDVirtualAttributeProvider 067 extends VirtualAttributeProvider<EntryUUIDVirtualAttributeCfg> 068 { 069 /** 070 * The tracer object for the debug logger. 071 */ 072 private static final DebugTracer TRACER = getTracer(); 073 074 /** 075 * Creates a new instance of this entryUUID virtual attribute provider. 076 */ 077 public EntryUUIDVirtualAttributeProvider() 078 { 079 super(); 080 081 // All initialization should be performed in the 082 // initializeVirtualAttributeProvider method. 083 } 084 085 086 087 /** 088 * {@inheritDoc} 089 */ 090 @Override() 091 public void initializeVirtualAttributeProvider( 092 EntryUUIDVirtualAttributeCfg configuration) 093 throws ConfigException, InitializationException 094 { 095 // No initialization is required. 096 } 097 098 099 100 /** 101 * {@inheritDoc} 102 */ 103 @Override() 104 public boolean isMultiValued() 105 { 106 return false; 107 } 108 109 110 111 /** 112 * {@inheritDoc} 113 */ 114 @Override() 115 public LinkedHashSet<AttributeValue> getValues(Entry entry, 116 VirtualAttributeRule rule) 117 { 118 LinkedHashSet<AttributeValue> values = new LinkedHashSet<AttributeValue>(1); 119 120 String normDNString = entry.getDN().toNormalizedString(); 121 String uuidString = 122 UUID.nameUUIDFromBytes(getBytes(normDNString)).toString(); 123 values.add(new AttributeValue(ByteStringFactory.create(uuidString), 124 ByteStringFactory.create(uuidString))); 125 126 return values; 127 } 128 129 130 131 /** 132 * {@inheritDoc} 133 */ 134 @Override() 135 public boolean hasValue(Entry entry, VirtualAttributeRule rule) 136 { 137 // This virtual attribute provider will always generate a value. 138 return true; 139 } 140 141 142 143 /** 144 * {@inheritDoc} 145 */ 146 @Override() 147 public boolean hasValue(Entry entry, VirtualAttributeRule rule, 148 AttributeValue value) 149 { 150 try 151 { 152 String normalizedDN = entry.getDN().toNormalizedString(); 153 String uuidString = 154 UUID.nameUUIDFromBytes(getBytes(normalizedDN)).toString(); 155 156 String normalizedValue = value.getNormalizedStringValue(); 157 return uuidString.equals(normalizedValue); 158 } 159 catch (Exception e) 160 { 161 if (debugEnabled()) 162 { 163 TRACER.debugCaught(DebugLogLevel.ERROR, e); 164 } 165 166 return false; 167 } 168 } 169 170 171 172 /** 173 * {@inheritDoc} 174 */ 175 @Override() 176 public ConditionResult matchesSubstring(Entry entry, 177 VirtualAttributeRule rule, 178 ByteString subInitial, 179 List<ByteString> subAny, 180 ByteString subFinal) 181 { 182 // DNs cannot be used in substring matching. 183 return ConditionResult.UNDEFINED; 184 } 185 186 187 188 /** 189 * {@inheritDoc} 190 */ 191 @Override() 192 public ConditionResult greaterThanOrEqualTo(Entry entry, 193 VirtualAttributeRule rule, 194 AttributeValue value) 195 { 196 // DNs cannot be used in ordering matching. 197 return ConditionResult.UNDEFINED; 198 } 199 200 201 202 /** 203 * {@inheritDoc} 204 */ 205 @Override() 206 public ConditionResult lessThanOrEqualTo(Entry entry, 207 VirtualAttributeRule rule, 208 AttributeValue value) 209 { 210 // DNs cannot be used in ordering matching. 211 return ConditionResult.UNDEFINED; 212 } 213 214 215 216 /** 217 * {@inheritDoc} 218 */ 219 @Override() 220 public ConditionResult approximatelyEqualTo(Entry entry, 221 VirtualAttributeRule rule, 222 AttributeValue value) 223 { 224 // DNs cannot be used in approximate matching. 225 return ConditionResult.UNDEFINED; 226 } 227 228 229 230 /** 231 * {@inheritDoc}. This virtual attribute will support search operations only 232 * if one of the following is true about the search filter: 233 * <UL> 234 * <LI>It is an equality filter targeting the associated attribute 235 * type.</LI> 236 * <LI>It is an AND filter in which at least one of the components is an 237 * equality filter targeting the associated attribute type.</LI> 238 * <LI>It is an OR filter in which all of the components are equality 239 * filters targeting the associated attribute type.</LI> 240 * </UL> 241 */ 242 @Override() 243 public boolean isSearchable(VirtualAttributeRule rule, 244 SearchOperation searchOperation) 245 { 246 return false; 247 } 248 249 250 251 /** 252 * {@inheritDoc} 253 */ 254 @Override() 255 public void processSearch(VirtualAttributeRule rule, 256 SearchOperation searchOperation) 257 { 258 searchOperation.setResultCode(ResultCode.UNWILLING_TO_PERFORM); 259 260 Message message = ERR_ENTRYUUID_VATTR_NOT_SEARCHABLE.get( 261 rule.getAttributeType().getNameOrOID()); 262 searchOperation.appendErrorMessage(message); 263 } 264 } 265