Java UncategorizedLdapException类代码示例

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
@Test(expected = UncategorizedLdapException.class)
public void newApplicationUserSaveFail() {
	final LdapPluginResource resource = new LdapPluginResource();
	resource.userResource = Mockito.mock(UserOrgResource.class);
	Mockito.when(resource.userResource.findByIdNoCache("flast123")).thenReturn(null);
	Mockito.doThrow(new UncategorizedLdapException("")).when(resource.userResource).saveOrUpdate(ArgumentMatchers.any(UserOrgEditionVo.class));

	final UserOrg user = new UserOrg();
	user.setMails(Collections.singletonList("[email protected]"));
	user.setFirstName("First");
	user.setLastName("Last123");
	user.setName("secondarylogin");
	user.setCompany("gfi");
	resource.newApplicationUser(user);
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
@SuppressWarnings("deprecation")
private static void loadLdif(DirContext context, Name rootNode, Resource ldifFile) {
       try {
           LdapName baseDn = (LdapName)
                   context.getEnvironment().get(DefaultDirObjectFactory.JNDI_ENV_BASE_PATH_KEY);

           LdifParser parser = new LdifParser(ldifFile);
           parser.open();
           while (parser.hasMoreRecords()) {
               LdapAttributes record = parser.getRecord();

               LdapName dn = record.getName();

               if(baseDn != null) {
                   dn = LdapUtils.removeFirst(dn, baseDn);
               }

               if(!rootNode.isEmpty()) {
                   dn = LdapUtils.prepend(dn, rootNode);
               }
               context.bind(dn, null, record);
           }
       } catch (Exception e) {
           throw new UncategorizedLdapException("Failed to populate LDIF", e);
       }
   }
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
protected void loadControlClasses() {
	Assert.notNull(defaultRequestControl, "defaultRequestControl must not be null");
	Assert.notNull(defaultResponseControl, "defaultResponseControl must not be null");
	Assert.notNull(fallbackRequestControl, "fallbackRequestControl must not be null");
	Assert.notNull(fallbackResponseControl, "fallbackReponseControl must not be null");
	try {
		requestControlClass = Class.forName(defaultRequestControl);
		responseControlClass = Class.forName(defaultResponseControl);
	}
	catch (ClassNotFoundException e) {
		log.debug("Default control classes not found - falling back to LdapBP classes", e);

		try {
			requestControlClass = Class.forName(fallbackRequestControl);
			responseControlClass = Class.forName(fallbackResponseControl);
		}
		catch (ClassNotFoundException e1) {
			throw new UncategorizedLdapException(
					"Neither default nor fallback classes are available - unable to proceed", e);
		}
	}
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
private void loadControlClasses() {
	try {
		requestControlClass = Class.forName(DEFAULT_REQUEST_CONTROL);
		responseControlClass = Class.forName(DEFAULT_RESPONSE_CONTROL);
	}
	catch (ClassNotFoundException e) {
		log.debug("Default control classes not found - falling back to LdapBP classes", e);

		try {
			requestControlClass = Class.forName(LDAPBP_REQUEST_CONTROL);
			responseControlClass = Class.forName(LDAPBP_RESPONSE_CONTROL);
		}
		catch (ClassNotFoundException e1) {
			throw new UncategorizedLdapException(
					"Neither default nor fallback classes are available - unable to proceed", e);
		}

	}
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
@Test
public void testRename_NamingException() throws Exception {
    expectGetReadWriteContext();

    javax.naming.NamingException ne = new javax.naming.NamingException();

    doThrow(ne).when(dirContextMock).rename(oldNameMock, newNameMock);

    try {
        tested.rename(oldNameMock, newNameMock);
        fail("UncategorizedLdapException expected");
    } catch (UncategorizedLdapException expected) {
        assertThat(true).isTrue();
    }

    verify(dirContextMock).close();
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
@Test
public void testAuthenticateWithErrorInCallbackShouldFail() throws Exception {
	when(contextSourceMock.getReadOnlyContext()).thenReturn(dirContextMock);

	Object expectedObject = new DirContextAdapter(new BasicAttributes(), LdapUtils.newLdapName("cn=john doe"),
			LdapUtils.newLdapName("dc=jayway, dc=se"));
	SearchResult searchResult = new SearchResult("", expectedObject, new BasicAttributes());

	singleSearchResult(searchControlsRecursive(), searchResult);

	when(contextSourceMock.getContext("cn=john doe,dc=jayway,dc=se", "password"))
               .thenReturn(authenticatedContextMock);
       doThrow(new UncategorizedLdapException("Authentication failed")).when(entryContextCallbackMock)
               .executeWithContext(authenticatedContextMock,
                       new LdapEntryIdentification(
                               LdapUtils.newLdapName("cn=john doe,dc=jayway,dc=se"), LdapUtils.newLdapName("cn=john doe")));

	boolean result = tested.authenticate(nameMock, "(ou=somevalue)", "password", entryContextCallbackMock);

       verify(authenticatedContextMock).close();
       verify(dirContextMock).close();

       assertThat(result).isFalse();
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
private static void loadLdif(DirContext context, Name rootNode, Resource ldifFile) {
    try {
        LdapName baseDn = (LdapName)
                context.getEnvironment().get(DefaultDirObjectFactory.JNDI_ENV_BASE_PATH_KEY);

        LdifParser parser = new LdifParser(ldifFile);
        parser.open();
        while (parser.hasMoreRecords()) {
            LdapAttributes record = parser.getRecord();

            LdapName dn = record.getName();

            if(baseDn != null) {
                dn = LdapUtils.removeFirst(dn, baseDn);
            }

            if(!rootNode.isEmpty()) {
                dn = LdapUtils.prepend(dn, rootNode);
            }
            context.bind(dn, null, record);
        }
    } catch (Exception e) {
        throw new UncategorizedLdapException("Failed to populate LDIF", e);
    }
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @throws UncategorizedLdapException
 *             in case the wrapped mapper could not map the attributes. The actual exception
 *             will be contained in the cause.
 */
@Override
public Object mapFromAttributes(Attributes attributes) throws NamingException,
UncategorizedLdapException {
    try {
        return mapper.mapAttributes(dn, attributes);
    } catch (LdapAttributeMappingException e) {
        throw new UncategorizedLdapException("Mapping LDAP attributes failed", e);
    }
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
/**
 * Start an embedded Apache Directory Server. Only one embedded server will be permitted in the same JVM.
 *
 * @param port                   the port on which the server will be listening.
 * @param defaultPartitionSuffix The default base suffix that will be used
 *                               for the LDAP server.
 * @param defaultPartitionName   The name to use in the directory server
 *                               configuration for the default base suffix.
 *
 * @throws IllegalStateException if an embedded server is already started.
 */
public static void startEmbeddedServer(int port, String defaultPartitionSuffix, String defaultPartitionName) {
    if(embeddedServer != null) {
        throw new IllegalStateException("An embedded server is already started");
    }

    try {
        embeddedServer = EmbeddedLdapServer.newEmbeddedServer(defaultPartitionName, defaultPartitionSuffix, port);
    } catch (Exception e) {
        throw new UncategorizedLdapException("Failed to start embedded server", e);
    }
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public Collection<Object> newCollectionInstance() {
    try {
        return (Collection<Object>) collectionClass.newInstance();
    } catch (Exception e) {
        throw new UncategorizedLdapException("Failed to instantiate collection class", e);
    }
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
/**
 * @see java.lang.Object#clone()
 */
public Object clone() {
	try {
		DistinguishedName result = (DistinguishedName) super.clone();
		result.names = new LinkedList(names);
		return result;
	}
	catch (CloneNotSupportedException e) {
		LOG.error("CloneNotSupported thrown from superclass - this should not happen");
		throw new UncategorizedLdapException("Fatal error in clone", e);
	}
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
static String nameEncodeForUrl(String value) {
    try {
        String ldapEncoded = LdapEncoder.nameEncode(value);
        URI valueUri = new URI(null, null, ldapEncoded, null);
        return valueUri.toString();
    } catch (URISyntaxException e) {
        throw new UncategorizedLdapException("This really shouldn't happen - report this", e);
    }
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
public final DirContext processContextAfterCreation(DirContext ctx, String userDn, String password)
		throws NamingException {

	if (ctx instanceof LdapContext) {
		final LdapContext ldapCtx = (LdapContext) ctx;
		final StartTlsResponse tlsResponse = (StartTlsResponse) ldapCtx.extendedOperation(new StartTlsRequest());
		try {
			if (hostnameVerifier != null) {
				tlsResponse.setHostnameVerifier(hostnameVerifier);
			}
			tlsResponse.negotiate(sslSocketFactory); // If null, the default SSL socket factory is used
			applyAuthentication(ldapCtx, userDn, password);

			if (shutdownTlsGracefully) {
				// Wrap the target context in a proxy to intercept any calls
				// to 'close', so that we can shut down the TLS connection
				// gracefully first.
				return (DirContext) Proxy.newProxyInstance(DirContextProxy.class.getClassLoader(), new Class<?>[] {
						LdapContext.class, DirContextProxy.class }, new TlsAwareDirContextProxy(ldapCtx,
						tlsResponse));
			}
			else {
				return ctx;
			}
		}
		catch (IOException e) {
			LdapUtils.closeContext(ctx);
			throw new UncategorizedLdapException("Failed to negotiate TLS session", e);
		}
	}
	else {
		throw new IllegalArgumentException(
				"Processed Context must be an LDAPv3 context, i.e. an LdapContext implementation");
	}

}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public <T> T authenticate(LdapQuery query, String password, AuthenticatedLdapEntryContextMapper<T> mapper) {
    SearchControls searchControls = searchControlsForQuery(query, RETURN_OBJ_FLAG);
    ReturningAuthenticatedLdapEntryContext<T> mapperCallback =
            new ReturningAuthenticatedLdapEntryContext<T>(mapper);
    CollectingAuthenticationErrorCallback errorCallback =
            new CollectingAuthenticationErrorCallback();

    AuthenticationStatus authenticationStatus = authenticate(query.base(),
            query.filter().encode(),
            password,
            searchControls,
            mapperCallback,
            errorCallback);

    if(errorCallback.hasError()) {
        Exception error = errorCallback.getError();

        if (error instanceof NamingException) {
            throw (NamingException) error;
        } else {
            throw new UncategorizedLdapException(error);
        }
    } else if(AuthenticationStatus.EMPTYRESULT == authenticationStatus) {
    	throw new EmptyResultDataAccessException(1);
    } else if(!authenticationStatus.isSuccess()) {
        throw new AuthenticationException();
    }

    return mapperCallback.collectedObject;
}
 

import org.springframework.ldap.UncategorizedLdapException; //导入依赖的package包/类
static String formatForUrl(LdapName ldapName) {
    StringBuilder sb = new StringBuilder();
    ListIterator<Rdn> it = ldapName.getRdns().listIterator(ldapName.size());
    while (it.hasPrevious()) {
        Rdn component = it.previous();

        Attributes attributes = component.toAttributes();

        // Loop through all attribute of the rdn (usually just one, but more are supported by RFC)
        NamingEnumeration<? extends Attribute> allAttributes = attributes.getAll();
        while(allAttributes.hasMoreElements()) {
            Attribute oneAttribute = allAttributes.nextElement();
            String encodedAttributeName = nameEncodeForUrl(oneAttribute.getID());

            // Loop through all values of the attribute (usually just one, but more are supported by RFC)
            NamingEnumeration <?> allValues;
            try {
                allValues = oneAttribute.getAll();
            } catch (NamingException e) {
                throw new UncategorizedLdapException("Unexpected error occurred formatting base URL", e);
            }

            while(allValues.hasMoreElements()) {
                sb.append(encodedAttributeName).append('=');

                Object oneValue = allValues.nextElement();
                if (oneValue instanceof String) {
                    String oneString = (String) oneValue;
                    sb.append(nameEncodeForUrl(oneString));
                } else {
                    throw new IllegalArgumentException("Binary attributes not supported for base URL");
                }

                if(allValues.hasMoreElements()) {
                    sb.append('+');
                }
            }
            if(allAttributes.hasMoreElements()) {
                sb.append('+');
            }
        }

        if(it.hasPrevious()) {
            sb.append(',');
        }
    }
    return sb.toString();
}