/**
     * Retrieves a paginated list of job logs based on the provided pager configuration.
     *
     * @param jobLogPager the pager configuration for pagination and filtering
     * @return a list of job logs matching the criteria
     */
    public List<JobLog> getJobLogList(final JobLogPager jobLogPager) {

        final PagingResultBean<JobLog> jobLogList = jobLogBhv.selectPage(cb -> {

    // Start by looking for exact matches. We start at the leftmost label. For example, foo.bar.com
    // will look like: [foo, bar, com], [bar, com], [com]. The longest matching rule wins.
    var exactMatch: String? = null
    for (i in domainLabelsUtf8Bytes.indices) {
      val rule = publicSuffixList.bytes.binarySearch(domainLabelsUtf8Bytes, i)
      if (rule != null) {
        exactMatch = rule

	}
}

func (b *bucketMetacache) debugf(format string, data ...any) {
	if serverDebugLog {
		console.Debugf(format+"\n", data...)
	}
}

// findCache will attempt to find a matching cache for the provided options.
// If a cache with the same ID exists already it will be returned.
// If none can be found a new is created with the provided ID.
func (b *bucketMetacache) findCache(o listPathOptions) metacache {

     * Updates the pager with pagination information including total count and page navigation.
     *
     * @param userPager the pager containing search criteria and pagination settings
     * @return a list of users matching the criteria
     */
    public List<User> getUserList(final UserPager userPager) {

        final PagingResultBean<User> userList = userBhv.selectPage(cb -> {

                try {
                    list.add(new LabelTypePattern(labelType.getValue(), includedPaths, excludedPaths));
                } catch (final Exception e) {
                    logger.warn("Failed to create a matching pattern of a label: {}, includedPaths:{}, excludedPaths:{}",
                            labelType.getValue(), includedPaths, excludedPaths, e);
                }
            }
        }

    val connect = planConnect()

    // Now that we have a set of IP addresses, make another attempt at getting a connection from
    // the pool. We have a better chance of matching thanks to connection coalescing.
    val pooled2 = planReusePooledConnection(connect, connect.routes)
    if (pooled2 != null) return pooled2

    return connect
  }

  /**

        int ctxOffsetFromHeader = 256; // arbitrary aligned location beyond header
        byte[] baseBody = buildCreateBodyWithContext(fileId, ctxOffsetFromHeader);

        // Build actual context bytes matching the pointers inside baseBody
        byte[] ctx = new byte[0x40];
        int ci = 0;
        SMBUtil.writeInt4(0, ctx, ci); // Next = 0
        ci += 4;
        SMBUtil.writeInt2(0x10, ctx, ci); // NameOffset

      if command:
        failure_msg = (f'\nThe command was:\n\n'
                       f'{command}\n\n')
      else:
        failure_msg = ('\nCouldn\'t parse a bazel command '
                       'matching the invocation, inside the log. '
                       'Please look for it in the build log.\n\n')
      failure_msg += (
          f'See the ResultStore link for a detailed view of failed targets:\n'

### Interaction with extended Bucket Versioning configuration

When Bucket Versioning with excluded prefixes are configured objects matching these prefixes are excluded from being versioned and replicated.

```
<VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
        <Status>Enabled</Status>

        @DisplayName("Should fixup host for matching FQDN")
        void testFixupHostWithMatchingFQDN() {
            setupReferralWithServer("SERVER");

            referralData.fixupHost("server.example.com");

            assertEquals("server.example.com", referralData.getServer());
        }

        @Test
        @DisplayName("Should not fixup host for non-matching FQDN")