public static void syncWorkspaceFormatFromMaster() {
Hudson h = Hudson.getInstance();
if (h != null)
workspaceFormat =
h.getDescriptorByType(SubversionSCM.DescriptorImpl.class).getWorkspaceFormat();
else {
Channel c = Channel.current();
if (c != null) // just being defensive. cannot be null.
try {
workspaceFormat =
c.call(
new Callable<Integer, RuntimeException>() {
private static final long serialVersionUID = 6494337549896104453L;
public Integer call() {
return Hudson.getInstance()
.getDescriptorByType(SubversionSCM.DescriptorImpl.class)
.getWorkspaceFormat();
}
});
} catch (IOException e) {
LOGGER.log(Level.WARNING, "Failed to retrieve Subversion workspace format", e);
} catch (InterruptedException e) {
LOGGER.log(Level.WARNING, "Failed to retrieve Subversion workspace format", e);
}
}
}
private void replaceContent(IFile f, String content) {
try {
f.delete(true, new NullProgressMonitor());
} catch (CoreException ce) {
LOGGER.log(Level.WARNING, ce.getMessage(), ce);
}
InputStream is = null;
try {
is = EAPFromWSDLTest.class.getResourceAsStream(content);
f.create(is, true, new NullProgressMonitor());
} catch (CoreException ce) {
LOGGER.log(Level.WARNING, ce.getMessage(), ce);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException ioe) {
// ignore
}
}
}
try {
ResourcesPlugin.getWorkspace()
.getRoot()
.refreshLocal(IWorkspaceRoot.DEPTH_INFINITE, new NullProgressMonitor());
} catch (CoreException e) {
LOGGER.log(Level.WARNING, e.getMessage(), e);
}
util.waitForNonIgnoredJobs();
}
protected boolean verify(String hostname, SSLSession session, boolean interactive) {
LOGGER.log(
Level.FINE, "hostname verifier for " + hostname + ", trying default verifier first");
// if the default verifier accepts the hostname, we are done
if (defaultVerifier.verify(hostname, session)) {
LOGGER.log(Level.FINE, "default verifier accepted " + hostname);
return true;
}
// otherwise, we check if the hostname is an alias for this cert in our keystore
try {
X509Certificate cert = (X509Certificate) session.getPeerCertificates()[0];
// Log.d(TAG, "cert: " + cert);
if (cert.equals(appKeyStore.getCertificate(hostname.toLowerCase(Locale.US)))) {
LOGGER.log(Level.FINE, "certificate for " + hostname + " is in our keystore. accepting.");
return true;
} else {
LOGGER.log(
Level.FINE, "server " + hostname + " provided wrong certificate, asking user.");
if (interactive) {
return interactHostname(cert, hostname);
} else {
return false;
}
}
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/** {@inheritDoc } */
@Override
protected Map<String, String> toString(final Envelope env) {
final Map<String, String> map = new HashMap<String, String>();
final StringBuilder sb = new StringBuilder();
final double minx = env.getMinimum(0);
final double maxx = env.getMaximum(0);
final double miny = env.getMinimum(1);
final double maxy = env.getMaximum(1);
sb.append(minx).append(',').append(miny).append(',').append(maxx).append(',').append(maxy);
map.put("BBOX", sb.toString());
try {
String code = IdentifiedObjects.lookupIdentifier(env.getCoordinateReferenceSystem(), true);
if (code == null) {
code =
IdentifiedObjects.lookupIdentifier(
CRSUtilities.getCRS2D(env.getCoordinateReferenceSystem()), true);
}
map.put("CRS", code);
} catch (FactoryException ex) {
LOGGER.log(Level.WARNING, null, ex);
} catch (TransformException ex) {
LOGGER.log(Level.WARNING, null, ex);
}
encodeNDParameters(env, map);
return map;
}
private boolean runPolling() {
try {
// to make sure that the log file contains up-to-date text,
// don't do buffering.
StreamTaskListener listener = new StreamTaskListener(getLogFile());
try {
PrintStream logger = listener.getLogger();
long start = System.currentTimeMillis();
logger.println("Started on " + DateFormat.getDateTimeInstance().format(new Date()));
boolean result = job.poll(listener).hasChanges();
logger.println(
"Done. Took " + Util.getTimeSpanString(System.currentTimeMillis() - start));
if (result) logger.println("Changes found");
else logger.println("No changes");
return result;
} catch (Error e) {
e.printStackTrace(listener.error("Failed to record SCM polling"));
LOGGER.log(Level.SEVERE, "Failed to record SCM polling", e);
throw e;
} catch (RuntimeException e) {
e.printStackTrace(listener.error("Failed to record SCM polling"));
LOGGER.log(Level.SEVERE, "Failed to record SCM polling", e);
throw e;
} finally {
listener.close();
}
} catch (IOException e) {
LOGGER.log(Level.SEVERE, "Failed to record SCM polling", e);
return false;
}
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerJoin(final PlayerJoinEvent event)
{
final User user = ess.getUser(event.getPlayer());
if (!user.isJailed() || user.getJail() == null || user.getJail().isEmpty())
{
return;
}
try
{
sendToJail(user, user.getJail());
}
catch (Exception ex)
{
if (ess.getSettings().isDebug())
{
LOGGER.log(Level.INFO, _("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()), ex);
}
else
{
LOGGER.log(Level.INFO, _("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()));
}
}
user.sendMessage(_("jailMessage"));
}
public void run() {
try {
while (selectable) {
// The select() will be woke up if some new connection
// have occurred, or if the selector has been explicitly
// woke up
if (selector.select() > 0) {
Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
while (selectedKeys.hasNext()) {
SelectionKey key = selectedKeys.next();
selectedKeys.remove();
if (key.isValid()) {
EventHandler processor = ((EventHandler) key.attachment());
processor.process(key);
}
}
}
}
} catch (IOException ioe) {
LOGGER.log(Level.WARNING, "Error while waiting for events", ioe);
} finally {
if (selectable) {
LOGGER.log(
Level.WARNING, "Unexpected death of thread {0}", Thread.currentThread().getName());
} else {
LOGGER.log(
Level.FINE,
"Thread {0} termination initiated by call to AgentServer.close()",
Thread.currentThread().getName());
}
}
}
/** Called when a module build that corresponds to this module set build has completed. */
/* package */ void notifyModuleBuild(IvyBuild newBuild) {
try {
// update module set build number
getParent().updateNextBuildNumber();
// update actions
Map<IvyModule, List<IvyBuild>> moduleBuilds = getModuleBuilds();
// actions need to be replaced atomically especially
// given that two builds might complete simultaneously.
synchronized (this) {
boolean modified = false;
List<Action> actions = getActions();
Set<Class<? extends AggregatableAction>> individuals =
new HashSet<Class<? extends AggregatableAction>>();
for (Action a : actions) {
if (a instanceof IvyAggregatedReport) {
IvyAggregatedReport mar = (IvyAggregatedReport) a;
mar.update(moduleBuilds, newBuild);
individuals.add(mar.getIndividualActionType());
modified = true;
}
}
// see if the new build has any new aggregatable action that we
// haven't seen.
for (AggregatableAction aa : newBuild.getActions(AggregatableAction.class)) {
if (individuals.add(aa.getClass())) {
// new AggregatableAction
IvyAggregatedReport mar = aa.createAggregatedAction(this, moduleBuilds);
mar.update(moduleBuilds, newBuild);
actions.add(mar);
modified = true;
}
}
if (modified) {
save();
getProject().updateTransientActions();
}
}
// symlink to this module build
String moduleFsName = newBuild.getProject().getModuleName().toFileSystemName();
Util.createSymlink(
getRootDir(),
"../../modules/" + moduleFsName + "/builds/" + newBuild.getId() /*ugly!*/,
moduleFsName,
StreamTaskListener.NULL);
} catch (IOException e) {
LOGGER.log(Level.WARNING, "Failed to update " + this, e);
} catch (InterruptedException e) {
LOGGER.log(Level.WARNING, "Failed to update " + this, e);
}
}
protected UserDetails retrieveUser(
String username, UsernamePasswordAuthenticationToken authentication)
throws AuthenticationException {
try {
// this is more seriously error, indicating a failure to search
List<BadCredentialsException> errors = new ArrayList<BadCredentialsException>();
// this is lesser error, in that we searched and the user was not found
List<UsernameNotFoundException> notFound = new ArrayList<UsernameNotFoundException>();
for (String domainName : domainNames) {
try {
return retrieveUser(username, authentication, domainName);
} catch (UsernameNotFoundException e) {
notFound.add(e);
} catch (BadCredentialsException bce) {
LOGGER.log(
Level.WARNING,
"Credential exception trying to authenticate against " + domainName + " domain",
bce);
errors.add(bce);
}
}
switch (errors.size()) {
case 0:
break; // fall through
case 1:
throw errors.get(0); // preserve the original exception
default:
throw new MultiCauseBadCredentialsException(
"Either no such user '" + username + "' or incorrect password", errors);
}
if (notFound.size() == 1) throw notFound.get(0); // preserve the original exception
if (!Util.filter(notFound, UserMayOrMayNotExistException.class).isEmpty())
// if one domain responds with UserMayOrMayNotExistException, then it might actually exist
// there,
// so our response will be "can't tell"
throw new MultiCauseUserNotFoundException(
"We can't tell if the user exists or not: " + username, notFound);
if (!notFound.isEmpty())
throw new MultiCauseUserNotFoundException("No such user: "******"no domain is configured");
} catch (AuthenticationException e) {
LOGGER.log(Level.FINE, "Failed toretrieve user " + username, e);
throw e;
}
}
void deleteTask(String taskArn) {
final AmazonECSClient client = getAmazonECSClient();
LOGGER.log(Level.INFO, "Delete ECS Slave task: {0}", taskArn);
try {
client.stopTask(new StopTaskRequest().withTask(taskArn));
} catch (ClientException e) {
LOGGER.log(
Level.SEVERE,
"Couldn't stop task arn " + taskArn + " caught exception: " + e.getMessage(),
e);
}
}
protected void handle(
final String pathInContext,
final String pathParams,
final HttpRequest request,
final HttpResponse response,
final HttpFields trailer)
throws IOException {
NewObjectIdentifier identifier;
try {
identifier = getRequestIdentifier(request, response, trailer);
} catch (IllegalArgumentException e) {
// already sent error reply in superclass
return;
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine("deleting object with id " + identifier);
}
try {
handleDelete(request, response, identifier);
} catch (NoSuchObjectException e) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, "delete failed on NoSuchObjectException.", e);
}
sendError(response, trailer, HttpResponse.__404_Not_Found, e.getMessage());
} catch (ObjectLostException e) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, "delete failed on ObjectLostException.", e);
}
sendError(response, trailer, HttpResponse.__410_Gone, e.getMessage());
} catch (ArchiveException e) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, "delete failed on ArchiveException.", e);
}
sendError(response, trailer, HttpResponse.__400_Bad_Request, e.getMessage());
} catch (InternalException e) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, "delete failed on InternalException.", e);
}
sendError(response, trailer, HttpResponse.__500_Internal_Server_Error, e.getMessage());
} catch (IllegalArgumentException e) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING, "delete failed on IllegalArgumentException.", e);
}
sendError(response, trailer, HttpResponse.__400_Bad_Request, e.getMessage());
}
}
/**
* Check for the count of EC2 slaves and determine if a new slave can be added. Takes into account
* both what Amazon reports as well as an internal count of slaves currently being "provisioned".
* Check for the count of EC2 slaves and determine if a new slave can be added. Takes into account
* both what Amazon reports as well as an internal count of slaves currently being "provisioned".
*
* @param templateDesc
*/
private boolean addProvisionedSlave(String ami, int amiCap, String templateDesc)
throws AmazonClientException {
int estimatedTotalSlaves = countCurrentEC2Slaves(null, null);
int estimatedAmiSlaves = countCurrentEC2Slaves(ami, templateDesc);
synchronized (provisioningAmis) {
int currentProvisioning;
for (int amiCount : provisioningAmis.values()) {
estimatedTotalSlaves += amiCount;
}
try {
currentProvisioning = provisioningAmis.get(ami);
} catch (NullPointerException npe) {
currentProvisioning = 0;
}
estimatedAmiSlaves += currentProvisioning;
if (estimatedTotalSlaves >= instanceCap) {
LOGGER.log(
Level.INFO, "Total instance cap of " + instanceCap + " reached, not provisioning.");
return false; // maxed out
}
if (estimatedAmiSlaves >= amiCap) {
LOGGER.log(
Level.INFO,
"AMI Instance cap of " + amiCap + " reached for ami " + ami + ", not provisioning.");
return false; // maxed out
}
LOGGER.log(
Level.INFO,
"Provisioning for AMI "
+ ami
+ "; "
+ "Estimated number of total slaves: "
+ String.valueOf(estimatedTotalSlaves)
+ "; "
+ "Estimated number of slaves for ami "
+ ami
+ ": "
+ String.valueOf(estimatedAmiSlaves));
provisioningAmis.put(ami, currentProvisioning + 1);
return true;
}
}
/** Performs all monitoring concurrently. */
@Override
protected Map<Computer, T> monitor() throws InterruptedException {
Map<Computer, Future<T>> futures = new HashMap<Computer, Future<T>>();
for (Computer c : Jenkins.getInstance().getComputers()) {
try {
VirtualChannel ch = c.getChannel();
futures.put(c, null); // sentinel value
if (ch != null) {
Callable<T, ?> cc = createCallable(c);
if (cc != null) futures.put(c, ch.callAsync(cc));
}
} catch (RuntimeException e) {
LOGGER.log(
WARNING, "Failed to monitor " + c.getDisplayName() + " for " + getDisplayName(), e);
} catch (IOException e) {
LOGGER.log(
WARNING, "Failed to monitor " + c.getDisplayName() + " for " + getDisplayName(), e);
}
}
final long now = System.currentTimeMillis();
final long end = now + getMonitoringTimeOut();
final Map<Computer, T> data = new HashMap<Computer, T>();
for (Entry<Computer, Future<T>> e : futures.entrySet()) {
Computer c = e.getKey();
Future<T> f = futures.get(c);
data.put(c, null); // sentinel value
if (f != null) {
try {
data.put(c, f.get(Math.max(0, end - System.currentTimeMillis()), MILLISECONDS));
} catch (RuntimeException x) {
LOGGER.log(
WARNING, "Failed to monitor " + c.getDisplayName() + " for " + getDisplayName(), x);
} catch (ExecutionException x) {
LOGGER.log(
WARNING, "Failed to monitor " + c.getDisplayName() + " for " + getDisplayName(), x);
} catch (TimeoutException x) {
LOGGER.log(
WARNING, "Failed to monitor " + c.getDisplayName() + " for " + getDisplayName(), x);
}
}
}
return data;
}
@Override
public void mouseMoved(final MouseEvent e) {
if (coords.size() > 2) {
if (justCreated) {
coords.remove(coords.size() - 1);
coords.remove(coords.size() - 1);
coords.add(helper.toCoord(e.getX(), e.getY()));
coords.add(helper.toCoord(e.getX(), e.getY()));
} else {
coords.remove(coords.size() - 1);
coords.add(helper.toCoord(e.getX(), e.getY()));
}
erase = EditionHelper.createPolygon(coords);
final Geometry line = EditionHelper.createLinearRing(coords);
geometry =
(multipolygon) ? EditionHelper.createMultiPolygon(subGeometries) : subGeometries.get(0);
try {
geometry = geometry.difference(erase);
} catch (TopologyException ex) {
LOGGER.log(Level.INFO, ex.getLocalizedMessage());
}
decoration.setGeometries(UnmodifiableArrayList.wrap(new Geometry[] {geometry, line}));
return;
}
super.mouseMoved(e);
}
public void run() {
String threadName = Thread.currentThread().getName();
Thread.currentThread().setName("SCM polling for " + job);
try {
startTime = System.currentTimeMillis();
if (runPolling()) {
AbstractProject p = job.asProject();
String name = " #" + p.getNextBuildNumber();
SCMTriggerCause cause;
try {
cause = new SCMTriggerCause(getLogFile());
} catch (IOException e) {
LOGGER.log(WARNING, "Failed to parse the polling log", e);
cause = new SCMTriggerCause();
}
if (p.scheduleBuild(p.getQuietPeriod(), cause, additionalActions)) {
LOGGER.info("SCM changes detected in " + job.getName() + ". Triggering " + name);
} else {
LOGGER.info(
"SCM changes detected in " + job.getName() + ". Job is already in the queue");
}
}
} finally {
Thread.currentThread().setName(threadName);
}
}
/* (non-Javadoc)
* @see java.lang.Thread#run()
*/
public void run() {
try {
LOGGER.info("Start " + getName() + ", (running = " + running + ")");
while (running) {
try {
work();
} catch (Throwable t) {
if (running)
LOGGER.log(
Level.WARNING,
"Exception \"" + t + "\" in thread " + getName() + ": running=" + running,
t);
else
LOGGER.info(
"Exception \""
+ t
+ "\" in thread "
+ getName()
+ " has successfully stopped socket thread");
}
}
} finally {
LOGGER.info(getName() + " has terminated (running = " + running + ")");
}
}
public <T> List<ExtensionComponent<T>> findComponents(Class<T> type, Hudson hudson) {
List<ExtensionFinder> finders;
if (type==ExtensionFinder.class) {
// Avoid infinite recursion of using ExtensionFinders to find ExtensionFinders
finders = Collections.<ExtensionFinder>singletonList(new ExtensionFinder.Sezpoz());
} else {
finders = hudson.getExtensionList(ExtensionFinder.class);
}
/**
* See {@link ExtensionFinder#scout(Class, Hudson)} for the dead lock issue and what this does.
*/
if (LOGGER.isLoggable(Level.FINER))
LOGGER.log(Level.FINER,"Scout-loading ExtensionList: "+type, new Throwable());
for (ExtensionFinder finder : finders) {
finder.scout(type, hudson);
}
List<ExtensionComponent<T>> r = new ArrayList<ExtensionComponent<T>>();
for (ExtensionFinder finder : finders) {
try {
r.addAll(finder._find(type, hudson));
} catch (AbstractMethodError e) {
// backward compatibility
for (T t : finder.findExtensions(type, hudson))
r.add(new ExtensionComponent<T>(t));
}
}
return r;
}
private void scanFile(File log) {
LOGGER.fine("Scanning " + log);
BufferedReader r = null;
try {
r = new BufferedReader(new FileReader(log));
if (!findHeader(r)) return;
// we should find a memory mapped file for secret.key
String secretKey = getSecretKeyFile().getAbsolutePath();
String line;
while ((line = r.readLine()) != null) {
if (line.contains(secretKey)) {
files.add(new HsErrPidFile(this, log));
return;
}
}
} catch (IOException e) {
// not a big enough deal.
LOGGER.log(Level.FINE, "Failed to parse hs_err_pid file: " + log, e);
} finally {
IOUtils.closeQuietly(r);
}
}
public HsErrPidList() {
if (Functions.getIsUnitTest()) {
return;
}
try {
FileChannel ch = new FileInputStream(getSecretKeyFile()).getChannel();
map = ch.map(MapMode.READ_ONLY, 0, 1);
scan("./hs_err_pid%p.log");
if (Functions.isWindows()) {
File dir = Kernel32Utils.getTempDir();
if (dir != null) {
scan(dir.getPath() + "\\hs_err_pid%p.log");
}
} else {
scan("/tmp/hs_err_pid%p.log");
}
// on different platforms, rules about the default locations are a lot more subtle.
// check our arguments in the very end since this might fail on some platforms
JavaVMArguments args = JavaVMArguments.current();
for (String a : args) {
// see http://www.oracle.com/technetwork/java/javase/felog-138657.html
if (a.startsWith(ERROR_FILE_OPTION)) {
scan(a.substring(ERROR_FILE_OPTION.length()));
}
}
} catch (UnsupportedOperationException e) {
// ignore
} catch (Throwable e) {
LOGGER.log(Level.WARNING, "Failed to list up hs_err_pid files", e);
}
}
private void closeQuietly(DirContext context) {
try {
if (context != null) context.close();
} catch (NamingException e) {
LOGGER.log(Level.INFO, "Failed to close DirContext: " + context, e);
}
}
protected FormValidation doTestConnection(
URL ec2endpoint,
boolean useInstanceProfileForCredentials,
String accessId,
String secretKey,
String privateKey)
throws IOException, ServletException {
try {
AWSCredentialsProvider credentialsProvider =
createCredentialsProvider(useInstanceProfileForCredentials, accessId, secretKey);
AmazonEC2 ec2 = connect(credentialsProvider, ec2endpoint);
ec2.describeInstances();
if (privateKey == null)
return FormValidation.error(
"Private key is not specified. Click 'Generate Key' to generate one.");
if (privateKey.trim().length() > 0) {
// check if this key exists
EC2PrivateKey pk = new EC2PrivateKey(privateKey);
if (pk.find(ec2) == null)
return FormValidation.error(
"The EC2 key pair private key isn't registered to this EC2 region (fingerprint is "
+ pk.getFingerprint()
+ ")");
}
return FormValidation.ok(Messages.EC2Cloud_Success());
} catch (AmazonClientException e) {
LOGGER.log(Level.WARNING, "Failed to check EC2 credential", e);
return FormValidation.error(e.getMessage());
}
}
public void run() {
try {
parser = parser().parse();
} catch (Throwable t) {
LOGGER.log(Level.WARNING, "LD test failed", t);
}
}
@Override
public void onComplete(NbGradleModel model, Throwable error) {
loadedAtLeastOnceSignal.signal();
boolean hasChanged = false;
if (model != null) {
NbGradleModelRef newModel = new NbGradleModelRef(model);
NbGradleModelRef lastModel = currentModelRef.getAndSet(newModel);
hasChanged = !lastModel.isSameModel(newModel);
}
if (error != null) {
ProjectInfo.Entry entry =
new ProjectInfo.Entry(ProjectInfo.Kind.ERROR, NbStrings.getErrorLoadingProject(error));
getLoadErrorRef().setInfo(new ProjectInfo(Collections.singleton(entry)));
LOGGER.log(Level.INFO, "Error while loading the project model.", error);
displayError(NbStrings.getProjectLoadFailure(name), error, true);
} else {
getLoadErrorRef().setInfo(null);
}
if (hasChanged) {
if (model == null) {
notifyEmptyModelChange();
} else {
notifyModelChange(model);
}
}
}
public URL lookupBpmPlatformXmlFromCatalinaConfDirectory() {
// read file from CATALINA_BASE if set, otherwise CATALINA_HOME directory.
String catalinaHome = System.getProperty(CATALINA_BASE);
if (catalinaHome == null) {
catalinaHome = System.getProperty(CATALINA_HOME);
}
String bpmPlatformFileLocation =
catalinaHome + File.separator + "conf" + File.separator + BPM_PLATFORM_XML_FILE;
try {
URL fileLocation = checkValidFileLocation(bpmPlatformFileLocation);
if (fileLocation != null) {
LOGGER.log(
Level.INFO,
"Found camunda bpm platform configuration in CATALINA_BASE/CATALINA_HOME conf directory ["
+ bpmPlatformFileLocation
+ "] at "
+ fileLocation.toString());
}
return fileLocation;
} catch (MalformedURLException e) {
throw new ProcessEngineException(
"'"
+ bpmPlatformFileLocation
+ "' is not a valid camunda bpm platform configuration resource location.",
e);
}
}
/** Loads the other data from disk if it's available. */
private synchronized void load() {
properties.clear();
XmlFile config = getConfigFile();
try {
if (config.exists()) config.unmarshal(this);
} catch (IOException e) {
LOGGER.log(Level.SEVERE, "Failed to load " + config, e);
}
// remove nulls that have failed to load
for (Iterator<UserProperty> itr = properties.iterator(); itr.hasNext(); ) {
if (itr.next() == null) itr.remove();
}
// allocate default instances if needed.
// doing so after load makes sure that newly added user properties do get reflected
for (UserPropertyDescriptor d : UserProperty.all()) {
if (getProperty(d.clazz) == null) {
UserProperty up = d.newInstance(this);
if (up != null) properties.add(up);
}
}
for (UserProperty p : properties) p.setUser(this);
}
/** Retrieves the currently active singleton instance of {@link ConfidentialStore}. */
public static @Nonnull ConfidentialStore get() {
if (TEST != null) return TEST.get();
Jenkins j = Jenkins.getInstance();
if (j == null) {
throw new IllegalStateException(
"cannot initialize confidential key store until Jenkins has started");
}
Lookup lookup = j.lookup;
ConfidentialStore cs = lookup.get(ConfidentialStore.class);
if (cs == null) {
try {
List<ConfidentialStore> r =
(List)
Service.loadInstances(
ConfidentialStore.class.getClassLoader(), ConfidentialStore.class);
if (!r.isEmpty()) cs = r.get(0);
} catch (IOException e) {
LOGGER.log(Level.WARNING, "Failed to list up ConfidentialStore implementations", e);
// fall through
}
if (cs == null)
try {
cs = new DefaultConfidentialStore();
} catch (Exception e) {
// if it's still null, bail out
throw new Error(e);
}
cs = lookup.setIfNull(ConfidentialStore.class, cs);
}
return cs;
}
/** PENDING javadocs */
public void run() {
assert (monitors != null);
boolean reloaded = false;
for (Iterator<Monitor> i = monitors.iterator(); i.hasNext(); ) {
Monitor m = i.next();
try {
if (m.hasBeenModified()) {
if (!reloaded) {
reloaded = true;
}
}
} catch (IOException ioe) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.severe(
"Unable to access url "
+ m.uri.toString()
+ ". Monitoring for this resource will no longer occur.");
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, ioe.toString(), ioe);
}
i.remove();
}
}
if (reloaded) {
reload(sc);
}
}
public final boolean loadFrom(File source) {
if (source == null) {
throw new IllegalArgumentException(
"The file must not be null in order to load the reflected!");
}
if (source.exists()) {
I in = null;
try {
in = getCodec().newInput(source);
this.loadFrom(in);
} catch (IOException e) {
throw new IllegalArgumentException("File to load from cannot be accessed!", e);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
Reflector.LOGGER.log(WARNING, "Failed to close the input stream!", e);
}
}
}
this.onLoaded(source);
return true;
}
LOGGER.log(Level.INFO, "Could not load reflected from file! Using default...");
return false;
}
static List<SRS> buildCodeList() {
long t = System.currentTimeMillis();
Set<String> codes = CRS.getSupportedCodes("EPSG");
try {
codes.addAll(customFactory.getAuthorityCodes(CoordinateReferenceSystem.class));
} catch (FactoryException e) {
LOGGER.log(Level.WARNING, "Error occurred while trying to gather custom CRS codes", e);
}
// make a set with each code
Set<SRS> idSet = new HashSet<SRS>();
for (String code : codes) {
// make sure we're using just the non prefix part
String id = code.substring(code.indexOf(':') + 1);
// avoid WGS84DD and eventual friends, as we're still not able to handle them,
// if they are chosen exceptions arises everywhere
if (NUMERIC.matcher(id).matches()) {
idSet.add(new SRS(id));
}
}
List<SRS> srsList = new ArrayList<SRS>(idSet);
Collections.sort(srsList, new CodeComparator()); // sort to get them in order
return srsList;
}
/** Creates a hudson.PluginStrategy, looking at the corresponding system property. */
protected PluginStrategy createPluginStrategy() {
String strategyName = System.getProperty(PluginStrategy.class.getName());
if (strategyName != null) {
try {
Class<?> klazz = getClass().getClassLoader().loadClass(strategyName);
Object strategy = klazz.getConstructor(PluginManager.class).newInstance(this);
if (strategy instanceof PluginStrategy) {
LOGGER.info("Plugin strategy: " + strategyName);
return (PluginStrategy) strategy;
} else {
LOGGER.warning(
"Plugin strategy (" + strategyName + ") is not an instance of hudson.PluginStrategy");
}
} catch (ClassNotFoundException e) {
LOGGER.warning("Plugin strategy class not found: " + strategyName);
} catch (Exception e) {
LOGGER.log(
WARNING,
"Could not instantiate plugin strategy: "
+ strategyName
+ ". Falling back to ClassicPluginStrategy",
e);
}
LOGGER.info("Falling back to ClassicPluginStrategy");
}
// default and fallback
return new ClassicPluginStrategy(this);
}