/**
* afterPropertiesSet
*
* @throws java.lang.Exception if any.
*/
@Override
public void afterPropertiesSet() throws Exception {
Assert.state(m_resourceService != null, "resourceService property has not been set");
Assert.state(m_kscReportFactory != null, "kscReportFactory property has not been set");
initTimeSpans();
}
@PostConstruct
public void init() {
System.out.println("SnmpDevice Locator 开始初始化");
Assert.state(m_snmpDeviceService != null, "m_SnmpDeviceDao不能为空，请检查");
Assert.state(m_domainLocator != null, "m_domainLocator不能为空，请检查");
distruteAllSnmpDeviceNode();
}
/** onInit */
protected void onInit() {
Assert.state(m_queryMgr != null, "must set the queryManager property");
Assert.state(m_linkdConfig != null, "must set the linkdConfig property");
Assert.state(m_scheduler != null, "must set the scheduler property");
Assert.state(m_eventForwarder != null, "must set the eventForwarder property");
// FIXME: circular dependency
m_queryMgr.setLinkd(this);
m_activepackages = new ArrayList<String>();
// initialize the ipaddrsentevents
m_newSuspectEventsIpAddr = new TreeSet<InetAddress>(new InetAddressComparator());
m_newSuspectEventsIpAddr.add(addr("127.0.0.1"));
m_newSuspectEventsIpAddr.add(addr("0.0.0.0"));
try {
m_nodes = m_queryMgr.getSnmpNodeList();
m_queryMgr.updateDeletedNodes();
} catch (SQLException e) {
LogUtils.errorf(this, e, "SQL exception executing on database");
throw new UndeclaredThrowableException(e);
}
Assert.notNull(m_nodes);
scheduleCollection();
LogUtils.infof(this, "init: LINKD CONFIGURATION INITIALIZED");
}
/** afterPropertiesSet */
@Override
public void afterPropertiesSet() {
Assert.state(m_nodeDao != null, "nodeDao property has not been set");
Assert.state(m_resourceDao != null, "resourceDao property has not been set");
Assert.state(m_graphDao != null, "graphDao property has not been set");
Assert.state(m_rrdDao != null, "rrdDao property has not been set");
}
private boolean isTap() {
if (tap != null) {
Assert.state(tap.getName() != null, "Tap name not provided");
Assert.state(!tap.getGroup().equals(group), "Tap group cannot be the same as module group");
}
return tap != null;
}
private void prepareEvaluationContext(
StandardEvaluationContext context,
Object method,
Class<? extends Annotation> annotationType) {
Class<?> targetType = AopUtils.getTargetClass(this.targetObject);
if (method instanceof Method) {
context.registerMethodFilter(targetType, new FixedMethodFilter((Method) method));
if (expectedType != null) {
Assert.state(
context
.getTypeConverter()
.canConvert(
TypeDescriptor.valueOf(((Method) method).getReturnType()),
TypeDescriptor.valueOf(expectedType)),
"Cannot convert to expected type (" + expectedType + ") from " + method);
}
} else if (method == null || method instanceof String) {
AnnotatedMethodFilter filter =
new AnnotatedMethodFilter(annotationType, (String) method, this.requiresReply);
Assert.state(
canReturnExpectedType(filter, targetType, context.getTypeConverter()),
"Cannot convert to expected type (" + expectedType + ") from " + method);
context.registerMethodFilter(targetType, filter);
}
context.setVariable("target", targetObject);
}
/** Get/allocate spaceNeeded entries for the designated float-based attribute */
private int getFloatSpace(int attrId, int spaceNeeded) {
int sequence =
AttrDefinitionMgr.getAttrIndex(attrId); // this should be unique across all attributes
if (sequence < indicesPlusOne.size()) {
int indexPlusOne = indicesPlusOne.getQuick(sequence);
if (indexPlusOne > 0) {
Assert.state(
getLength(attrId) == spaceNeeded,
"getLength = "
+ getLength(attrId)
+ ", requested = "
+ spaceNeeded); // dumbo check to ensure not asking for diff size
return indexPlusOne - 1;
}
} else {
padSpace(indicesPlusOne, sequence);
}
// okay, it's not been allocated so ...
int index = nextFloatsIndex;
nextFloatsIndex += spaceNeeded;
indicesPlusOne.set(sequence, index + 1);
// Add to list of attrIds for iterator
Assert.state(attrIds.contains(attrId) == false);
attrIds.add(attrId);
setLength(sequence, spaceNeeded);
syncToStore(); // we sync here as we've modified
return index;
}
/**
* afterPropertiesSet
*
* @throws java.lang.Exception if any.
*/
@Override
public void afterPropertiesSet() throws Exception {
Assert.state(
m_configResource != null, "property configResource must be set to a non-null value");
Assert.state(m_localServer != null, "property localServer must be set to a non-null value");
Assert.state(m_verifyServer != null, "property verifyServer must be set to a non-null value");
loadConfig();
}
/** afterPropertiesSet */
public void afterPropertiesSet() {
Assert.state(m_jdbcTemplate != null, "property jdbcTemplate must be set to a non-null value");
Assert.state(m_capsdConfig != null, "property capsdConfig must be set to a non-null value");
Assert.state(
m_opennmsServerConfig != null,
"property opennmsServerConfig must be set to a non-null value");
Assert.state(m_pollerConfig != null, "property pollerConfig must be set to a non-null value");
Assert.state(
m_collectdConfig != null, "property collectdConfig must be set to a non-null value");
}
@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);
}
}
/**
* afterPropertiesSet
*
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
@Override
public void afterPropertiesSet() {
Assert.state(
m_delegatedVisitor != null, "property delegatedVisitor must be set to a non-null value");
Assert.state(
m_resourceAttributeKey != null,
"property resourceAttributeKey must be set to a non-null value");
Assert.state(
m_resourceAttributeValueMatch != null,
"property resourceAttributeValueMatch must be set to a non-null value");
}
@PostConstruct
public void checkLocationExists() {
if (this.properties.isCheckLocation()) {
Assert.state(
!this.properties.getLocations().isEmpty(), "Migration script locations not configured");
boolean exists = hasAtLeastOneLocation();
Assert.state(
exists,
"Cannot find migrations location in: "
+ this.properties.getLocations()
+ " (please add migrations or check your Flyway configuration)");
}
}
/**
* Create a new chunk oriented tasklet with reader, writer and processor as provided.
*
* @see org.springframework.batch.core.step.builder.SimpleStepBuilder#createTasklet()
*/
@Override
protected Tasklet createTasklet() {
Assert.state(getReader() != null, "ItemReader must be provided");
Assert.state(
getProcessor() != null || getWriter() != null,
"ItemWriter or ItemProcessor must be provided");
addSpecialExceptions();
registerSkipListeners();
FaultTolerantChunkProvider<I> chunkProvider = createChunkProvider();
FaultTolerantChunkProcessor<I, O> chunkProcessor = createChunkProcessor();
ChunkOrientedTasklet<I> tasklet = new ChunkOrientedTasklet<I>(chunkProvider, chunkProcessor);
tasklet.setBuffering(!isReaderTransactionalQueue());
return tasklet;
}
/**
* Rename a file or folder.
*
* @param from the source to rename, this will be a complete reference to a file or folder
* @param to the destination name, this will be a complete reference to the new name (including
* path)
* @param overwrite <tt>true</tt> if any existing destination should be overwritten. If this
* parameter is <tt>false</tt> a unique name should be generated based on <tt>to</tt>.
* @return the name of the new file (excluding the path)
*/
public String renameFile(
@ParamName(name = "from") String from,
@ParamName(name = "to") String to,
@ParamName(name = "overwrite") boolean overwrite) {
Resource source = getResource(from, Resource.class);
ResourcePath destination = new ResourcePath().get(to);
Folder destinationFolder = getResource(destination.getParent().toString(), Folder.class);
Assert.state(
destinationFolder.exists(),
"The destination folder '" + destinationFolder + "' does not exist");
String destinationName = destination.getName();
if (destinationFolder.hasExisting(destinationName) && !overwrite) {
destinationName = generateUniqueNumberedFileName(destinationFolder, destinationName);
}
Resource renamed = source;
if (!destinationFolder.equals(renamed.getParent())) {
renamed = renamed.moveTo(destinationFolder);
}
if (!renamed.getName().equals(destinationName)) {
renamed = renamed.rename(destinationName);
}
return renamed.getName();
}
@SuppressWarnings("unchecked")
public void afterPropertiesSet() throws Exception {
Assert.state(yaml != null, "Yaml document should not be null");
Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
try {
logger.trace("Yaml document is\n" + yaml);
configuration = (T) (new Yaml(constructor)).load(yaml);
Set<ConstraintViolation<T>> errors = validator.validate(configuration);
if (!errors.isEmpty()) {
logger.error("YAML configuration failed validation");
for (ConstraintViolation<?> error : errors) {
logger.error(error.getPropertyPath() + ": " + error.getMessage());
}
if (exceptionIfInvalid) {
@SuppressWarnings("rawtypes")
ConstraintViolationException summary = new ConstraintViolationException((Set) errors);
throw summary;
}
}
} catch (YAMLException e) {
if (exceptionIfInvalid) {
throw e;
}
logger.error("Failed to load YAML validation bean. Your YAML file may be invalid.", e);
}
}
public SockJsMessageCodec getMessageCodec() {
Assert.state(
this.messageCodec != null,
"A SockJsMessageCodec is required but not available: "
+ "Add Jackson 2 to the classpath, or configure a custom SockJsMessageCodec.");
return this.messageCodec;
}
public JobInstance createJobInstance(String jobName, final JobParameters jobParameters) {
Assert.notNull(jobName, "Job name must not be null.");
Assert.notNull(jobParameters, "JobParameters must not be null.");
Assert.state(
getJobInstance(jobName, jobParameters) == null, "JobInstance must not already exist");
Long jobId = getNextId(JobInstance.class.getSimpleName(), mongoTemplate);
JobInstance jobInstance = new JobInstance(jobId, jobName);
jobInstance.incrementVersion();
Map<String, JobParameter> jobParams = jobParameters.getParameters();
Map<String, Object> paramMap = new HashMap<String, Object>(jobParams.size());
for (Map.Entry<String, JobParameter> entry : jobParams.entrySet()) {
paramMap.put(
entry.getKey().replaceAll(DOT_STRING, DOT_ESCAPE_STRING), entry.getValue().getValue());
}
getCollection()
.save(
start()
.add(JOB_INSTANCE_ID_KEY, jobId)
.add(JOB_NAME_KEY, jobName)
.add(JOB_KEY_KEY, createJobKey(jobParameters))
.add(VERSION_KEY, jobInstance.getVersion())
.add(JOB_PARAMETERS_KEY, new BasicDBObject(paramMap))
.get());
return jobInstance;
}
@Override
public void applyPromotion(final Owner owner, final Bonus bonus) {
final Account account = accountService.findAccountByOwner(owner);
Assert.state(account != null, "account doesn't exist");
final double updatedBalance = account.getBalance() + bonus.getBonusAmount();
accountService.updateAccountBalance(account, updatedBalance);
}
@Override
public void afterPropertiesSet() throws Exception {
Assert.state(
getUri() != null,
"You need to configure a uri for the subversion repository (e.g. 'http://example.com/svn/')");
resolveRelativeFileUri();
}
protected final SubProtocolHandler findProtocolHandler(WebSocketSession session) {
String protocol = null;
try {
protocol = session.getAcceptedProtocol();
} catch (Exception ex) {
// Shouldn't happen
logger.error(
"Failed to obtain session.getAcceptedProtocol(). Will use the "
+ "default protocol handler (if configured).",
ex);
}
SubProtocolHandler handler;
if (!StringUtils.isEmpty(protocol)) {
handler = this.protocolHandlerLookup.get(protocol);
Assert.state(
handler != null, "No handler for '" + protocol + "' among " + this.protocolHandlerLookup);
} else {
if (this.defaultProtocolHandler != null) {
handler = this.defaultProtocolHandler;
} else if (this.protocolHandlers.size() == 1) {
handler = this.protocolHandlers.iterator().next();
} else {
throw new IllegalStateException(
"Multiple protocol handlers configured and "
+ "no protocol was negotiated. Consider configuring a default SubProtocolHandler.");
}
}
return handler;
}
/** Obtain a lazily initializted CachedIntrospectionResults instance for the wrapped object. */
private CachedIntrospectionResults getCachedIntrospectionResults() {
Assert.state(this.object != null, "BeanWrapper does not hold a bean instance");
if (this.cachedIntrospectionResults == null) {
this.cachedIntrospectionResults = CachedIntrospectionResults.forClass(getWrappedClass());
}
return this.cachedIntrospectionResults;
}
@Override
public void execute(Runnable task, long startTimeout) {
Assert.state(this.workManager != null, "No WorkManager specified");
Work work = new DelegatingWork(task);
try {
if (this.blockUntilCompleted) {
if (startTimeout != TIMEOUT_INDEFINITE || this.workListener != null) {
this.workManager.doWork(work, startTimeout, null, this.workListener);
} else {
this.workManager.doWork(work);
}
} else if (this.blockUntilStarted) {
if (startTimeout != TIMEOUT_INDEFINITE || this.workListener != null) {
this.workManager.startWork(work, startTimeout, null, this.workListener);
} else {
this.workManager.startWork(work);
}
} else {
if (startTimeout != TIMEOUT_INDEFINITE || this.workListener != null) {
this.workManager.scheduleWork(work, startTimeout, null, this.workListener);
} else {
this.workManager.scheduleWork(work);
}
}
} catch (WorkRejectedException ex) {
if (WorkException.START_TIMED_OUT.equals(ex.getErrorCode())) {
throw new TaskTimeoutException(
"JCA WorkManager rejected task because of timeout: " + task, ex);
} else {
throw new TaskRejectedException("JCA WorkManager rejected task: " + task, ex);
}
} catch (WorkException ex) {
throw new SchedulingException("Could not schedule task on JCA WorkManager", ex);
}
}
@Override
public void afterPropertiesSet() throws Exception {
// Check the signing and verification keys match
if (signer instanceof RsaSigner) {
RsaVerifier verifier;
try {
verifier = new RsaVerifier(verifierKey);
} catch (Exception e) {
logger.warn("Unable to create an RSA verifier from verifierKey");
return;
}
byte[] test = "test".getBytes();
try {
verifier.verify(test, signer.sign(test));
logger.info("Signing and verification RSA keys match");
} catch (InvalidSignatureException e) {
logger.error("Signing and verification RSA keys do not match");
}
} else {
// Avoid a race condition where verifier is set after signer to a different (possibly
// incompatible value)
Assert.state(
this.signingKey == this.verifierKey,
"For MAC signing you do not need to specify the verifier key separately, and if you do it must match the signing key");
}
}
protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
SpringApplicationBuilder builder = new SpringApplicationBuilder();
builder.main(getClass());
ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
if (parent != null) {
this.logger.info("Root context already created (using as parent).");
servletContext.setAttribute(
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
builder.initializers(new ParentContextApplicationContextInitializer(parent));
}
builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
builder = configure(builder);
SpringApplication application = builder.build();
if (application.getSources().isEmpty()
&& AnnotationUtils.findAnnotation(getClass(), Configuration.class) != null) {
application.getSources().add(getClass());
}
Assert.state(
application.getSources().size() > 0,
"No SpringApplication sources have been defined. Either override the "
+ "configure method or add an @Configuration annotation");
// Ensure error pages are registered
application.getSources().add(ErrorPageFilter.class);
return run(application);
}
@Override
@SuppressWarnings({"unchecked", "rawtypes"})
protected Tasklet createTasklet() {
Assert.state(getReader() != null, "ItemReader must be provided");
Assert.state(
getProcessor() != null || getWriter() != null,
"ItemWriter or ItemProcessor must be provided");
RepeatOperations repeatOperations = createRepeatOperations();
ChunkProvider<I> chunkProvider = new JsrChunkProvider<I>();
JsrChunkProcessor<I, O> chunkProcessor =
new JsrChunkProcessor(getReader(), getProcessor(), getWriter(), repeatOperations);
chunkProcessor.setListeners(new ArrayList<StepListener>(getItemListeners()));
ChunkOrientedTasklet<I> tasklet = new ChunkOrientedTasklet<I>(chunkProvider, chunkProcessor);
tasklet.setBuffering(!isReaderTransactionalQueue());
return tasklet;
}
/**
* Get a {@link PagingQueryProvider} instance using the provided properties and appropriate for
* the given database type.
*
* @see FactoryBean#getObject()
*/
@Override
public PagingQueryProvider getObject() throws Exception {
DatabaseType type;
try {
type =
databaseType != null
? DatabaseType.valueOf(databaseType.toUpperCase())
: DatabaseType.fromMetaData(dataSource);
} catch (MetaDataAccessException e) {
throw new IllegalArgumentException(
"Could not inspect meta data for database type. You have to supply it explicitly.", e);
}
AbstractSqlPagingQueryProvider provider = providers.get(type);
Assert.state(
provider != null,
"Should not happen: missing PagingQueryProvider for DatabaseType=" + type);
provider.setFromClause(fromClause);
provider.setWhereClause(whereClause);
provider.setSortKeys(sortKeys);
if (StringUtils.hasText(selectClause)) {
provider.setSelectClause(selectClause);
}
if (StringUtils.hasText(groupClause)) {
provider.setGroupClause(groupClause);
}
provider.init(dataSource);
return provider;
}
/**
* Will extract the payload from the Message and store it in the collection identified by the key
* (which may be determined by an expression). The type of collection is specified by the {@link
* #collectionType} property. The default CollectionType is LIST.
*
* <p>The rules for storing the payload are:
*
* <p><b>LIST/SET</b> If the payload is of type Collection and {@link #extractPayloadElements} is
* 'true' (default), the payload will be added using the addAll() method. If {@link
* #extractPayloadElements} is set to 'false', then regardless of the payload type, the payload
* will be added using add().
*
* <p><b>ZSET</b> In addition to the rules described for LIST/SET, ZSET allows 'score' information
* to be provided. The score can be provided using the {@link RedisHeaders#ZSET_SCORE} message
* header when the payload is not a Map, or by sending a Map as the payload where each Map 'key'
* is a value to be saved and each corresponding Map 'value' is the score assigned to it. If
* {@link #extractPayloadElements} is set to 'false' the map will be stored as a single entry. If
* the 'score' can not be determined, the default value (1) will be used.
*
* <p><b>MAP/PROPERTIES</b> You can also add items to a Map or Properties based store. If the
* payload itself is of type Map or Properties, it can be stored either as a batch or single item
* following the same rules as described above for other collection types. If the payload itself
* needs to be stored as a value of the map/property then the map key must be specified via the
* mapKeyExpression (default {@link RedisHeaders#MAP_KEY} Message header).
*/
@SuppressWarnings("unchecked")
@Override
protected void handleMessageInternal(Message<?> message) throws Exception {
String key = this.keyExpression.getValue(this.evaluationContext, message, String.class);
Assert.hasText(
key,
"Failed to determine a key for the Redis store using expression: "
+ this.keyExpression.getExpressionString());
RedisStore store = this.createStoreView(key);
Assert.state(
this.initialized,
"handler not initialized - afterPropertiesSet() must be called before the first use");
try {
if (collectionType == CollectionType.ZSET) {
this.writeToZset((RedisZSet<Object>) store, message);
} else if (collectionType == CollectionType.SET) {
this.writeToSet((RedisSet<Object>) store, message);
} else if (collectionType == CollectionType.LIST) {
this.writeToList((RedisList<Object>) store, message);
} else if (collectionType == CollectionType.MAP) {
this.writeToMap((RedisMap<Object, Object>) store, message);
} else if (collectionType == CollectionType.PROPERTIES) {
this.writeToProperties((RedisProperties) store, message);
}
} catch (Exception e) {
throw new MessageHandlingException(
message, "Failed to store Message data in Redis collection", e);
}
}
/**
* Internal version of getPropertyDescriptor: Returns null if not found rather than throwing an
* exception.
*/
protected PropertyDescriptor getPropertyDescriptorInternal(String propertyName)
throws BeansException {
Assert.state(this.object != null, "BeanWrapper does not hold a bean instance");
BeanWrapperImpl nestedBw = getBeanWrapperForPropertyPath(propertyName);
return nestedBw.cachedIntrospectionResults.getPropertyDescriptor(
getFinalPath(nestedBw, propertyName));
}
@SuppressWarnings("unchecked")
protected AbstractEndpoint doCreateEndpoint(
MessageHandler handler, MessageChannel inputChannel, List<Annotation> annotations) {
AbstractEndpoint endpoint;
if (inputChannel instanceof PollableChannel) {
PollingConsumer pollingConsumer =
new PollingConsumer((PollableChannel) inputChannel, handler);
configurePollingEndpoint(pollingConsumer, annotations);
endpoint = pollingConsumer;
} else {
Poller[] pollers =
MessagingAnnotationUtils.resolveAttribute(annotations, "poller", Poller[].class);
Assert.state(
ObjectUtils.isEmpty(pollers),
"A '@Poller' should not be specified for Annotation-based "
+ "endpoint, since '"
+ inputChannel
+ "' is a SubscribableChannel (not pollable).");
if (inputChannel instanceof Publisher) {
Subscriber<Message<?>> subscriber;
if (handler instanceof Subscriber) {
subscriber = (Subscriber<Message<?>>) handler;
} else {
// TODO errorConsumer, completeConsumer
DirectProcessor<Message<?>> directProcessor = DirectProcessor.create();
directProcessor.doOnNext(handler::handleMessage);
subscriber = directProcessor;
}
endpoint = new ReactiveConsumer(inputChannel, subscriber);
} else {
endpoint = new EventDrivenConsumer((SubscribableChannel) inputChannel, handler);
}
}
return endpoint;
}
public void afterPropertiesSet() throws Exception {
// Check the signing and verification keys match
if (signer instanceof RsaSigner) {
RsaVerifier verifier;
try {
verifier = new RsaVerifier(verifierKey);
} catch (Exception e) {
logger.warn("Unable to create an RSA verifier from verifierKey");
return;
}
byte[] test = "test".getBytes();
try {
verifier.verify(test, signer.sign(test));
logger.info("Signing and verification RSA keys match");
} catch (InvalidSignatureException e) {
logger.error("Signing and verification RSA keys do not match");
}
} else {
// Avoid a race condition where setters are called in the wrong order. Use of == is
// intentional.
Assert.state(
this.signingKey == this.verifierKey,
"For MAC signing you do not need to specify the verifier key separately, and if you do it must match the signing key");
}
SignatureVerifier verifier = new MacSigner(verifierKey);
try {
verifier = new RsaVerifier(verifierKey);
} catch (Exception e) {
logger.warn("Unable to create an RSA verifier from verifierKey");
}
this.verifier = verifier;
}