jadex.bridge.service.component.ProvidedServicesComponentFeature Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jadex-platform-bridge Show documentation
Jadex bridge is a base package for kernels and platforms, i.e., it is used by both and provides commonly used interfaces and classes for active components and their management.
There is a newer version: 4.0.267
Show newest version
package jadex.bridge.service.component;

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;

import jadex.base.IPlatformConfiguration;
import jadex.base.Starter;
import jadex.bridge.IExternalAccess;
import jadex.bridge.IInternalAccess;
import jadex.bridge.ProxyFactory;
import jadex.bridge.component.ComponentCreationInfo;
import jadex.bridge.component.IExecutionFeature;
import jadex.bridge.component.impl.AbstractComponentFeature;
import jadex.bridge.modelinfo.ConfigurationInfo;
import jadex.bridge.modelinfo.UnparsedExpression;
import jadex.bridge.sensor.service.IMethodInvocationListener;
import jadex.bridge.service.BasicService;
import jadex.bridge.service.IInternalService;
import jadex.bridge.service.IService;
import jadex.bridge.service.IServiceIdentifier;
import jadex.bridge.service.ProvidedServiceImplementation;
import jadex.bridge.service.ProvidedServiceInfo;
import jadex.bridge.service.PublishInfo;
import jadex.bridge.service.RequiredServiceInfo;
import jadex.bridge.service.ServiceIdentifier;
import jadex.bridge.service.ServiceScope;
import jadex.bridge.service.annotation.Service;
import jadex.bridge.service.search.IServiceRegistry;
import jadex.bridge.service.search.ServiceNotFoundException;
import jadex.bridge.service.search.ServiceQuery;
import jadex.bridge.service.search.ServiceRegistry;
import jadex.bridge.service.types.library.ILibraryService;
import jadex.bridge.service.types.monitoring.IMonitoringService.PublishEventLevel;
import jadex.bridge.service.types.publish.IPublishService;
import jadex.commons.IValueFetcher;
import jadex.commons.MethodInfo;
import jadex.commons.SReflect;
import jadex.commons.SUtil;
import jadex.commons.future.DelegationResultListener;
import jadex.commons.future.ExceptionDelegationResultListener;
import jadex.commons.future.Future;
import jadex.commons.future.FutureBarrier;
import jadex.commons.future.IFuture;
import jadex.commons.future.IResultListener;
import jadex.commons.future.IntermediateEmptyResultListener;
import jadex.javaparser.SJavaParser;

/**
 *  Feature for provided services.
 */
public class ProvidedServicesComponentFeature extends AbstractComponentFeature implements IProvidedServicesFeature
{
	//-------- attributes --------
	
	/** The map of platform services. */
	protected Map, Collection> services;
	
	/** The map of provided service infos. (sid -> method listener) */
	protected Map servicelisteners;
	
	/** The map of provided service infos. (sid -> provided service info) */
	protected Map serviceinfos;
	
	//-------- constructors --------
	
	/**
	 *  Factory method constructor for instance level.
	 */
	public ProvidedServicesComponentFeature(IInternalAccess component, ComponentCreationInfo cinfo)
	{
		super(component, cinfo);
	}
	
	//-------- IComponentFeature interface / instance level --------
	
