Hello Igniters, I have plans to implement service invocation in thin clients. I've already implemented a PoC for java thin client and want to discuss some details. Also, Pavel Tupitsin has created IEP [1] and the ticket for .Net thin client [2].
To invoke the service method by java thick client we can get service proxy by: IgniteServices.serviceProxy(String name, Class<? super T> svcItf, boolean sticky, long timeout) and then invoke the method on this proxy. Also, we already have service invocation functionality for .Net thick client (see PlatformServices class). For .Net thick client there are two types of operation related to service invocation: create a proxy and invoke a method (this approach is identical to java thick client). But I think we can't use two operations for thin clients. If we create a proxy by a separate operation we should store this resource somewhere on server-side and we should also have an ability to close this resource when it's not needed anymore. So there is an additional operation on client-side needed to close the proxy explicitly. This is more complex from users point of view than the current approach for java thick client, so I think it's better to use only one operation for thin clients: OP_SERVICE_INVOKE and create a service proxy on each method invocation. In this case, each request should have at least these parameters: service name, interface name, timeout, nodes set, method name, and args (sticky flag is useless since we always will create a new proxy for each request). There is one more problem: methods of some interface can be overloaded. In .Net thick client implementation there is a method used to find an appropriate service method to invoke by method name and args values: PlatformServices.ServiceProxyHolder#getMethod. Since we use here only args values (don't have full information about args types) sometimes we can get an error for overloaded methods. For example, if you have an interface like: public interface TestServiceInterface { public String testMethod(String val); public String testMethod(Object val); } And invoke service like: Object arg = null; svc.testMethod(arg); Java will resolve the correct method to call on client-side, but using only arg value (null) it's impossible to get exactly one method on the server-side (PlatformServices.ServiceProxyHolder#getMethod will throw an error in this case: Ambiguous proxy method 'testMethod') To solve this problem we can pass full method signature (method name with parameters types) instead of just method name. Or we can additionally pass argument types to find exactly one method by Class.getMethod(String name, Class<?>... parameterTypes). Also, we can support two approaches at the same time: just the method name to simplify the implementation of non-java thin clients, and full method signature to deal with overloaded methods. So, What do you think about single operation for service invocation (create service proxy on each invoke request)? What do you think about ways to resolve the method? [1] : https://cwiki.apache.org/confluence/display/IGNITE/IEP-46%3A+Thin+Client+Service+Invocation [2] : https://issues.apache.org/jira/browse/IGNITE-12754