/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2012 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.enterprise.resource.deployer;
import com.sun.appserv.connectors.internal.api.ConnectorsUtil;
import com.sun.enterprise.config.serverbeans.Resource;
import com.sun.enterprise.config.serverbeans.Resources;
import com.sun.enterprise.deployment.AdministeredObjectDefinitionDescriptor;
import com.sun.logging.LogDomains;
import org.glassfish.connectors.config.AdminObjectResource;
import org.glassfish.resourcebase.resources.api.ResourceConflictException;
import org.glassfish.resourcebase.resources.api.ResourceDeployer;
import org.glassfish.resourcebase.resources.api.ResourceDeployerInfo;
import org.glassfish.resourcebase.resources.util.ResourceManagerFactory;
import org.jvnet.hk2.annotations.Service;
import org.jvnet.hk2.config.ConfigBeanProxy;
import org.jvnet.hk2.config.TransactionFailure;
import org.jvnet.hk2.config.types.Property;
import javax.inject.Inject;
import javax.inject.Provider;
import java.beans.PropertyVetoException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* @author Dapeng Hu
*/
@Service
@ResourceDeployerInfo(AdministeredObjectDefinitionDescriptor.class)
public class AdministeredObjectDefinitionDeployer implements ResourceDeployer {
@Inject
private Provider<ResourceManagerFactory> resourceManagerFactoryProvider;
private static Logger _logger = LogDomains.getLogger(AdministeredObjectDefinitionDeployer.class, LogDomains.RSR_LOGGER);
final static String PROPERTY_PREFIX = "org.glassfish.admin-object.";
public void deployResource(Object resource, String applicationName, String moduleName) throws Exception {
//TODO ASR
}
public void deployResource(Object resource) throws Exception {
final AdministeredObjectDefinitionDescriptor desc = (AdministeredObjectDefinitionDescriptor) resource;
String resourceName = ConnectorsUtil.deriveResourceName(desc.getResourceId(), desc.getName(), desc.getResourceType());
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "AdministeredObjectDefinitionDeployer.deployResource() : resource-name ["+resourceName+"]");
}
//deploy resource
MyAdministeredObjectResource adminObjectResource = new MyAdministeredObjectResource(desc, resourceName);
getDeployer(adminObjectResource).deployResource(adminObjectResource);
}
/**
* {@inheritDoc}
*/
public boolean canDeploy(boolean postApplicationDeployment, Collection<Resource> allResources, Resource resource){
if(handles(resource)){
if(!postApplicationDeployment){
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*/
public void validatePreservedResource(com.sun.enterprise.config.serverbeans.Application oldApp,
com.sun.enterprise.config.serverbeans.Application newApp,
Resource resource,
Resources allResources)
throws ResourceConflictException {
//do nothing.
}
private ResourceDeployer getDeployer(Object resource) {
return resourceManagerFactoryProvider.get().getResourceDeployer(resource);
}
private AdministeredObjectProperty convertProperty(String name, String value) {
return new AdministeredObjectProperty(name, value);
}
public void undeployResource(Object resource, String applicationName, String moduleName) throws Exception {
//TODO ASR
}
public void undeployResource(Object resource) throws Exception {
final AdministeredObjectDefinitionDescriptor desc = (AdministeredObjectDefinitionDescriptor) resource;
String resourceName = ConnectorsUtil.deriveResourceName(desc.getResourceId(), desc.getName(), desc.getResourceType());
if(_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "AdministeredObjectDefinitionDeployer.undeployResource() : resource-name ["+resourceName+"]");
}
//undeploy resource
MyAdministeredObjectResource adminObjectResource = new MyAdministeredObjectResource(desc, resourceName);
getDeployer(adminObjectResource).undeployResource(adminObjectResource);
}
public void redeployResource(Object resource) throws Exception {
throw new UnsupportedOperationException("redeploy() not supported for administered-object-definition type");
}
public void enableResource(Object resource) throws Exception {
throw new UnsupportedOperationException("enable() not supported for administered-object-definition type");
}
public void disableResource(Object resource) throws Exception {
throw new UnsupportedOperationException("disable() not supported for administered-object-definition type");
}
public boolean handles(Object resource) {
return resource instanceof AdministeredObjectDefinitionDescriptor;
}
/**
* @inheritDoc
*/
public boolean supportsDynamicReconfiguration() {
return false;
}
/**
* @inheritDoc
*/
@SuppressWarnings("rawtypes")
public Class[] getProxyClassesForDynamicReconfiguration() {
return new Class[0];
}
abstract class FakeConfigBean implements ConfigBeanProxy {
public ConfigBeanProxy deepCopy(ConfigBeanProxy parent) {
throw new UnsupportedOperationException();
}
public ConfigBeanProxy getParent() {
return null;
}
public <T extends ConfigBeanProxy> T getParent(Class<T> tClass) {
return null;
}
public <T extends ConfigBeanProxy> T createChild(Class<T> tClass) throws TransactionFailure {
return null;
}
}
class AdministeredObjectProperty extends FakeConfigBean implements Property {
private String name;
private String value;
private String description;
AdministeredObjectProperty(String name, String value) {
this.name = name;
this.value = value;
}
public String getName() {
return name;
}
public void setName(String value) throws PropertyVetoException {
this.name = value;
}
public String getValue() {
return value;
}
public void setValue(String value) throws PropertyVetoException {
this.value = value;
}
public String getDescription() {
return description;
}
public void setDescription(String value) throws PropertyVetoException {
this.description = value;
}
public void injectedInto(Object o) {
//do nothing
}
}
class MyAdministeredObjectResource extends FakeConfigBean implements AdminObjectResource {
private AdministeredObjectDefinitionDescriptor desc;
private String name;
public MyAdministeredObjectResource(AdministeredObjectDefinitionDescriptor desc, String name) {
this.desc = desc;
this.name = name;
}
@Override
public String getObjectType() {
return "user"; //To change body of implemented methods use File | Settings | File Templates.
}
@Override
public void setObjectType(String value) throws PropertyVetoException {
//To change body of implemented methods use File | Settings | File Templates.
}
public String getIdentity() {
return name;
}
public String getResAdapter() {
String resourceAdapterName = desc.getResourceAdapterName();
if (resourceAdapterName != null && !resourceAdapterName.equals("")) {
return resourceAdapterName;
}else{
return null;
}
}
public void setResAdapter(String value) throws PropertyVetoException {
//do nothing
}
public String getDescription() {
return desc.getDescription();
}
public void setDescription(String value) throws PropertyVetoException {
//do nothing
}
@Override
public String getJndiName() {
return name;
}
@Override
public void setJndiName(String value) throws PropertyVetoException {
//do nothing
}
@Override
public String getResType() {
String resType = desc.getProperty(PROPERTY_PREFIX+"resType");
if(resType!=null && !resType.equals("")){
return resType;
}else{
return null;
}
}
@Override
public void setResType(String value) throws PropertyVetoException {
//do nothing
}
@Override
public String getClassName() {
return desc.getClassName();
}
@Override
public void setClassName(String value) throws PropertyVetoException {
//do nothing
}
@Override
public String getEnabled() {
return "true";
}
@Override
public void setEnabled(String value) throws PropertyVetoException {
//do nothing
}
public List<Property> getProperty() {
Properties p = desc.getProperties();
List<Property> administeredObjectProperties = new ArrayList<Property>();
for (Entry<Object, Object> entry : p.entrySet()) {
String key = (String) entry.getKey();
if(key.startsWith(PROPERTY_PREFIX)){
continue;
}
String value = (String) entry.getValue();
AdministeredObjectProperty dp = convertProperty(key, value);
administeredObjectProperties.add(dp);
}
return administeredObjectProperties;
}
public Property getProperty(String name) {
String value = desc.getProperty(name);
return new AdministeredObjectProperty(name, value);
}
public String getPropertyValue(String name) {
return desc.getProperty(name);
}
public String getPropertyValue(String name, String defaultValue) {
String value = null;
value = desc.getProperty(name);
if (value != null) {
return value;
} else {
return defaultValue;
}
}
public void injectedInto(Object o) {
//do nothing
}
}
}