@Override
public void upgrade(
ServerHttpRequest request,
ServerHttpResponse response,
String protocol,
WebSocketHandler wsHandler,
Map<String, Object> attrs)
throws IOException {
Assert.isInstanceOf(ServletServerHttpRequest.class, request);
HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
Assert.isInstanceOf(ServletServerHttpResponse.class, response);
HttpServletResponse servletResponse =
((ServletServerHttpResponse) response).getServletResponse();
if (!this.factory.isUpgradeRequest(servletRequest, servletResponse)) {
// should never happen
throw new HandshakeFailureException("Not a WebSocket request");
}
JettyWebSocketSession wsSession = new JettyWebSocketSession(request.getPrincipal(), attrs);
JettyWebSocketHandlerAdapter wsListener =
new JettyWebSocketHandlerAdapter(wsHandler, wsSession);
servletRequest.setAttribute(WEBSOCKET_LISTENER_ATTR_NAME, wsListener);
if (!this.factory.acceptWebSocket(servletRequest, servletResponse)) {
// should not happen
throw new HandshakeFailureException("WebSocket request not accepted by Jetty");
}
}
@Override
protected void doInit() {
Assert.state(
exchangeNameExpression == null || exchangeName == null,
"Either an exchangeName or an exchangeNameExpression can be provided, but not both");
BeanFactory beanFactory = this.getBeanFactory();
if (this.exchangeNameExpression != null) {
this.exchangeNameGenerator =
new ExpressionEvaluatingMessageProcessor<String>(
this.exchangeNameExpression, String.class);
if (beanFactory != null) {
this.exchangeNameGenerator.setBeanFactory(beanFactory);
}
}
Assert.state(
routingKeyExpression == null || routingKey == null,
"Either a routingKey or a routingKeyExpression can be provided, but not both");
if (this.routingKeyExpression != null) {
this.routingKeyGenerator =
new ExpressionEvaluatingMessageProcessor<String>(this.routingKeyExpression, String.class);
if (beanFactory != null) {
this.routingKeyGenerator.setBeanFactory(beanFactory);
}
}
if (this.confirmCorrelationExpression != null) {
this.correlationDataGenerator =
new ExpressionEvaluatingMessageProcessor<Object>(
this.confirmCorrelationExpression, Object.class);
Assert.isInstanceOf(
RabbitTemplate.class,
this.amqpTemplate,
"RabbitTemplate implementation is required for publisher confirms");
((RabbitTemplate) this.amqpTemplate).setConfirmCallback(this);
if (beanFactory != null) {
this.correlationDataGenerator.setBeanFactory(beanFactory);
}
} else {
NullChannel nullChannel = extractTypeIfPossible(this.confirmAckChannel, NullChannel.class);
Assert.state(
this.confirmAckChannel == null || nullChannel != null,
"A 'confirmCorrelationExpression' is required when specifying a 'confirmAckChannel'");
nullChannel = extractTypeIfPossible(this.confirmNackChannel, NullChannel.class);
Assert.state(
this.confirmNackChannel == null || nullChannel != null,
"A 'confirmCorrelationExpression' is required when specifying a 'confirmNackChannel'");
}
if (this.returnChannel != null) {
Assert.isInstanceOf(
RabbitTemplate.class,
this.amqpTemplate,
"RabbitTemplate implementation is required for publisher confirms");
((RabbitTemplate) this.amqpTemplate).setReturnCallback(this);
}
}
@Override
public void bindRequestor(
String name, MessageChannel requests, MessageChannel replies, Properties properties) {
if (logger.isInfoEnabled()) {
logger.info("binding requestor: " + name);
}
validateProducerProperties(name, properties, SUPPORTED_REQUESTING_PRODUCER_PROPERTIES);
Assert.isInstanceOf(SubscribableChannel.class, requests);
RabbitPropertiesAccessor accessor = new RabbitPropertiesAccessor(properties);
String queueName = applyRequests(name);
AmqpOutboundEndpoint queue =
this.buildOutboundEndpoint(queueName, accessor, this.rabbitTemplate);
queue.setBeanFactory(this.getBeanFactory());
String replyQueueName =
accessor.getPrefix(this.defaultPrefix)
+ name
+ ".replies."
+ this.getIdGenerator().generateId();
this.doRegisterProducer(name, requests, queue, replyQueueName, accessor);
Queue replyQueue = new Queue(replyQueueName, false, false, true); // auto-delete
declareQueueIfNotPresent(replyQueue);
// register with context so it will be redeclared after a connection failure
if (!this.autoDeclareContext.containsBean(replyQueueName)) {
this.autoDeclareContext.getBeanFactory().registerSingleton(replyQueueName, replyQueue);
}
this.doRegisterConsumer(name, replies, replyQueue, accessor, false);
}
@Test
public void test_ml_always_return_true() {
Assert.isInstanceOf(BeanJarImpl.class, beanJar);
String resp = beanJar.saludaJar("eduardo");
Assert.isTrue("Hola eduardo Saludando desde jar".equals(resp));
}
public WebLogicClassLoaderAdapter(ClassLoader classLoader) {
Class wlGenericClassLoaderClass = null;
try {
wlGenericClassLoaderClass = classLoader.loadClass(GENERIC_CLASS_LOADER_NAME);
this.wlPreProcessorClass = classLoader.loadClass(CLASS_PRE_PROCESSOR_NAME);
this.addPreProcessorMethod =
classLoader
.getClass()
.getMethod("addInstanceClassPreProcessor", this.wlPreProcessorClass);
this.getClassFinderMethod = classLoader.getClass().getMethod("getClassFinder");
this.getParentMethod = classLoader.getClass().getMethod("getParent");
this.wlGenericClassLoaderConstructor =
wlGenericClassLoaderClass.getConstructor(
this.getClassFinderMethod.getReturnType(), ClassLoader.class);
} catch (Exception ex) {
throw new IllegalStateException(
"Could not initialize WebLogic LoadTimeWeaver because WebLogic 10 API classes are not available",
ex);
}
Assert.isInstanceOf(
wlGenericClassLoaderClass,
classLoader,
"ClassLoader must be instance of [" + wlGenericClassLoaderClass.getName() + "]");
this.classLoader = classLoader;
}
private boolean assertHttpClientInstance(HttpClient httpClient) {
Assert.isInstanceOf(
AbstractHttpClient.class,
httpClient,
"HttpClient has to be derivate of AbstractHttpClient in order to allow authentication.");
return true;
}
@Override
public MutableAcl createAcl(ObjectIdentity objectIdentity) throws AlreadyExistsException {
Assert.notNull(objectIdentity, "Object Identity required");
if (LOG.isDebugEnabled()) {
LOG.debug("BEGIN createAcl: objectIdentity: " + objectIdentity);
}
// Need to retrieve the current principal, in order to know who "owns"
// this ACL (can be changed later on)
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
PrincipalSid sid = new PrincipalSid(auth);
AclObjectIdentity newAoi = new AclObjectIdentity(objectIdentity);
newAoi.setOwnerId(sid.getPrincipal());
newAoi.setOwnerPrincipal(true);
newAoi.setEntriesInheriting(false);
try {
aclRepository.saveAcl(newAoi);
} catch (AclAlreadyExistsException e) {
throw new AlreadyExistsException(e.getMessage(), e);
}
// Retrieve the ACL via superclass (ensures cache registration, proper retrieval etc)
Acl acl = readAclById(objectIdentity);
Assert.isInstanceOf(MutableAcl.class, acl, "MutableAcl should be been returned");
if (LOG.isDebugEnabled()) {
LOG.debug("END createAcl: acl: " + acl);
}
return (MutableAcl) acl;
}
@SuppressWarnings("unchecked")
@HideFromClient
private <T extends Resource> T getResource(String name, Class<T> resourceType) {
Assert.notNull(name, "Name must not be null");
Assert.notNull(resourceType, "ResourceType must not be null");
Folder root;
String resourceName;
if (name.equals("/common")) {
root = this.fileSystem.getCommonFolder();
resourceName = "";
} else if (name.startsWith("/common/")) {
root = this.fileSystem.getCommonFolder();
resourceName = name.substring("/common/".length());
} else {
root = this.projectManager.getCurrentProject().getRootFolder();
resourceName = name;
}
if (resourceName.length() == 0) {
Assert.isInstanceOf(resourceType, root);
return (T) root;
}
return root.jail().get(resourceName, resourceType);
}
private Map<String, Object> discoverAndSetParameters(
IReportRunnable report, HttpServletRequest request) throws Throwable {
Map<String, Object> parms = new HashMap<String, Object>();
IGetParameterDefinitionTask task = birtEngine.createGetParameterDefinitionTask(report);
@SuppressWarnings("unchecked")
Collection<IParameterDefnBase> params = task.getParameterDefns(true);
for (IParameterDefnBase param : params) {
Assert.isInstanceOf(
IScalarParameterDefn.class,
param,
"the parameter must be assignable to " + IScalarParameterDefn.class.getName());
IScalarParameterDefn scalar = (IScalarParameterDefn) param;
if (this.reportParameters != null && this.reportParameters.get(param.getName()) != null) {
String format = scalar.getDisplayFormat();
// todo will this step on the Spring MVC converters?
ReportParameterConverter converter =
new ReportParameterConverter(format, request.getLocale());
Object value = this.reportParameters.get(param.getName());
parms.put(param.getName(), value);
// /* converter.parse(*/ this.reportParameters.get(param.getName()),
// scalar.getDataType()/*)*/);
} else if (StringUtils.hasText(getParameter(request, param.getName()))) {
parms.put(param.getName(), getParamValueObject(request, scalar));
}
}
task.close();
return parms;
}
/**
* Calculates the hash of password (and salt bytes, if supplied) and returns a base64 encoded
* concatenation of the hash and salt, prefixed with {SHA} (or {SSHA} if salt was used).
*
* @param rawPass the password to be encoded.
* @param salt the salt. Must be a byte array or null.
* @return the encoded password in the specified format
*/
public String encodePassword(String rawPass, Object salt) {
MessageDigest sha;
try {
sha = MessageDigest.getInstance("SHA");
sha.update(rawPass.getBytes("UTF-8"));
} catch (java.security.NoSuchAlgorithmException e) {
throw new IllegalStateException("No SHA implementation available!");
} catch (UnsupportedEncodingException ue) {
throw new IllegalStateException("UTF-8 not supported!");
}
if (salt != null) {
Assert.isInstanceOf(byte[].class, salt, "Salt value must be a byte array");
sha.update((byte[]) salt);
}
byte[] hash = combineHashAndSalt(sha.digest(), (byte[]) salt);
String prefix;
if (salt == null) {
prefix = forceLowerCasePrefix ? SHA_PREFIX_LC : SHA_PREFIX;
} else {
prefix = forceLowerCasePrefix ? SSHA_PREFIX_LC : SSHA_PREFIX;
}
return prefix + new String(Base64.encode(hash));
}
public void setClassLoader(ClassLoader classLoader) {
Assert.isInstanceOf(
GroovyClassLoader.class,
classLoader,
"Property [classLoader] must be an instance of GroovyClassLoader");
this.classLoader = (GroovyClassLoader) classLoader;
}
private Message<?> sendAndReceive(
String exchangeName,
String routingKey,
Message<?> requestMessage,
CorrelationData correlationData) {
Assert.isInstanceOf(
RabbitTemplate.class,
this.amqpTemplate,
"RabbitTemplate implementation is required for publisher confirms");
MessageConverter converter = ((RabbitTemplate) this.amqpTemplate).getMessageConverter();
MessageProperties amqpMessageProperties = new MessageProperties();
org.springframework.amqp.core.Message amqpMessage =
converter.toMessage(requestMessage.getPayload(), amqpMessageProperties);
this.headerMapper.fromHeadersToRequest(requestMessage.getHeaders(), amqpMessageProperties);
checkDeliveryMode(requestMessage, amqpMessageProperties);
org.springframework.amqp.core.Message amqpReplyMessage =
((RabbitTemplate) this.amqpTemplate)
.sendAndReceive(exchangeName, routingKey, amqpMessage, correlationData);
if (amqpReplyMessage == null) {
return null;
}
Object replyObject = converter.fromMessage(amqpReplyMessage);
AbstractIntegrationMessageBuilder<?> builder =
(replyObject instanceof Message)
? this.getMessageBuilderFactory().fromMessage((Message<?>) replyObject)
: this.getMessageBuilderFactory().withPayload(replyObject);
Map<String, ?> headers =
this.headerMapper.toHeadersFromReply(amqpReplyMessage.getMessageProperties());
builder.copyHeadersIfAbsent(headers);
return builder.build();
}
/**
* {@inheritDoc}
*
* @see es.ieci.tecdoc.isicres.legacy.ws.manager.impl.mapper.Mapper#map(java.lang.Object)
*/
public Object map(Object obj) {
Assert.isInstanceOf(InteresadoVO.class, obj);
InteresadoVO interesado = (InteresadoVO) obj;
WSStakeholder wsStakeholder = new WSStakeholder();
wsStakeholder.setBookId(Long.valueOf(interesado.getIdLibro()));
wsStakeholder.setFolderId(Long.valueOf(interesado.getIdRegistro()));
wsStakeholder.setId(Long.valueOf(interesado.getId()));
// Puede ocurrir que un interesado no tenga dirección de notificación
if (interesado.getDireccionNotificacion() != null) {
wsStakeholder.setIdAddress(Long.valueOf(interesado.getDireccionNotificacion().getId()));
}
wsStakeholder.setIdThirdParty(Long.valueOf(interesado.getTercero().getId()));
wsStakeholder.setName(interesado.getNombre());
wsStakeholder.setOrd(interesado.getOrden());
wsStakeholder.setPreferred(interesado.isPrincipal());
// El tipo indica si es fÃsico o jurÃdico
BaseTerceroVO tercero = interesado.getTercero();
if (tercero != null) {
if (tercero instanceof TerceroValidadoFisicoVO) {
wsStakeholder.setTypeStakeholder(TerceroType.FISICO_VALUE);
} else if (tercero instanceof TerceroValidadoJuridicoVO) {
wsStakeholder.setTypeStakeholder(TerceroType.JURIDICO_VALUE);
}
}
return wsStakeholder;
}
/**
* Converts a given {@link Document} to an AXIOM {@link org.apache.axiom.soap.SOAPEnvelope}.
*
* @param document the document to be converted
* @return the converted envelope
* @throws IllegalArgumentException in case of errors
* @see org.apache.rampart.util.Axis2Util.getSOAPEnvelopeFromDOMDocument(Document, boolean)
*/
public static SOAPEnvelope toEnvelope(Document document) {
try {
DOMImplementation implementation = document.getImplementation();
Assert.isInstanceOf(DOMImplementationLS.class, implementation);
DOMImplementationLS loadSaveImplementation = (DOMImplementationLS) implementation;
LSOutput output = loadSaveImplementation.createLSOutput();
ByteArrayOutputStream bos = new ByteArrayOutputStream();
output.setByteStream(bos);
LSSerializer serializer = loadSaveImplementation.createLSSerializer();
serializer.write(document, output);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
XMLInputFactory inputFactory = StAXUtils.getXMLInputFactory();
StAXSOAPModelBuilder stAXSOAPModelBuilder =
new StAXSOAPModelBuilder(inputFactory.createXMLStreamReader(bis), null);
SOAPEnvelope envelope = stAXSOAPModelBuilder.getSOAPEnvelope();
// Necessary to build a correct Axiom tree, see SWS-483
envelope.serialize(new NullOutputStream());
return envelope;
} catch (Exception ex) {
IllegalArgumentException iaex =
new IllegalArgumentException("Error in converting Document to SOAP Envelope");
iaex.initCause(ex);
throw iaex;
}
}
public void handleReturnValue(
Object returnValue,
MethodParameter returnType,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest)
throws Exception {
mavContainer.setRequestHandled(true);
if (returnValue == null) {
return;
}
ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
Assert.isInstanceOf(HttpEntity.class, returnValue);
HttpEntity<?> responseEntity = (HttpEntity<?>) returnValue;
if (responseEntity instanceof ResponseEntity) {
outputMessage.setStatusCode(((ResponseEntity<?>) responseEntity).getStatusCode());
}
HttpHeaders entityHeaders = responseEntity.getHeaders();
if (!entityHeaders.isEmpty()) {
outputMessage.getHeaders().putAll(entityHeaders);
}
Object body = responseEntity.getBody();
if (body != null) {
writeWithMessageConverters(body, returnType, inputMessage, outputMessage);
} else {
// flush headers to the HttpServletResponse
outputMessage.getBody();
}
}
/** La interfaz de Spring que se implementa, define este thrown de un Runtime Exception. */
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
Assert.isInstanceOf(
UsernamePasswordAuthenticationToken.class,
authentication,
"Only UsernamePasswordAuthenticationToken is supported");
final UsernamePasswordAuthenticationToken userToken =
(UsernamePasswordAuthenticationToken) authentication;
String mail = userToken.getName();
String password = (String) authentication.getCredentials();
LOGGER.debug("Authenticating user: "******"ROLE_USER"};
return createSuccessfulAuthentication(mail, password, null, roles);
} else {
if (UserStateEnum.SUSPENDED_BY_ADMIN.equals(checkCredentials.getUserStateEnum())) {
throw new UserSuspendedException(checkCredentials.getMessage());
} else {
throw new BadCredentialsException(checkCredentials.getMessage());
}
}
}
private AbstractEndpoint createEndpoint(MessageHandler handler, T annotation) {
AbstractEndpoint endpoint = null;
String inputChannelName =
(String) AnnotationUtils.getValue(annotation, INPUT_CHANNEL_ATTRIBUTE);
if (StringUtils.hasText(inputChannelName)) {
MessageChannel inputChannel;
try {
inputChannel = this.channelResolver.resolveDestination(inputChannelName);
} catch (DestinationResolutionException e) {
inputChannel = new DirectChannel();
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
ConfigurableListableBeanFactory listableBeanFactory =
(ConfigurableListableBeanFactory) this.beanFactory;
listableBeanFactory.registerSingleton(inputChannelName, inputChannel);
inputChannel =
(MessageChannel) listableBeanFactory.initializeBean(inputChannel, inputChannelName);
}
}
Assert.notNull(inputChannel, "failed to resolve inputChannel '" + inputChannelName + "'");
Assert.isInstanceOf(
SubscribableChannel.class,
inputChannel,
"The input channel for an Annotation-based endpoint must be a SubscribableChannel.");
endpoint = new EventDrivenConsumer((SubscribableChannel) inputChannel, handler);
}
return endpoint;
}
private SimpleMessageGroup buildMessageGroup(Object groupId, boolean raw) {
Assert.notNull(groupId, "'groupId' must not be null");
Object mgm = this.doRetrieve(MESSAGE_GROUP_KEY_PREFIX + groupId);
if (mgm != null) {
Assert.isInstanceOf(MessageGroupMetadata.class, mgm);
MessageGroupMetadata messageGroupMetadata = (MessageGroupMetadata) mgm;
ArrayList<Message<?>> messages = new ArrayList<Message<?>>();
Iterator<UUID> messageIds = messageGroupMetadata.messageIdIterator();
while (messageIds.hasNext()) {
if (raw) {
messages.add(this.getRawMessage(messageIds.next()));
} else {
messages.add(this.getMessage(messageIds.next()));
}
}
SimpleMessageGroup messageGroup =
new SimpleMessageGroup(
messages,
groupId,
messageGroupMetadata.getTimestamp(),
messageGroupMetadata.isComplete());
messageGroup.setLastReleasedMessageSequenceNumber(
messageGroupMetadata.getLastReleasedMessageSequenceNumber());
return messageGroup;
} else {
return new SimpleMessageGroup(groupId);
}
}
private MediaType getRequestedMediaType() {
RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
Assert.isInstanceOf(ServletRequestAttributes.class, attrs);
HttpServletRequest request = ((ServletRequestAttributes) attrs).getRequest();
MediaType requestedMediaType = getMediaTypes(request);
return requestedMediaType;
}
@Override
protected void endpointInit() {
if (getConfirmCorrelationExpression() != null) {
Assert.isInstanceOf(
RabbitTemplate.class,
this.amqpTemplate,
"RabbitTemplate implementation is required for publisher confirms");
((RabbitTemplate) this.amqpTemplate).setConfirmCallback(this);
}
if (getReturnChannel() != null) {
Assert.isInstanceOf(
RabbitTemplate.class,
this.amqpTemplate,
"RabbitTemplate implementation is required for publisher confirms");
((RabbitTemplate) this.amqpTemplate).setReturnCallback(this);
}
}
@Override
public void setEnvironment(Environment environment) {
Assert.isInstanceOf(
ConfigurableEnvironment.class,
environment,
"unsupported environment type. " + environment.getClass());
this.environment = (ConfigurableEnvironment) environment;
}
/**
* Gets the http servlet response from the context.
*
* @param context the context
* @return the http servlet response
*/
public static HttpServletResponse getHttpServletResponse(final RequestContext context) {
Assert.isInstanceOf(
ServletExternalContext.class,
context.getExternalContext(),
"Cannot obtain HttpServletResponse from event of type: "
+ context.getExternalContext().getClass().getName());
return (HttpServletResponse) context.getExternalContext().getNativeResponse();
}
protected void configureSslStoreProvider(
AbstractHttp11JsseProtocol<?> protocol, SslStoreProvider sslStoreProvider) {
Assert.isInstanceOf(
Http11NioProtocol.class,
protocol,
"SslStoreProvider can only be used with Http11NioProtocol");
((Http11NioProtocol) protocol).getEndpoint().setAttribute("sslStoreProvider", sslStoreProvider);
protocol.setSslImplementationName(TomcatEmbeddedJSSEImplementation.class.getName());
}
/**
* Opens and returns a connection to the given URL.
*
* <p>The default implementation uses the given {@linkplain #setProxy(java.net.Proxy) proxy} - if
* any - to open a connection.
*
* @param url the URL to open a connection to
* @param proxy the proxy to use, may be {@code null}
* @return the opened connection
* @throws IOException in case of I/O errors
*/
protected HttpURLConnection openConnection(URL url, Proxy proxy) throws IOException {
// Bugs with reusing connections in Android 2.2 (Froyo) and older
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO) {
System.setProperty("http.keepAlive", "false");
}
URLConnection urlConnection =
(proxy != null ? url.openConnection(proxy) : url.openConnection());
Assert.isInstanceOf(HttpURLConnection.class, urlConnection);
return (HttpURLConnection) urlConnection;
}
private void udpateRequest(
ServerHttpRequest request, ServerHttpResponse response, FrameFormat frameFormat) {
Assert.notNull(request, "expected request");
Assert.notNull(response, "expected response");
Assert.notNull(frameFormat, "expected frameFormat");
Assert.isInstanceOf(AsyncServerHttpRequest.class, request, "Expected AsyncServerHttpRequest");
this.asyncRequest = (AsyncServerHttpRequest) request;
this.response = response;
this.frameFormat = frameFormat;
}
public void testRESTXMLWithWrongCodingSchemeParameter() throws Exception {
try {
callRestfulService(
"GetXML?query=org.LexGrid.codingSchemes.CodingScheme&org.LexGrid.codingSchemes.CodingScheme&codingSchemeName=INVALID_CODING_SCHEME");
} catch (Exception e) {
Assert.isInstanceOf(FileNotFoundException.class, e);
return;
}
fail();
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
throws BeansException {
Assert.isInstanceOf(
ConfigurableListableBeanFactory.class,
registry,
"Test Database Auto-configuration can only be "
+ "used with a ConfigurableListableBeanFactory");
process(registry, (ConfigurableListableBeanFactory) registry);
}
@Override
public Binding<MessageChannel> bindProducer(
final String name, MessageChannel moduleOutputChannel, Properties properties) {
Assert.isInstanceOf(SubscribableChannel.class, moduleOutputChannel);
KafkaPropertiesAccessor producerPropertiesAccessor = new KafkaPropertiesAccessor(properties);
validateProducerProperties(name, properties, SUPPORTED_PRODUCER_PROPERTIES);
if (logger.isInfoEnabled()) {
logger.info("Using kafka topic for outbound: " + name);
}
final String topicName = escapeTopicName(name);
int numPartitions = producerPropertiesAccessor.getNumberOfKafkaPartitionsForProducer();
Collection<Partition> partitions =
ensureTopicCreated(topicName, numPartitions, defaultReplicationFactor);
ProducerMetadata<byte[], byte[]> producerMetadata =
new ProducerMetadata<>(
topicName, byte[].class, byte[].class, BYTE_ARRAY_SERIALIZER, BYTE_ARRAY_SERIALIZER);
producerMetadata.setCompressionType(
ProducerMetadata.CompressionType.valueOf(
producerPropertiesAccessor.getCompressionCodec(this.defaultCompressionCodec)));
producerMetadata.setBatchBytes(producerPropertiesAccessor.getBatchSize(this.defaultBatchSize));
Properties additionalProps = new Properties();
additionalProps.put(
ProducerConfig.ACKS_CONFIG,
String.valueOf(producerPropertiesAccessor.getRequiredAcks(this.defaultRequiredAcks)));
additionalProps.put(
ProducerConfig.LINGER_MS_CONFIG,
String.valueOf(producerPropertiesAccessor.getBatchTimeout(this.defaultBatchTimeout)));
ProducerFactoryBean<byte[], byte[]> producerFB =
new ProducerFactoryBean<>(producerMetadata, brokers, additionalProps);
try {
final ProducerConfiguration<byte[], byte[]> producerConfiguration =
new ProducerConfiguration<>(producerMetadata, producerFB.getObject());
MessageHandler handler =
new SendingHandler(
topicName, producerPropertiesAccessor, partitions.size(), producerConfiguration);
EventDrivenConsumer consumer =
new EventDrivenConsumer((SubscribableChannel) moduleOutputChannel, handler);
consumer.setBeanFactory(this.getBeanFactory());
consumer.setBeanName("outbound." + name);
consumer.afterPropertiesSet();
Binding<MessageChannel> producerBinding =
Binding.forProducer(name, moduleOutputChannel, consumer, producerPropertiesAccessor);
addBinding(producerBinding);
producerBinding.start();
return producerBinding;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* This is the main method of this class, calling authentication, authorization and user details
* mapping.
*
* @param authentication object to populate
* @return Populated authentication object
* @throws AuthenticationException
*/
public Authentication authenticate(final Authentication authentication)
throws AuthenticationException {
Assert.isInstanceOf(
UsernamePasswordAuthenticationToken.class,
authentication,
messages.getMessage(
"AbstractUserDetailsAuthenticationProvider.onlySupports",
"Only UsernamePasswordAuthenticationToken is supported"));
logger.finest("CustomLdapAuthenticationProvider: authenticate");
final UsernamePasswordAuthenticationToken userToken =
(UsernamePasswordAuthenticationToken) authentication;
String username = userToken.getName();
String password = (String) authentication.getCredentials();
logger.fine("Processing authentication request for user: "******"LdapAuthenticationProvider.emptyUsername", "Empty Username"));
}
Assert.notNull(password, "Null password was supplied in authentication token");
try {
DirContextOperations userData = getAuthenticator().authenticate(authentication);
Collection<GrantedAuthority> extraAuthorities =
loadUserAuthorities(userData, username, password);
Collection<String> userAuthGroups = loadUserAuthGroups(userData, username, password);
ExtendedLdapUserDetailsImpl extendedUserDetails =
userDetailsContextMapper.mapUserFromContext(
userData, username, extraAuthorities, userAuthGroups);
return createSuccessfulAuthentication(userToken, extendedUserDetails);
} catch (PasswordPolicyException ppe) {
// The only reason a ppolicy exception can occur during a bind is that the account is locked.
throw new LockedException(
messages.getMessage(ppe.getStatus().getErrorCode(), ppe.getStatus().getDefaultMessage()));
} catch (UsernameNotFoundException notFound) {
if (hideUserNotFoundExceptions) {
throw new BadCredentialsException(
messages.getMessage("LdapAuthenticationProvider.badCredentials", "Bad credentials"));
} else {
throw notFound;
}
} catch (NamingException ldapAccessFailure) {
throw new AuthenticationServiceException(ldapAccessFailure.getMessage(), ldapAccessFailure);
}
}
/**
* {@inheritDoc}
*
* @see es.ieci.tecdoc.isicres.legacy.ws.manager.impl.mapper.Mapper#map(java.lang.Object)
*/
public Object map(Object obj) {
Assert.isInstanceOf(CiudadVO.class, obj);
CiudadVO ciudadVO = (CiudadVO) obj;
WSCity wsCity = new WSCity();
wsCity.setCode(ciudadVO.getCodigo());
wsCity.setId(Long.valueOf(ciudadVO.getId()));
wsCity.setName(ciudadVO.getNombre());
return wsCity;
}