	/**
	 *  Initialize the feature.
	 */
	public IFuture	init()
	{
		final Future ret = new Future();
		
		// Collect provided services from model (name or type -> provided service info)
		ProvidedServiceInfo[] ps = component.getModel().getProvidedServices();
		Map sermap = new LinkedHashMap();
		for(int i=0; i args = getComponent().getInternalAccess().getArguments();
		Boolean extaarg = (Boolean)args.get("externalaccess");
		Boolean extaplatarg = (Boolean)((Map)Starter.getPlatformValue(getComponent().getId(), IPlatformConfiguration.PLATFORMARGS)).get("externalaccess");
		boolean on = extaarg!=null? extaarg.booleanValue(): extaplatarg!=null? extaplatarg.booleanValue(): true;
//			System.out.println("on: "+on+" "+extaarg+" "+extaplatarg);
		if(on)
		{
			ProvidedServiceImplementation impl = new ProvidedServiceImplementation();
			impl.setValue("$component.getExternalAccess()");
			// platform external access service will be published network wide, all others only on platform
			ProvidedServiceInfo psi= new ProvidedServiceInfo("externalaccessservice", IExternalAccess.class, impl, 
				getComponent().getId().equals(getComponent().getId().getRoot())? ServiceScope.NETWORK: ServiceScope.PLATFORM, null, null, null, null);
			sermap.put("externalaccessservice", psi);
		}
		
		FutureBarrier bar = new FutureBarrier<>();
		
		// Instantiate service objects
		for(ProvidedServiceInfo info: sermap.values())
		{
			// Evaluate and replace scope expression, if any.
			ServiceScope scope = info.getScope();
			if(ServiceScope.EXPRESSION.equals(scope))
			{
				scope = (ServiceScope)SJavaParser.getParsedValue(info.getScopeExpression(), component.getModel().getAllImports(), component.getFetcher(), component.getClassLoader());
				info = new ProvidedServiceInfo(info.getName(), info.getType(), info.getImplementation(), scope, info.getScopeExpression(), info.getSecurity(), info.getPublish(), info.getProperties(), info.isSystemService());
//				System.out.println("expression scope '"
//					+ (info.getScopeExpression()!=null ? info.getScopeExpression().getValue() : "")
//					+ "': "+scope);
			}
				
			final Future fut = new Future<>();
			bar.addFuture(fut);
			
			final ProvidedServiceImplementation	impl = info.getImplementation();
			// Virtual service (e.g. promoted)
			if(impl!=null && impl.getBinding()!=null)
			{
				RequiredServiceInfo rsi = new RequiredServiceInfo(BasicService.generateServiceName(info.getType().getType( 
					component.getClassLoader(), component.getModel().getAllImports()))+":virtual", info.getType().getType(component.getClassLoader(), component.getModel().getAllImports()));
				IServiceIdentifier sid = BasicService.createServiceIdentifier(component, 
					rsi.getName(), rsi.getType().getType(component.getClassLoader(), component.getModel().getAllImports()),
					BasicServiceInvocationHandler.class, component.getModel().getResourceIdentifier(), info);
				final IInternalService service = BasicServiceInvocationHandler.createDelegationProvidedServiceProxy(
					component, sid, rsi, impl.getBinding(), component.getClassLoader(), Starter.isRealtimeTimeout(component.getId(), true));
				
				addService(service, info);
				fut.setResult(null);
			}
			else
			{
				final ProvidedServiceInfo finfo = info;
				createServiceImplementation(info, getComponent().getFetcher())
					.then(ser ->
				{
					// Implementation may null to disable service in some configurations.
					if(ser!=null)
					{
						UnparsedExpression[] ins = finfo.getImplementation().getInterceptors();
						IServiceInvocationInterceptor[] ics = null;
						if(ins!=null)
						{
							ics = new IServiceInvocationInterceptor[ins.length];
							for(int i=0; i0)
								{
									ics[i] = (IServiceInvocationInterceptor)SJavaParser.evaluateExpression(ins[i].getValue(), component.getModel().getAllImports(), component.getFetcher(), component.getClassLoader());
								}
								else
								{
									try
									{
										ics[i] = (IServiceInvocationInterceptor)ins[i].getClazz().getType(component.getClassLoader(), component.getModel().getAllImports()).newInstance();
									}
									catch(Exception e)
									{
										e.printStackTrace();
									}
								}
							}
						}
						
						final Class type = finfo.getType().getType(component.getClassLoader(), component.getModel().getAllImports());
						PublishEventLevel elm = component.getDescription().getMonitoring()!=null? component.getDescription().getMonitoring(): null;
//						 todo: remove this? currently the level cannot be turned on due to missing interceptor
						boolean moni = elm!=null? !PublishEventLevel.OFF.equals(elm.getLevel()): false; 
						final IInternalService proxy = BasicServiceInvocationHandler.createProvidedServiceProxy(
							component, ser, finfo.getName(), type, ics,
							moni, finfo);
						
						addService(proxy, finfo);
					}
					fut.setResult(null);
					
				}).catchEx(e -> {e.printStackTrace(); fut.setResult(null);});
			}
		}
		
		bar.waitFor().then(v ->
		{
			// Start the services.
			Collection allservices = getAllServices();
			if(!allservices.isEmpty())
			{
				initServices(allservices.iterator()).addResultListener(new DelegationResultListener(ret));
			}
			else
			{
				ret.setResult(null);
			}
		}).catchEx(ret);
		
		return ret;
	}
	
