com.almende.eve.instantiation.InstantiationService Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of eve-bundle-android Show documentation
The newest version!
/*
 * Copyright: Almende B.V. (2014), Rotterdam, The Netherlands
 * License: The Apache Software License, Version 2.0
 */
package com.almende.eve.instantiation;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.almende.eve.capabilities.Capability;
import com.almende.eve.capabilities.handler.Handler;
import com.almende.eve.state.State;
import com.almende.eve.state.StateBuilder;
import com.almende.eve.state.StateConfig;
import com.almende.eve.state.StateService;
import com.almende.util.TypeUtil;
import com.almende.util.jackson.JOM;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.databind.node.ObjectNode;

/**
 * The Class InstantiationService.
 */
public class InstantiationService implements Capability {
	private static final Logger							LOG					= Logger.getLogger(InstantiationService.class
																					.getName());
	private static final TypeUtil	INSTANTIATIONENTRY	= new TypeUtil() {};
	private ObjectNode									myParams			= null;
	private String										myId				= null;
	private Map				entries				= new HashMap();
	private StateService								stateService		= null;
	private ClassLoader									cl					= null;

	/**
	 * Instantiates a new wake service.
	 */
	public InstantiationService() {};

	/**
	 * Instantiates a new InstantiationService.
	 *
	 * @param params
	 *            the params, containing at least a "state" field, with a
	 *            specific State configuration.
	 * @param cl
	 *            the cl
	 */
	public InstantiationService(final ObjectNode params, final ClassLoader cl) {
		this.cl = cl;
		myParams = params;
		final State state = new StateBuilder().withConfig(
				(ObjectNode) myParams.get("state")).build();
		stateService = state.getService();
		myId = state.getId();
		InstantiationServiceBuilder.getServices().put(myId, this);
		load();
	}

	@Override
	public void delete() {
		// TODO: clear out all state files
		final State state = new StateBuilder().withConfig(
				(ObjectNode) myParams.get("state")).build();
		if (state != null) {
			state.delete();
		}
	}

	/**
	 * Gets the my params.
	 * 
	 * @return the my params
	 */
	public ObjectNode getMyParams() {
		return myParams;
	}

	/**
	 * Sets the my params.
	 * 
	 * @param myParams
	 *            the new my params
	 */
	public void setMyParams(final ObjectNode myParams) {
		this.myParams = myParams;
		load();
	}

	/**
	 * Boot.
	 */
	@JsonIgnore
	public void boot() {
		load();
		for (final String key : entries.keySet()) {
			init(key, true);
		}
	}

	/**
	 * Exists.
	 *
	 * @param wakeKey
	 *            the wake key
	 * @return true, if successful
	 */
	public boolean exists(final String wakeKey) {
		return entries.containsKey(wakeKey);
	}

	/**
	 * Init a specific initable.
	 *
	 * @param wakeKey
	 *            the wake key
	 * @return the initable
	 */
	public Initable init(final String wakeKey) {
		return init(wakeKey, false);
	}

	/**
	 * Wake.
	 *
	 * @param wakeKey
	 *            the wake key
	 * @param onBoot
	 *            the on boot
	 * @return the initable
	 */
	@JsonIgnore
	public Initable init(final String wakeKey, final boolean onBoot) {
		InstantiationEntry entry = entries.get(wakeKey);
		if (entry == null) {
			entry = load(wakeKey);
			entries.put(wakeKey, entry);
		}
		if (entry != null) {
			final String className = entry.getClassName();
			Initable instance = null;
			Handler oldHandler = entry.getHandler();
			if (oldHandler != null) {
				instance = oldHandler.getNoWait();
			}
			if (instance == null) {
				try {
					Class clazz = null;
					if (cl != null) {
						clazz = cl.loadClass(className);
					} else {
						clazz = Class.forName(className);
					}
					instance = (Initable) clazz.newInstance();
					instance.init(entry.getParams(), onBoot);
				} catch (final Exception e) {
					LOG.log(Level.WARNING, "Failed to instantiate entry:'"
							+ wakeKey + "'", e);
				}
			}
			if (instance != null){
			    entry.setHandler(instance.getHandler());
			    if (oldHandler != null) {
				oldHandler.update(instance.getHandler());
			    }
			    entries.put(wakeKey, entry);
			}
			return instance;
		} else {
			LOG.warning("Sorry, I don't know any entry called:'" + wakeKey
					+ "'");
		}
		return null;
	}

	/**
	 * Register.
	 *
	 * @param wakeKey
	 *            the wake key
	 * @param className
	 *            the class name
	 */
	@JsonIgnore
	public void register(final String wakeKey, final String className) {
		final InstantiationEntry entry = new InstantiationEntry(wakeKey, null,
				className);
		entries.put(wakeKey, entry);
		store();
	}

	/**
	 * Register.
	 *
	 * @param wakeKey
	 *            the wake key
	 * @param params
	 *            the params
	 * @param className
	 *            the class name
	 */
	@JsonIgnore
	public void register(final String wakeKey, final ObjectNode params,
			final String className) {
		final InstantiationEntry entry = new InstantiationEntry(wakeKey,
				params, className);
		entries.put(wakeKey, entry);
		store(wakeKey, entry);
	}

	/**
	 * Deregister.
	 *
	 * @param wakeKey
	 *            the wake key
	 */
	public void deregister(final String wakeKey) {
		final InstantiationEntry entry = entries.remove(wakeKey);
		remove(wakeKey, entry);
	}

	/**
	 * Store.
	 *
	 * @param key
	 *            the key
	 * @param val
	 *            the val
	 */
	private void store(final String key, final InstantiationEntry val) {
		State innerState = null;
		if (val != null) {
			innerState = val.getState();
		}
		if (innerState == null) {
			innerState = new StateBuilder().withConfig(
					new StateConfig((ObjectNode) myParams.get("state")).put(
							"id", key)).build();
		}
		if (innerState != null) {
			innerState.put("entry", JOM.getInstance().valueToTree(val));
		}
	}

	/**
	 * Removes the specific state.
	 *
	 * @param key
	 *            the key
	 * @param val
	 *            the val
	 */
	private void remove(final String key, final InstantiationEntry val) {
		State innerState = null;
		if (val != null) {
			innerState = val.getState();
		}
		if (innerState == null) {
			innerState = new StateBuilder().withConfig(
					new StateConfig((ObjectNode) myParams.get("state")).put(
							"id", key)).build();
		}
		if (innerState != null) {
			innerState.delete();
		}
	}

	/**
	 * Load.
	 *
	 * @param key
	 *            the key
	 * @return the instantiation entry
	 */
	private InstantiationEntry load(final String key) {
		final State innerState = new StateBuilder().withConfig(
				new StateConfig((ObjectNode) myParams.get("state")).put("id",
						key)).build();
		final InstantiationEntry result = innerState.get("entry",
				INSTANTIATIONENTRY);
		if(result!=null) {
		    result.setState(innerState);
		}
		return result;
	}

	/**
	 * Store.
	 */
	private void store() {
		for (Entry entry : entries.entrySet()) {
			if (entry.getValue() != null) {
				store(entry.getKey(), entry.getValue());
			}
		}
	}

	/**
	 * Load.
	 */
	private void load() {
		final Set stateIds = stateService.getStateIds();
		for (String key : stateIds) {
			if (key.equals(myId)) {
				continue;
			}
			entries.put(key, null);
		}
	}

	/*
	 * (non-Javadoc)
	 * @see com.almende.eve.capabilities.Capability#getParams()
	 */
	@Override
	public ObjectNode getParams() {
		return myParams;
	}
}