/*
* Copyright 2010-2012 VMware and contributors
*
* Licensed 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 org.springsource.loaded;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Every reloadable hierarchy gets an Instance State Manager (ISMgr). The instance state manager is used to find the
* value of a field for a particular object instance. The manager is added to the top most type in a reloadable
* hierarchy and is accessible to all the subtypes. It maintains a map from types to secondary maps. The secondary maps
* record name,value pairs for each field. The maps are only used if something has happened to mean we cannot continue
* to store the values in the original fields.
*
* @author Andy Clement
* @since 0.5.0
*/
public class ISMgr {
private static Logger log = Logger.getLogger(ISMgr.class.getName());
Map<String, Map<String, Object>> values = new HashMap<String, Map<String, Object>>();
// TODO rtype in here means no need to have it on the getValue calls
public ISMgr(Object instance, ReloadableType rtype) {
// System.out.println("Instance passed to ISMgr " + instance + " rtype=" + rtype);
if (rtype.getTypeDescriptor().isGroovyType()) {
rtype.trackLiveInstance(instance);
}
}
/**
* Get the value of a instance field - this will use 'any means necessary' to get to it.
*
* @param rtype the reloadabletype
* @param instance the object instance on which the field is being accessed (whose type may not be that which
* declares the field)
* @param name the name of the field
*
* @return the value of the field
* @throws IllegalAccessException if there is a problem accessing the field
*/
public Object getValue(ReloadableType rtype, Object instance, String name) throws IllegalAccessException {
if (GlobalConfiguration.isRuntimeLogging && log.isLoggable(Level.FINER)) {
log.finer(">getValue(rtype=" + rtype + ",instance=" + instance + ",name=" + name + ")");
}
Object result = null;
// Quick look from here to top most reloadable type:
FieldMember field = rtype.findInstanceField(name);
if (field == null) {
// If the field is now null, there are two possible reasons:
// 1. The field does not exist in the hierarchy at all
// 2. The field is on a type just above our topmost reloadable type
FieldReaderWriter frw = rtype.locateField(name);
if (frw == null) {
// Used to be caused because we were not reloading constructors - so when a new version of the type was
// loaded, maybe a field was removed, but the constructor may still be referring to it. Should no longer
// happen but what about static initializers that aren't run straightaway?
log.info("Unexpectedly unable to locate instance field " + name + " starting from type "
+ rtype.dottedtypename
+ ": clinit running late?");
return null;
}
result = frw.getValue(instance, this);
}
else {
if (field.isStatic()) {
throw new IncompatibleClassChangeError("Expected non-static field " + rtype.dottedtypename + "."
+ field.getName());
}
String declaringTypeName = field.getDeclaringTypeName();
Map<String, Object> typeLevelValues = values.get(declaringTypeName);
boolean knownField = false;
if (typeLevelValues != null) {
knownField = typeLevelValues.containsKey(name);
}
if (knownField) {
result = typeLevelValues.get(name);
}
// If a field has been deleted it may 'reveal' a field in a supertype. The revealed field may be in a type
// not yet dealt with. In this case typeLevelValues may be null (type not seen before) or the typelevelValues
// may not have heard of our field name. In these cases we need to go and find the field and 'relocate' it
// into our map, where it will be processed from now on.
// These revealed fields are not necessarily in the original form of the type so cannot be accessed via reflection
if (typeLevelValues == null || !knownField) {
// Determine whether we need to use reflection or not:
// 'field' tells us if we know about it now, it doesn't tell us if we've always known about it
// TODO lookup performance
FieldMember fieldOnOriginalType = rtype.getTypeRegistry().getReloadableType(
field.getDeclaringTypeName())
.getTypeDescriptor().getField(name);
if (fieldOnOriginalType != null) {
// The field was on the original type, use reflection
ReloadableType rt = rtype.getTypeRegistry().getReloadableType(field.getDeclaringTypeName());
try {
Field f = rt.getClazz().getDeclaredField(name);
f.setAccessible(true);
result = f.get(instance);
if (typeLevelValues == null) {
typeLevelValues = new HashMap<String, Object>();
values.put(declaringTypeName, typeLevelValues);
}
typeLevelValues.put(name, result);
}
catch (Exception e) {
throw new IllegalStateException("Unexpectedly unable to access field " + name + " on type "
+ rt.getClazz().getName(), e);
}
}
else {
// The field was not on the original type. As not seen before, can default it
result = Utils.toResultCheckIfNull(null, field.getDescriptor());
if (typeLevelValues == null) {
typeLevelValues = new HashMap<String, Object>();
values.put(declaringTypeName, typeLevelValues);
}
typeLevelValues.put(name, result);
return result;
}
}
if (result != null) {
result = Utils.checkCompatibility(rtype.getTypeRegistry(), result, field.getDescriptor());
if (result == null) {
typeLevelValues.remove(field.getName());
}
}
result = Utils.toResultCheckIfNull(result, field.getDescriptor());
}
if (GlobalConfiguration.isRuntimeLogging && log.isLoggable(Level.FINER)) {
log.finer("<getValue() value of " + name + " is " + result);
}
return result;
}
/**
* Set the value of a field.
*
* @param rtype the reloadabletype
* @param instance the instance upon which to set the field
* @param value the value to put into the field
* @param name the name of the field
* @throws IllegalAccessException if there is a problem setting the field value
*/
public void setValue(ReloadableType rtype, Object instance, Object value, String name)
throws IllegalAccessException {
// System.err.println(">setValue(rtype=" + rtype + ",instance=" + instance + ",value=" + value + ",name=" + name + ")");
// Look up through our reloadable hierarchy to find it
FieldMember fieldmember = rtype.findInstanceField(name);
if (fieldmember == null) {
// If the field is null, there are two possible reasons:
// 1. The field does not exist in the hierarchy at all
// 2. The field is on a type just above our topmost reloadable type
FieldReaderWriter frw = rtype.locateField(name);
if (frw == null) {
// bad code redeployed?
log.info("Unexpectedly unable to locate instance field " + name + " starting from type "
+ rtype.dottedtypename
+ ": clinit running late?");
return;
}
frw.setValue(instance, value, this);
}
else {
if (fieldmember.isStatic()) {
throw new IncompatibleClassChangeError("Expected non-static field " + rtype.dottedtypename + "."
+ fieldmember.getName());
}
Map<String, Object> typeValues = values.get(fieldmember.getDeclaringTypeName());
if (typeValues == null) {
typeValues = new HashMap<String, Object>();
values.put(fieldmember.getDeclaringTypeName(), typeValues);
}
typeValues.put(name, value);
}
}
private String valuesToString() {
StringBuilder s = new StringBuilder();
s.append("InstanceState:" + System.identityHashCode(this)).append("\n");
for (Map.Entry<String, Map<String, Object>> entry : values.entrySet()) {
s.append("Type " + entry.getKey()).append("\n");
for (Map.Entry<String, Object> entry2 : entry.getValue().entrySet()) {
s.append(" " + entry2.getKey() + "=" + entry2.getValue()).append("\n");
}
}
return s.toString();
}
public String toString() {
return valuesToString();
}
Map<String, Map<String, Object>> getMap() {
return values;
}
}