	/**
	 *  Check if the feature potentially executed user code in body.
	 *  Allows blocking operations in user bodies by using separate steps for each feature.
	 *  Non-user-body-features are directly executed for speed.
	 *  If unsure just return true. ;-)
	 */
	public boolean	hasUserBody()
	{
		return false;
	}
	
	/**
	 *  Called when the feature is shutdowned.
	 */
	public IFuture shutdown()
	{
		Future ret = new Future();
		
		// Shutdown the services.
		Collection allservices = getAllServices();
		if(!allservices.isEmpty())
		{
			LinkedList list = new LinkedList(allservices);
			shutdownServices(list.descendingIterator()).addResultListener(new DelegationResultListener(ret));
		}
		else
		{
			ret.setResult(null);
		}
		
		return ret;
	}
	
	/**
	 *  Add a service.
	 *  @param service	The service object.
	 *  @param info	 The service info.
	 */
	protected void addService(IInternalService service, ProvidedServiceInfo info)
	{
		if(serviceinfos==null)
			serviceinfos = new HashMap();
		serviceinfos.put(service.getServiceId(), info);
		
		// Find service types
//		Class	type	= info.getType().getType(component.getClassLoader(), component.getModel().getAllImports());
		Class	type	= service.getServiceId().getServiceType().getType(component.getClassLoader(), component.getModel().getAllImports());
		Set> types = new LinkedHashSet>();
		types.add(type);
		for(Class sin: SReflect.getSuperInterfaces(new Class[]{type}))
		{
			if(sin.isAnnotationPresent(Service.class))
			{
				types.add(sin);
			}
		}

		if(services==null)
			services = Collections.synchronizedMap(new LinkedHashMap, Collection>());
		
//		return ServiceRegistry.getRegistry(component.getComponentIdentifier()).addService(service);
		
//		FutureBarrier bar = new FutureBarrier();
		
		for(Class servicetype: types)
		{
			Collection tmp = services.get(servicetype);
			if(tmp==null)
			{
				tmp = Collections.synchronizedList(new ArrayList());
				services.put(servicetype, tmp);
			}
			tmp.add(service);
			
			// Make service available immediately, even before start (hack???).
//			bar.addFuture(SynchronizedServiceRegistry.getRegistry(component.getComponentIdentifier()).addService(new ClassInfo(servicetype), service));
		}
		
		ServiceRegistry.getRegistry(component.getId()).addLocalService(service);
		//System.out.println("added service: "+component.getId()+" "+service.getServiceId());
//		return bar.waitFor();
	}
	
	/**
	 *  Get the provided service info for a service.
	 *  @param sid The service identifier.
	 *  @return The provided service info.
	 */
	protected ProvidedServiceInfo getProvidedServiceInfo(IServiceIdentifier sid)
	{
		return serviceinfos.get(sid);
	}
	
	/**
	 *  Remove a service.
	 *  @param service	The service object.
	 *  @param info	 The service info.
	 */
	protected void	removeService(IInternalService service)
	{
		IServiceRegistry	registry	= ServiceRegistry.getRegistry(component.getId());
		
		if(registry!=null) // Maybe null on rescue thread (todo: why remove() on rescue thread?)
		{
			registry.removeService(service.getServiceId());
		}
	}
	
	/**
	 *  Create a service implementation from description.
	 */
	public IFuture