001/* 002 * Copyright 2009-2020 Ping Identity Corporation 003 * All Rights Reserved. 004 */ 005/* 006 * Copyright 2009-2020 Ping Identity Corporation 007 * 008 * Licensed under the Apache License, Version 2.0 (the "License"); 009 * you may not use this file except in compliance with the License. 010 * You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, software 015 * distributed under the License is distributed on an "AS IS" BASIS, 016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 017 * See the License for the specific language governing permissions and 018 * limitations under the License. 019 */ 020/* 021 * Copyright (C) 2015-2020 Ping Identity Corporation 022 * 023 * This program is free software; you can redistribute it and/or modify 024 * it under the terms of the GNU General Public License (GPLv2 only) 025 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 026 * as published by the Free Software Foundation. 027 * 028 * This program is distributed in the hope that it will be useful, 029 * but WITHOUT ANY WARRANTY; without even the implied warranty of 030 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 031 * GNU General Public License for more details. 032 * 033 * You should have received a copy of the GNU General Public License 034 * along with this program; if not, see <http://www.gnu.org/licenses>. 035 */ 036package com.unboundid.ldap.sdk.unboundidds.logs; 037 038 039 040import java.util.Collections; 041import java.util.LinkedList; 042import java.util.List; 043import java.util.StringTokenizer; 044 045import com.unboundid.ldap.sdk.ResultCode; 046import com.unboundid.ldap.sdk.unboundidds.controls.AssuredReplicationLocalLevel; 047import com.unboundid.ldap.sdk.unboundidds.controls. 048 AssuredReplicationRemoteLevel; 049import com.unboundid.util.NotExtensible; 050import com.unboundid.util.NotMutable; 051import com.unboundid.util.ThreadSafety; 052import com.unboundid.util.ThreadSafetyLevel; 053 054 055 056/** 057 * This class provides a data structure that holds information about a log 058 * message that may appear in the Directory Server access log about the result 059 * of a delete operation processed by the Directory Server. 060 * <BR> 061 * <BLOCKQUOTE> 062 * <B>NOTE:</B> This class, and other classes within the 063 * {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only 064 * supported for use against Ping Identity, UnboundID, and 065 * Nokia/Alcatel-Lucent 8661 server products. These classes provide support 066 * for proprietary functionality or for external specifications that are not 067 * considered stable or mature enough to be guaranteed to work in an 068 * interoperable way with other types of LDAP servers. 069 * </BLOCKQUOTE> 070 */ 071@NotExtensible() 072@NotMutable() 073@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 074public class DeleteResultAccessLogMessage 075 extends DeleteRequestAccessLogMessage 076 implements OperationResultAccessLogMessage 077{ 078 /** 079 * The serial version UID for this serializable class. 080 */ 081 private static final long serialVersionUID = -4379716182028950134L; 082 083 084 085 // The assured replication level to use for local servers. 086 private final AssuredReplicationLocalLevel assuredReplicationLocalLevel; 087 088 // The assured replication level to use for remote servers. 089 private final AssuredReplicationRemoteLevel assuredReplicationRemoteLevel; 090 091 // Indicates whether the delete operation targeted a soft-deleted entry. 092 private final Boolean changeToSoftDeletedEntry; 093 094 // Indicates whether the response was known to be delayed by replication 095 // assurance processing. 096 private final Boolean responseDelayedByAssurance; 097 098 // Indicates whether the any uncached data was accessed in the course of 099 // processing this operation. 100 private final Boolean uncachedDataAccessed; 101 102 // The processing time for the operation. 103 private final Double processingTime; 104 105 // The queue time for the operation. 106 private final Double queueTime; 107 108 // The port of the backend server to which the request has been forwarded. 109 private final Integer targetPort; 110 111 // The list of indexes for which keys near the index entry limit were accessed 112 // while processing the operation. 113 private final List<String> indexesWithKeysAccessedNearEntryLimit; 114 115 // The list of indexes for which keys over the index entry limit were accessed 116 // while processing the operation. 117 private final List<String> indexesWithKeysAccessedOverEntryLimit; 118 119 // The list of privileges required for processing the operation that the 120 // requester did not have. 121 private final List<String> missingPrivileges; 122 123 // The list of privileges used during the course of processing the operation 124 // before an alternate authorization identity was assigned. 125 private final List<String> preAuthZUsedPrivileges; 126 127 // The list of referral URLs for the operation. 128 private final List<String> referralURLs; 129 130 // The list of response control OIDs for the operation. 131 private final List<String> responseControlOIDs; 132 133 // The list of servers accessed while processing the operation. 134 private final List<String> serversAccessed; 135 136 // The list of privileges used during the course of processing the operation. 137 private final List<String> usedPrivileges; 138 139 // The assured replication timeout, in milliseconds. 140 private final Long assuredReplicationTimeoutMillis; 141 142 // The number of intermediate response messages returned to the client. 143 private final Long intermediateResponsesReturned; 144 145 // The result code for the operation. 146 private final ResultCode resultCode; 147 148 // Additional information about the operation result. 149 private final String additionalInformation; 150 151 // The alternate authorization DN for the operation. 152 private final String authzDN; 153 154 // The diagnostic message for the operation. 155 private final String diagnosticMessage; 156 157 // The intermediate client result for the operation. 158 private final String intermediateClientResult; 159 160 // The matched DN for the operation. 161 private final String matchedDN; 162 163 // The replication change ID for the operation. 164 private final String replicationChangeID; 165 166 // The DN of the soft-deleted entry that was created as a result of a soft 167 // delete operation rather than a hard delete. 168 private final String softDeletedEntryDN; 169 170 // The address of the backend server to which the request has been forwarded. 171 private final String targetHost; 172 173 // The protocol used to forward the request to the backend server. 174 private final String targetProtocol; 175 176 177 178 /** 179 * Creates a new delete result access log message from the provided message 180 * string. 181 * 182 * @param s The string to be parsed as a delete result access log message. 183 * 184 * @throws LogException If the provided string cannot be parsed as a valid 185 * log message. 186 */ 187 public DeleteResultAccessLogMessage(final String s) 188 throws LogException 189 { 190 this(new LogMessage(s)); 191 } 192 193 194 195 /** 196 * Creates a new delete result access log message from the provided log 197 * message. 198 * 199 * @param m The log message to be parsed as a delete result access log 200 * message. 201 */ 202 public DeleteResultAccessLogMessage(final LogMessage m) 203 { 204 super(m); 205 206 diagnosticMessage = getNamedValue("message"); 207 additionalInformation = getNamedValue("additionalInfo"); 208 matchedDN = getNamedValue("matchedDN"); 209 processingTime = getNamedValueAsDouble("etime"); 210 queueTime = getNamedValueAsDouble("qtime"); 211 intermediateClientResult = getNamedValue("from"); 212 authzDN = getNamedValue("authzDN"); 213 replicationChangeID = getNamedValue("replicationChangeID"); 214 softDeletedEntryDN = getNamedValue("softDeleteEntryDN"); 215 targetHost = getNamedValue("targetHost"); 216 targetPort = getNamedValueAsInteger("targetPort"); 217 targetProtocol = getNamedValue("targetProtocol"); 218 219 changeToSoftDeletedEntry = 220 getNamedValueAsBoolean("changeToSoftDeletedEntry"); 221 intermediateResponsesReturned = 222 getNamedValueAsLong("intermediateResponsesReturned"); 223 224 final Integer rcInteger = getNamedValueAsInteger("resultCode"); 225 if (rcInteger == null) 226 { 227 resultCode = null; 228 } 229 else 230 { 231 resultCode = ResultCode.valueOf(rcInteger); 232 } 233 234 final String refStr = getNamedValue("referralURLs"); 235 if ((refStr == null) || refStr.isEmpty()) 236 { 237 referralURLs = Collections.emptyList(); 238 } 239 else 240 { 241 final LinkedList<String> refs = new LinkedList<>(); 242 int startPos = 0; 243 while (true) 244 { 245 final int commaPos = refStr.indexOf(",ldap", startPos); 246 if (commaPos < 0) 247 { 248 refs.add(refStr.substring(startPos)); 249 break; 250 } 251 else 252 { 253 refs.add(refStr.substring(startPos, commaPos)); 254 startPos = commaPos+1; 255 } 256 } 257 referralURLs = Collections.unmodifiableList(refs); 258 } 259 260 final String controlStr = getNamedValue("responseControls"); 261 if (controlStr == null) 262 { 263 responseControlOIDs = Collections.emptyList(); 264 } 265 else 266 { 267 final LinkedList<String> controlList = new LinkedList<>(); 268 final StringTokenizer t = new StringTokenizer(controlStr, ","); 269 while (t.hasMoreTokens()) 270 { 271 controlList.add(t.nextToken()); 272 } 273 responseControlOIDs = Collections.unmodifiableList(controlList); 274 } 275 276 final String serversAccessedStr = getNamedValue("serversAccessed"); 277 if ((serversAccessedStr == null) || serversAccessedStr.isEmpty()) 278 { 279 serversAccessed = Collections.emptyList(); 280 } 281 else 282 { 283 final LinkedList<String> servers = new LinkedList<>(); 284 final StringTokenizer tokenizer = 285 new StringTokenizer(serversAccessedStr, ","); 286 while (tokenizer.hasMoreTokens()) 287 { 288 servers.add(tokenizer.nextToken()); 289 } 290 serversAccessed = Collections.unmodifiableList(servers); 291 } 292 293 uncachedDataAccessed = getNamedValueAsBoolean("uncachedDataAccessed"); 294 295 296 final String localLevelStr = getNamedValue("localAssuranceLevel"); 297 if (localLevelStr == null) 298 { 299 assuredReplicationLocalLevel = null; 300 } 301 else 302 { 303 assuredReplicationLocalLevel = 304 AssuredReplicationLocalLevel.valueOf(localLevelStr); 305 } 306 307 final String remoteLevelStr = getNamedValue("remoteAssuranceLevel"); 308 if (remoteLevelStr == null) 309 { 310 assuredReplicationRemoteLevel = null; 311 } 312 else 313 { 314 assuredReplicationRemoteLevel = 315 AssuredReplicationRemoteLevel.valueOf(remoteLevelStr); 316 } 317 318 assuredReplicationTimeoutMillis = 319 getNamedValueAsLong("assuranceTimeoutMillis"); 320 responseDelayedByAssurance = 321 getNamedValueAsBoolean("responseDelayedByAssurance"); 322 323 final String usedPrivilegesStr = getNamedValue("usedPrivileges"); 324 if ((usedPrivilegesStr == null) || usedPrivilegesStr.isEmpty()) 325 { 326 usedPrivileges = Collections.emptyList(); 327 } 328 else 329 { 330 final LinkedList<String> privileges = new LinkedList<>(); 331 final StringTokenizer tokenizer = 332 new StringTokenizer(usedPrivilegesStr, ","); 333 while (tokenizer.hasMoreTokens()) 334 { 335 privileges.add(tokenizer.nextToken()); 336 } 337 usedPrivileges = Collections.unmodifiableList(privileges); 338 } 339 340 final String preAuthZUsedPrivilegesStr = 341 getNamedValue("preAuthZUsedPrivileges"); 342 if ((preAuthZUsedPrivilegesStr == null) || 343 preAuthZUsedPrivilegesStr.isEmpty()) 344 { 345 preAuthZUsedPrivileges = Collections.emptyList(); 346 } 347 else 348 { 349 final LinkedList<String> privileges = new LinkedList<>(); 350 final StringTokenizer tokenizer = 351 new StringTokenizer(preAuthZUsedPrivilegesStr, ","); 352 while (tokenizer.hasMoreTokens()) 353 { 354 privileges.add(tokenizer.nextToken()); 355 } 356 preAuthZUsedPrivileges = Collections.unmodifiableList(privileges); 357 } 358 359 final String missingPrivilegesStr = getNamedValue("missingPrivileges"); 360 if ((missingPrivilegesStr == null) || missingPrivilegesStr.isEmpty()) 361 { 362 missingPrivileges = Collections.emptyList(); 363 } 364 else 365 { 366 final LinkedList<String> privileges = new LinkedList<>(); 367 final StringTokenizer tokenizer = 368 new StringTokenizer(missingPrivilegesStr, ","); 369 while (tokenizer.hasMoreTokens()) 370 { 371 privileges.add(tokenizer.nextToken()); 372 } 373 missingPrivileges = Collections.unmodifiableList(privileges); 374 } 375 376 final String indexesNearLimitStr = 377 getNamedValue("indexesWithKeysAccessedNearEntryLimit"); 378 if ((indexesNearLimitStr == null) || indexesNearLimitStr.isEmpty()) 379 { 380 indexesWithKeysAccessedNearEntryLimit = Collections.emptyList(); 381 } 382 else 383 { 384 final LinkedList<String> indexes = new LinkedList<>(); 385 final StringTokenizer tokenizer = 386 new StringTokenizer(indexesNearLimitStr, ","); 387 while (tokenizer.hasMoreTokens()) 388 { 389 indexes.add(tokenizer.nextToken()); 390 } 391 indexesWithKeysAccessedNearEntryLimit = 392 Collections.unmodifiableList(indexes); 393 } 394 395 final String indexesOverLimitStr = 396 getNamedValue("indexesWithKeysAccessedExceedingEntryLimit"); 397 if ((indexesOverLimitStr == null) || indexesOverLimitStr.isEmpty()) 398 { 399 indexesWithKeysAccessedOverEntryLimit = Collections.emptyList(); 400 } 401 else 402 { 403 final LinkedList<String> indexes = new LinkedList<>(); 404 final StringTokenizer tokenizer = 405 new StringTokenizer(indexesOverLimitStr, ","); 406 while (tokenizer.hasMoreTokens()) 407 { 408 indexes.add(tokenizer.nextToken()); 409 } 410 indexesWithKeysAccessedOverEntryLimit = 411 Collections.unmodifiableList(indexes); 412 } 413 } 414 415 416 417 /** 418 * Retrieves the result code for the operation. 419 * 420 * @return The result code for the operation, or {@code null} if it is not 421 * included in the log message. 422 */ 423 @Override() 424 public ResultCode getResultCode() 425 { 426 return resultCode; 427 } 428 429 430 431 /** 432 * Retrieves the diagnostic message for the operation. 433 * 434 * @return The diagnostic message for the operation, or {@code null} if it is 435 * not included in the log message. 436 */ 437 @Override() 438 public String getDiagnosticMessage() 439 { 440 return diagnosticMessage; 441 } 442 443 444 445 /** 446 * Retrieves a message with additional information about the result of the 447 * operation. 448 * 449 * @return A message with additional information about the result of the 450 * operation, or {@code null} if it is not included in the log 451 * message. 452 */ 453 @Override() 454 public String getAdditionalInformation() 455 { 456 return additionalInformation; 457 } 458 459 460 461 /** 462 * Retrieves the matched DN for the operation. 463 * 464 * @return The matched DN for the operation, or {@code null} if it is not 465 * included in the log message. 466 */ 467 @Override() 468 public String getMatchedDN() 469 { 470 return matchedDN; 471 } 472 473 474 475 /** 476 * Retrieves the list of referral URLs for the operation. 477 * 478 * @return The list of referral URLs for the operation, or an empty list if 479 * it is not included in the log message. 480 */ 481 @Override() 482 public List<String> getReferralURLs() 483 { 484 return referralURLs; 485 } 486 487 488 489 /** 490 * Retrieves the number of intermediate response messages returned in the 491 * course of processing the operation. 492 * 493 * @return The number of intermediate response messages returned to the 494 * client in the course of processing the operation, or {@code null} 495 * if it is not included in the log message. 496 */ 497 @Override() 498 public Long getIntermediateResponsesReturned() 499 { 500 return intermediateResponsesReturned; 501 } 502 503 504 505 /** 506 * Retrieves the length of time in milliseconds required to process the 507 * operation. 508 * 509 * @return The length of time in milliseconds required to process the 510 * operation, or {@code null} if it is not included in the log 511 * message. 512 */ 513 @Override() 514 public Double getProcessingTimeMillis() 515 { 516 return processingTime; 517 } 518 519 520 521 /** 522 * Retrieves the length of time in milliseconds the operation was required to 523 * wait on the work queue. 524 * 525 * @return The length of time in milliseconds the operation was required to 526 * wait on the work queue, or {@code null} if it is not included in 527 * the log message. 528 */ 529 @Override() 530 public Double getQueueTimeMillis() 531 { 532 return queueTime; 533 } 534 535 536 537 /** 538 * Retrieves the OIDs of any response controls contained in the log message. 539 * 540 * @return The OIDs of any response controls contained in the log message, or 541 * an empty list if it is not included in the log message. 542 */ 543 @Override() 544 public List<String> getResponseControlOIDs() 545 { 546 return responseControlOIDs; 547 } 548 549 550 551 /** 552 * Retrieves a list of the additional servers that were accessed in the course 553 * of processing the operation. For example, if the access log message is 554 * from a Directory Proxy Server instance, then this may contain a list of the 555 * backend servers used to process the operation. 556 * 557 * @return A list of the additional servers that were accessed in the course 558 * of processing the operation, or an empty list if it is not 559 * included in the log message. 560 */ 561 @Override() 562 public List<String> getServersAccessed() 563 { 564 return serversAccessed; 565 } 566 567 568 569 /** 570 * Indicates whether the server accessed any uncached data in the course of 571 * processing the operation. 572 * 573 * @return {@code true} if the server was known to access uncached data in 574 * the course of processing the operation, {@code false} if the 575 * server was known not to access uncached data, or {@code null} if 576 * it is not included in the log message (and the server likely did 577 * not access uncached data). 578 */ 579 public Boolean getUncachedDataAccessed() 580 { 581 return uncachedDataAccessed; 582 } 583 584 585 586 /** 587 * Retrieves the content of the intermediate client result for the 588 * operation. 589 * 590 * @return The content of the intermediate client result for the operation, 591 * or {@code null} if it is not included in the log message. 592 */ 593 @Override() 594 public String getIntermediateClientResult() 595 { 596 return intermediateClientResult; 597 } 598 599 600 601 /** 602 * Retrieves the alternate authorization DN for the operation. 603 * 604 * @return The alternate authorization DN for the operation, or {@code null} 605 * if it is not included in the log message. 606 */ 607 public String getAlternateAuthorizationDN() 608 { 609 return authzDN; 610 } 611 612 613 614 /** 615 * Retrieves the replication change ID for the operation, if available. 616 * 617 * @return The replication change ID for the operation, or {@code null} if it 618 * is not included in the log message. 619 */ 620 public String getReplicationChangeID() 621 { 622 return replicationChangeID; 623 } 624 625 626 627 /** 628 * Retrieves the DN of the soft-deleted entry that was created as a result of 629 * this operation, if it was a soft delete rather than a normal hard delete. 630 * 631 * @return The DN of the soft-deleted entry that was created as a result of 632 * this operation, or {@code null} if it is not included in the log 633 * message (e.g., because the operation was a hard delete rather than 634 * a soft delete). 635 */ 636 public String getSoftDeletedEntryDN() 637 { 638 return softDeletedEntryDN; 639 } 640 641 642 643 /** 644 * Indicates whether the delete operation targeted a soft-deleted entry. 645 * 646 * @return {@code true} if the delete operation was known to target a 647 * soft-deleted entry, {@code false} if it was known to target a 648 * non-soft-deleted entry, or {@code null} if it is not included in 649 * the log message (and likely did not target a soft-deleted entry). 650 */ 651 public Boolean getChangeToSoftDeletedEntry() 652 { 653 return changeToSoftDeletedEntry; 654 } 655 656 657 658 /** 659 * Retrieves the address of the backend server to which the request has been 660 * forwarded. 661 * 662 * @return The address of the backend server to which the request has been 663 * forwarded, or {@code null} if it is not included in the log 664 * message. 665 */ 666 public String getTargetHost() 667 { 668 return targetHost; 669 } 670 671 672 673 /** 674 * Retrieves the port of the backend server to which the request has been 675 * forwarded. 676 * 677 * @return The port of the backend server to which the request has been 678 * forwarded, or {@code null} if it is not included in the log 679 * message. 680 */ 681 public Integer getTargetPort() 682 { 683 return targetPort; 684 } 685 686 687 688 /** 689 * Retrieves the protocol used to forward the request to the backend server. 690 * 691 * @return The protocol used to forward the request to the backend server, or 692 * {@code null} if it is not included in the log message. 693 */ 694 public String getTargetProtocol() 695 { 696 return targetProtocol; 697 } 698 699 700 701 /** 702 * Retrieves the local level that will be used for assured replication 703 * processing, if available. 704 * 705 * @return The local level that will be used for assured replication 706 * processing, or {@code null} if this is not included in the log 707 * message (e.g., because assured replication will not be performed 708 * for the operation). 709 */ 710 public AssuredReplicationLocalLevel getAssuredReplicationLocalLevel() 711 { 712 return assuredReplicationLocalLevel; 713 } 714 715 716 717 /** 718 * Retrieves the remote level that will be used for assured replication 719 * processing, if available. 720 * 721 * @return The remote level that will be used for assured replication 722 * processing, or {@code null} if this is not included in the log 723 * message (e.g., because assured replication will not be performed 724 * for the operation). 725 */ 726 public AssuredReplicationRemoteLevel getAssuredReplicationRemoteLevel() 727 { 728 return assuredReplicationRemoteLevel; 729 } 730 731 732 733 /** 734 * Retrieves the maximum length of time in milliseconds that the server will 735 * delay the response to the client while waiting for the replication 736 * assurance requirement to be satisfied. 737 * 738 * @return The maximum length of time in milliseconds that the server will 739 * delay the response to the client while waiting for the replication 740 * assurance requirement to be satisfied, or {@code null} if this is 741 * not included in the log message (e.g., because assured replication 742 * will not be performed for the operation). 743 */ 744 public Long getAssuredReplicationTimeoutMillis() 745 { 746 return assuredReplicationTimeoutMillis; 747 } 748 749 750 751 /** 752 * Indicates whether the operation response to the client will be delayed 753 * until replication assurance has been satisfied or the timeout has occurred. 754 * 755 * @return {@code true} if the operation response to the client will be 756 * delayed until replication assurance has been satisfied, 757 * {@code false} if the response will not be delayed by assurance 758 * processing, or {@code null} if this was not included in the 759 * log message (e.g., because assured replication will not be 760 * performed for the operation) 761 */ 762 public Boolean getResponseDelayedByAssurance() 763 { 764 return responseDelayedByAssurance; 765 } 766 767 768 769 /** 770 * Retrieves the names of any privileges used during the course of processing 771 * the operation. 772 * 773 * @return The names of any privileges used during the course of processing 774 * the operation, or an empty list if no privileges were used or this 775 * is not included in the log message. 776 */ 777 public List<String> getUsedPrivileges() 778 { 779 return usedPrivileges; 780 } 781 782 783 784 /** 785 * Retrieves the names of any privileges used during the course of processing 786 * the operation before an alternate authorization identity was assigned. 787 * 788 * @return The names of any privileges used during the course of processing 789 * the operation before an alternate authorization identity was 790 * assigned, or an empty list if no privileges were used or this is 791 * not included in the log message. 792 */ 793 public List<String> getPreAuthorizationUsedPrivileges() 794 { 795 return preAuthZUsedPrivileges; 796 } 797 798 799 800 /** 801 * Retrieves the names of any privileges that would have been required for 802 * processing the operation but that the requester did not have. 803 * 804 * @return The names of any privileges that would have been required for 805 * processing the operation but that the requester did not have, or 806 * an empty list if there were no missing privileges or this is not 807 * included in the log message. 808 */ 809 public List<String> getMissingPrivileges() 810 { 811 return missingPrivileges; 812 } 813 814 815 816 /** 817 * Retrieves the names of any indexes for which one or more keys near 818 * (typically, within 80% of) the index entry limit were accessed while 819 * processing the operation. 820 * 821 * @return The names of any indexes for which one or more keys near the index 822 * entry limit were accessed while processing the operation, or an 823 * empty list if no such index keys were accessed, or if this is not 824 * included in the log message. 825 */ 826 public List<String> getIndexesWithKeysAccessedNearEntryLimit() 827 { 828 return indexesWithKeysAccessedNearEntryLimit; 829 } 830 831 832 833 /** 834 * Retrieves the names of any indexes for which one or more keys over the 835 * index entry limit were accessed while processing the operation. 836 * 837 * @return The names of any indexes for which one or more keys over the index 838 * entry limit were accessed while processing the operation, or an 839 * empty list if no such index keys were accessed, or if this is not 840 * included in the log message. 841 */ 842 public List<String> getIndexesWithKeysAccessedOverEntryLimit() 843 { 844 return indexesWithKeysAccessedOverEntryLimit; 845 } 846 847 848 849 /** 850 * {@inheritDoc} 851 */ 852 @Override() 853 public AccessLogMessageType getMessageType() 854 { 855 return AccessLogMessageType.RESULT; 856 } 857}