} catch (final Exception e) {
                        logger.warn("Failed to install {}", filename, e);
                    } finally {
                        if (tempFile.exists() && !tempFile.delete()) {
                            logger.warn("Failed to delete {}.", tempFile.getAbsolutePath());
                        }
                    }
                }).start();

            } catch (RepositoryMetadataReadException e) {
                if (getLogger().isDebugEnabled()) {
                    getLogger().warn(e.getMessage(), e);
                } else {
                    getLogger().warn(e.getMessage());
                }
                return setRepository;
            }

            if (repoMetadata.isSnapshot() && (previousMetadata != null)) {

		dsc:    "arn:minio:replication::id:bucket=true;false;arn:minio:replication::id:bucket;id,arn:minio:replication::id2:bucket=false;true;arn:minio:replication::id2:bucket;id2",
		expErr: nil,
		expDsc: ReplicateDecision{
			targetsMap: map[string]replicateTargetDecision{
				"arn:minio:replication::id:bucket":  newReplicateTargetDecision("arn:minio:replication::id:bucket", true, false),

    }

    @Override
    public void warn(CharSequence content) {
        if (isWarnEnabled()) {
            logger.warn(toString(content));
        }
    }

    @Override
    public void warn(CharSequence content, Throwable error) {
        if (isWarnEnabled()) {
            logger.warn(toString(content), error);
        }
    }

    @Override
    public void warn(Throwable error) {
        logger.warn("", error);

                        logger.warn("  " + unsafeGoal.getId());
                    }
                } else {
                    logger.warn("The following plugins are not marked as thread-safe in " + project.getName() + ":");
                    for (Plugin unsafePlugin : unsafePlugins) {
                        logger.warn("  " + unsafePlugin.getId());
                    }
                    logger.warn("");

			}
		}
		sys.incTargetErr(bucket, arn)
	}()
	return nil
}

// GetRemoteBucketTargetByArn returns BucketTarget for a ARN
func (sys *BucketTargetSys) GetRemoteBucketTargetByArn(ctx context.Context, bucket, arn string) madmin.BucketTarget {
	sys.RLock()
	defer sys.RUnlock()
	var tgt madmin.BucketTarget
	for _, t := range sys.targetsMap[bucket] {
		if t.Arn == arn {
			tgt = t.Clone()

                searchEngineClient.admin().indices().prepareOpen(docIndex).execute(
                        ActionListener.wrap(res2 -> logger.info("Open {}", docIndex), e -> logger.warn("Failed to open {}", docIndex, e)));
            }, e -> logger.warn("Failed to close {}", docIndex, e)));
        });
        saveInfo(messages -> messages.addSuccessStartedDataUpdate(GLOBAL));
        return redirect(getClass());
    }

    /**
     * @return true if the <b>warn</b> error level is enabled
     */
    boolean isWarnEnabled();

    /**
     * Send a message to the user in the <b>warn</b> error level.
     *
     * @param content
     */
    void warn(CharSequence content);

    /**
     * Send a message (and accompanying exception) to the user in the <b>warn</b> error level.<br>

            } else if (response.getContentException() != null) {
                logger.warn("ConfigSync request failed.", response.getContentException());
            } else {
                logger.warn("ConfigSync request failed. The response is {}", response.getContentAsString());
            }
        } catch (final IOException e) {
            logger.warn("ConfigSync request failed.", e);
        }
        return new String[0];

                    }
                } catch (final Exception e) {
                    logger.warn("Failed to read a sugget elevate word: {}", list, e);
                }
            }
            searchEngineClient.refresh("_all"); // TODO replace _all
        } catch (final IOException e) {
            logger.warn("Failed to read a sugget elevate word.", e);
        }
    }