/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.sun.jini.start;
import com.sun.jini.start.SharedActivatableServiceDescriptor.Created;
import net.jini.config.Configuration;
import net.jini.config.ConfigurationProvider;
import net.jini.config.ConfigurationException;
import java.io.File;
import java.rmi.activation.ActivationSystem;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
import javax.security.auth.Subject;
import com.sun.jini.system.FileSystem;
/**
* This class contains the command-line interface for
* destroying an instance of a shared activation group.
*
* The following items are discussed below:
*
*
*
* Configuring DestroySharedGroup
*
*
* This implementation of DestroySharedGroup supports the
* following configuration entries, with component
* com.sun.jini.start:
*
*
*
* | •
* |
* activationSystemPreparer
* |
| |
* Type: | {@link net.jini.security.ProxyPreparer}
* |
| |
* Default: |
* new {@link net.jini.security.BasicProxyPreparer}()
* |
| |
* Description: | The proxy preparer for the proxy for the
* activation system. The value should not be null. This
* entry is obtained at service start and restart. This entry is only
* used by the activatable implementation.
*
* The service calls the {@link
* java.rmi.activation.ActivationSystem#unregisterObject
* unregisterObject} method on the {@link
* java.rmi.activation.ActivationSystem} when there is a problem
* creating a service.
* |
*
*
*
* | •
* |
* loginContext
* |
| |
* Type: | {@link javax.security.auth.login.LoginContext}
* |
| |
* Default: | null
* |
| |
* Description: | If not null, specifies the JAAS
* login context to use for performing a JAAS login and supplying the
* {@link javax.security.auth.Subject} to use when running the
* services starter. If null, no JAAS login is performed.
* |
*
*
*
* | •
* |
* serviceDestructors
* |
| |
* Type: | {@link ServiceDescriptor}[]
* |
| |
* Default: no default
* |
| |
* Description: | Array of service descriptors to start.
* |
*
*
*
*Loggers and Logging Levels
*
*
*The DestroySharedGroup service implementation uses the {@link
*java.util.logging.Logger}, named
* com.sun.jini.start.service.starter.
*The following table describes the
*type of information logged as well as the levels of information logged.
*
*
*
*
*
* com.sun.jini.start.service.starter
*
* | Level | Description
*
* |
| {@link java.util.logging.Level#SEVERE SEVERE} |
* for problems that prevent service destruction from proceeding
* |
| {@link java.util.logging.Level#WARNING WARNING} |
* for problems with service destruction that don't prevent further
* processing
* |
| {@link java.util.logging.Level#FINER FINER} |
* for high level
* service destruction operation tracing
* |
| {@link java.util.logging.Level#FINEST FINEST} |
* for low level
* service destruction operation tracing
*
* |
*
*
*
* @see com.sun.jini.start.ServiceStarter
*
* @since 1.2
*/
public class DestroySharedGroup {
/** Configure logger. */
private static final Logger logger = ServiceStarter.logger;
// Private constructor to prevent instantiation
private DestroySharedGroup() { }
/**
* The main method for the DestroySharedGroup application.
* The args parameter is passed directly to
* ConfigurationProvider.getInstance() in order to
* obtain a Configuration object. This configuration
* object is then queried for a
* com.sun.jini.start.serviceDestructors entry, which
* is assumed to be a SharedActivatableServiceDescriptor[]
* configured to run {@link com.sun.jini.start.SharedGroup} implementations.
* The {@link com.sun.jini.start.SharedGroup#destroyVM() destroyVM()}
* method is then called on each of the array elements. An attempt is
* made to also delete shared group log directory associated
* with each array element.
* @param args String[] passed to
* ConfigurationProvider.getInstance() in order
* to obtain a Configuration object.
*
* @see ServiceDescriptor
* @see SharedActivatableServiceDescriptor
* @see net.jini.config.Configuration
* @see net.jini.config.ConfigurationProvider
*
*/
public static void main(String[] args) {
ServiceStarter.ensureSecurityManager();
logger.entering(DestroySharedGroup.class.getName(), "main",
((Object[])args));
try {
Configuration config = ConfigurationProvider.getInstance(args);
ServiceDescriptor[] srvArray =
(ServiceDescriptor[])config.getEntry(
ServiceStarter.START_PACKAGE, "serviceDestructors",
ServiceDescriptor[].class, null);
if (srvArray == null || srvArray.length == 0) {
logger.log(Level.WARNING, "service.config.empty");
return;
}
LoginContext loginContext = (LoginContext)
config.getEntry(ServiceStarter.START_PACKAGE, "loginContext",
LoginContext.class, null);
if (loginContext != null)
destroyWithLogin(srvArray, config, loginContext);
else
destroy(srvArray, config);
} catch (ConfigurationException ce) {
logger.log(Level.SEVERE, "destroy.config.exception", ce);
} catch (Exception e) {
logger.log(Level.SEVERE, "destroy.unexpected.exception", e);
}
logger.exiting(DestroySharedGroup.class.getName(), "main");
}
/**
* Method that attempts to destroy any available SharedGroup
* objects in the provided ServiceDescriptor[].
*/
private static void destroy(ServiceDescriptor[] srvArray,
Configuration config) throws Exception
{
logger.entering(DestroySharedGroup.class.getName(), "destroy",
new Object[] {Arrays.asList(srvArray), config} );
Created created = null;
SharedActivatableServiceDescriptor desc = null;
ActivationSystem activationSystem = null;
for (int i=0; i < srvArray.length; i++) {
if (srvArray[i] instanceof SharedActivatableServiceDescriptor) {
desc = (SharedActivatableServiceDescriptor)srvArray[i];
activationSystem =
ServiceStarter.getActivationSystem(
desc.getActivationSystemHost(),
desc.getActivationSystemPort(),
config);
try {
created = (Created)desc.create(config);
if (created != null &&
created.proxy instanceof SharedGroup) {
// service proxy from create() is already prepared
SharedGroup sg = (SharedGroup)created.proxy;
try {
sg.destroyVM();
try {
File log = new File(desc.getSharedGroupLog());
FileSystem.destroy(log, true);
} catch (Exception e) {
logger.log(Level.WARNING,
"destroy.group.deletion", e);
}
} catch (Exception e ) {
logger.log(Level.SEVERE,
"destroy.group.exception", e);
//TODO - Add configurable retry logic or just unregister
}
} else {
logger.log(Level.WARNING, "destroy.unexpected.proxy",
(created==null)?null:created.proxy);
if (created != null && created.aid != null) {
try {
activationSystem.unregisterObject(created.aid);
} catch (Exception e) {
logger.log(Level.WARNING,
"destroy.unregister.exception", e) ;
}
}
}
} catch (Exception ee) {
logger.log(Level.SEVERE, "destroy.creation.exception", ee);
if (created != null && created.aid != null) {
try {
activationSystem.unregisterObject(created.aid);
} catch (Exception e) {
logger.log(Level.WARNING,
"destroy.unregister.exception", ee) ;
}
}
}
} else {
logger.log(Level.WARNING, "destroy.unexpected.type", srvArray[i]);
}
}
logger.exiting(DestroySharedGroup.class.getName(), "destroy");
}
/**
* Method that attempts to login via the provided
* LoginContext and then calls destroy.
*/
private static void destroyWithLogin(
final ServiceDescriptor[] descs, final Configuration config,
final LoginContext loginContext) throws Exception
{
logger.entering(DestroySharedGroup.class.getName(),
"destroyWithLogin", new Object[] {descs, config, loginContext});
loginContext.login();
try {
Subject.doAsPrivileged(
loginContext.getSubject(),
new PrivilegedExceptionAction() {
public Object run() throws Exception
{
destroy(descs, config);
return null;
}
},
null);
} catch (PrivilegedActionException e) {
throw e.getException();
} finally {
try {
loginContext.logout();
} catch (LoginException le) {
logger.log(Level.FINE, "service.logout.exception", le);
}
}
logger.exiting(DestroySharedGroup.class.getName(),
"destroyWithLogin");
return;
}
}