JCo server programming, properties and connection settings

Question

Greetings, SAP professionals.
The reason I come to this forum is that I'm hoping to gain some insights into the use of the SAP Java Connector (JCo). I am a developer who was tasked with making a new component for a systems integration application. As is typical of integration software, our app can link together various different systems using a variety of protocols, as well as providing the means to apply business logic on messages passed from one location to another. We already have a connector acting as an SAP client which was implemented using JCo. Now, we were asked to develop a new component: a server capable of accepting RFCs from a remote SAP system acting as client. The server is to be created using the JCo classes, so basically an extension of JCo.Server, with some logic for creating function templates from configuration files.
However, while I'm understanding the structure of the Java API, it's not entirely clear to me just what the classes do. I've found the JavaDoc for JCo to be mostly descriptive of the interface of classes and methods, but not really explaining what these achieve, or how. So I'm hoping to be set straight, as I fear I'm kind of misunderstanding the functionality of JCo... Being mainly an integrations developer, I unfortunately often have to settle for gaining a superficial knowledge of a variety of systems to quickly interface with them, so I don't have any prior knowledge of SAP but still need to be able to implement something with JCo without too much delay.
The most important question I have is this: when a JCO.Server implementation is started, does it act as a fully standalone component capable of receiving calls, or does it merely act as a sort of listener for some main SAP system? I'm not talking about a reliability on the two .dll files (or .so for Linux) that are required for the use of JCo, I just wish to know if the JCo package is entirely self-sufficient for server functionality or if it is intended to be linked to some SAP system.
A second problem I have is that the parameters passed to various constructors aren't clear to me... I'm not familiar with SAP terminology, nor have I worked with any client apps that make use of an SAP system.
The meaning of client strings, gwhost, gwservice, ashost, system IDs and program IDs mostly elude me, especially when it comes to knowing what client parameters must match what server parameters.
In order to familiarize myself with the classes, I've tried playing around with them a bit trying to create a small test app that first starts a JCO.Server instance, then tries to make a remote function call to it with a JCO.Client (within the same class, for simplicity and debugging purposes). I was wondering if this actually makes sense... Would a JCo client be capable of connecting to a JCo server, all running purely in Java, or is that nonsense?
To eliminate some common troubleshooting options, I'll quicly describe the steps I've taken:
Both librfc32.dll and sapjcorfc.dll were placed in the Windows system32 folder. Maybe only librfd32 needs to be placed there, but I copied both anyway to make sure.
The directory containing the jar file and both dll files is included in my environment path variable.
I've added a line to the C:\Windows\system32\drivers\etc\services file as follows:
sapgw00          3300/tcp                           #SAP System Gateway Port
I've opened port 3300 in my Windows firewall. In fact, I also tested with the firewall completely turned off.
However, I do not manage to get my test class to work. I've tried ports 3300, 3200 and 3600. I've tried various permutations of the client and server properties. I've tried removing the line from the services file, which would prompt the client to state upon connecting that the service "sapgw00" is unknown. When I add it back in, the error changes to "partner not reached", so it is definitely picking something up.
The server itself starts just fine, but connecting through a client doesn't work. My class source code is posted below. Maybe what I'm trying to do doesn't make any sense, but at the moment it's my best guess.
I realize this is a pretty long post and the class, while not exactly big, also implies a bit of reading of its own. But if anyone could give me any answers that are new to me, I'd be hugely grateful. Right now I'm kind of stuck, and just setting up the service and letting our customer test on it is a somewhat slow approach that can't match developing and testing on one and the same host.
Preliminary thanks to everyone who took the effort to read this.
//Start of code
import java.util.Properties;
import com.sap.mw.jco.IFunctionTemplate;
import com.sap.mw.jco.IMetaData;
import com.sap.mw.jco.IRepository;
import com.sap.mw.jco.JCO;
public class Test {
     public static void main(String[] args) {
          Test test = new Test();
          ServerThread serverThread = test.new ServerThread();
          serverThread.start();
          while(!serverThread.isReady) {
               try {
                    Thread.sleep(5000);
               } catch(final InterruptedException i) {
                    System.out.println("Rudely awakened");
          try {
//               JCO.Function func = getSampleFunction(test, "STAY");
//               serverThread.server.handleRequest(func);
//               System.out.println(func.getExportParameterList().toXML());
//               func = getSampleFunction(test, "STOP");
//               serverThread.server.handleRequest(func);
//               System.out.println(func.getExportParameterList().toXML());
               final Properties clientProps = getClientProps();
               JCO.Client client = JCO.createClient(clientProps);
               client.connect();
               IRepository rep = JCO.createRepository("1", client);
               IFunctionTemplate templ = rep.getFunctionTemplate("TEST_FUNC");
               JCO.Function function = templ.getFunction();
               function.getImportParameterList().setValue("STAY", "FIELD1");
               client.execute(function);
               JCO.Function function2 = templ.getFunction();
               function2.getImportParameterList().setValue("STOP", "FIELD1");
               client.execute(function2);
          } catch(final Exception e) {
               e.printStackTrace(System.out);
               serverThread.requestStop();
               while(serverThread.isAlive) {
                    try {
                         Thread.sleep(5000);
                    } catch(final InterruptedException i) {
                         System.out.println("Rudely awakened");
          } finally {
     private static Properties getClientProps() {
          final Properties props = new Properties();
          props.setProperty("jco.client.client", "100");
          props.setProperty("jco.client.user", "");
          props.setProperty("jco.client.passwd", "");
          props.setProperty("jco.client.lang", "");
          props.setProperty("jco.client.sysnr", "00");
          props.setProperty("jco.client.ashost", "/H/localhost/S/sapgw00");
          props.setProperty("jco.client.gwhost", "localhost");
          props.setProperty("jco.client.gwserv", "sapgw00");
          return props;
     public class ServerThread extends Thread {
          public void run() {
               isAlive = true;
               IRepository repos = new TestRepository("testrep");
               repos.addFunctionInterfaceToCache(getFunctionInterface());
               server = new TestServer(repos);
               server.start();
               System.out.println("Server successfully started");
               isReady = true;
               while(!stop) {
                    try {
                         Thread.sleep(1000);
                    } catch(final InterruptedException i) {
                         System.out.println("Wouldn't let me sleep...");
                    stop = server.stopRequested;
               server.stop();
               isAlive = false;
               System.out.println("Server successfully stopped");
          public void requestStop() {
               server.requestStop();
          public TestServer server;
          public boolean isReady = false;
          public boolean isAlive = false;
     public class TestServer extends JCO.Server {
          public TestServer(IRepository rep) {
               super("localhost", "sapgw00", "PROGID", rep);
          public void handleRequest(JCO.Function fct) {
               try {
                    JCO.ParameterList importParams = fct.getImportParameterList();
                    final String importXML = importParams.toXML();
                    System.out.println("XML representation of import parameters: ");
                    System.out.println(importXML);
                    final String input = importParams.getString("FIELD1");
                    System.out.println("FIELD1 value: " + input);
                    JCO.ParameterList exportParams = fct.getExportParameterList();
                    if(input.equals("STOP")) {
                         exportParams.getField("FIELD2").setValue("OK");
                         stopRequested = true;
               catch(JCO.AbapException ex) {
                    throw ex;
               catch(Throwable t) {
                    throw new JCO.AbapException("SYSTEM_FAILURE", t.getMessage());
          public boolean checkAuthorization(String functionName, int authorMode, String partner, byte[] key) {
               System.out.println(functionName + " " + partner);
               return true;
          public void requestStop() {
               stopRequested = true;
          public boolean stopRequested = false;
     public class TestRepository extends JCO.BasicRepository implements IRepository {
          public TestRepository(String name) {
               super(name);
     public static IMetaData getFunctionInterface() {
          JCO.MetaData metaData = new JCO.MetaData("TEST_FUNC");
          metaData.addInfo("FIELD1", IMetaData.TYPE_STRING, 4);
          metaData.setFlags(0, IMetaData.IMPORT_PARAMETER);
          metaData.addInfo("FIELDX", IMetaData.TYPE_STRING, 8);
          metaData.setFlags(1, IMetaData.IMPORT_PARAMETER & IMetaData.OPTIONAL_PARAMETER);
          metaData.addInfo("FIELD2", IMetaData.TYPE_STRING, 2);
          metaData.setFlags(2, IMetaData.EXPORT_PARAMETER);
          return metaData;
     public static JCO.Function getSampleFunction(Test test, String s) {
          TestRepository testRep = test.new TestRepository("testrepository");
          testRep.addFunctionInterfaceToCache(getFunctionInterface());
          JCO.Function func = testRep.getFunctionTemplate("TEST_FUNC").getFunction();
          func.getImportParameterList().setValue(s, "FIELD1");
          return func;
     private static boolean stop = false;

Answer 1

If I understood you correctly, you want to provide a "service" that can be called from SAP. To provide this service you've chosen to implement an (external) RFC server program via JCo. One common method for RFC server programs is to register in SAP on the gateway - you do this by supplying the three parameters
<ol>
<li><b>jco.server.gwhost</b> -  SAP gateway host on which the server should be registered (so this would be the server name or IP address of the SAP gateway; localhost is only correct, if your RFC server program runs on the same server as the SAP gateway)</li>
<li><b>jco.server.gwserv</b>  - Gateway service, i.e. the port on which a registration can be done</li>
<li><b>jco.server.progid</b> - Program ID under which your RFC server program can be reached (free, made-up case sensitive name, that should represent the service your RFC server is providing)</li>
</ol>
So essentially you're creating a listener, that is registered in SAP and waits for any invocations. Within SAP they will define a <i>RFC destination</i>, which basically represents a TCP/IP connection pointing to the SAP gateway where you registered with the given program ID. If you want more details, check the SAP help pages for <a target="_blank" href="http://help.sap.com/saphelp_nw04/helpdata/en/22/04262b488911d189490000e829fbbd/content.htm">RFC destinations</a> (you're looking for destination type <b>T</b>, see explanations <a target="_blank" href="http://help.sap.com/saphelp_nw04/helpdata/en/22/042652488911d189490000e829fbbd/content.htm">here</a>).
Usually gateway host and service (port) are given to you by the SAP basis folks and you tell them which program ID you're using. They will then enter those parameters in an RFC destination of type <b>T</b> in SAP. So no need for any of the client parameters you've mentioned. Although, I'd like to repeat, it's usually handy to also have SAP logon parameters maintained on your RFC server program, so that you can utilize the repository data from SAP (might be irrelevant in your case).
Hope this clarifies it a bit...