The javadoc for the server framework can be found here.

The following screenshot shows the popup in action:



The popup will appear after receiving no response from the server for a couple of seconds. It will automatically disappear when the server responds. The user can click the popup to terminate the connection to the server (it will automatically reconnect on the next function call).

Note that this feature can be disabled via the INI file (see table above).

The addin can register function information/help with Excel on startup. This is is achieved by calling a special function on the server called org.boris.xlloop.GetFunctions.

The server responds with an array of FunctionInformation objects (which are encoded as arrays).

The addin then calls the Excel4(xlfRegister, ...) function to register each function. The user will then see the help information via the Insert->Function menu.



Note that the Java server framework has a handler called FunctionInformationFunctionHandler, which accepts FunctionInformation objects. This handler implements the special function above. For an example see the ServerExample class in the Java source.

The following code example shows how to uses annotations to add function information when using the ReflectFunctionHandler handler:

package org.boris.xlloop;

import java.io.File;

import org.boris.xlloop.reflect.XLFunction;
				
public class AnnotationsTest
{
    @XLFunction(name = "ListFiles", 
            help = "List the files contained within a directory", 
            args = { "dir" }, 
            argHelp = { "The directory" }, 
            category = "Files")
    public static String[] listFiles(String dir) {
        return new File(dir).list();
    }
}

The following page shows an example lisp function handler.

The following example shows a server that exposes all scripts within a directory (and sub directories) as functions:

package org.boris.functionserver;

import java.io.File;

import org.boris.functionserver.reflect.ReflectFunctionHandler;
import org.boris.functionserver.script.ScriptRepository;
import org.boris.functionserver.util.CompositeFunctionHandler;

public class ServerTest 
{
    public static void main(String[] args) throws Exception {
        FunctionServer fs = new FunctionServer();
        ReflectFunctionHandler rfh = new ReflectFunctionHandler();
        ScriptRepository srep = new ScriptRepository(new File("functions"), "Script.");
        rfh.addMethods("Math.", Math.class);
        CompositeFunctionHandler cfh = new CompositeFunctionHandler();
        cfh.add(rfh);
        cfh.add(srep);
        fs.setFunctionHandler(cfh);
        fs.run();
    }
}

An example script called "mult.js", written in javascript simply multiplies the two numbers entered:

args[0] * args[1];

This can be called from Excel with the configuration above as follows:

=FS("Script.mult", 45.3, 23)
=Script.mult(45.3, 23)

The binary protocol supports connecting to multiple servers to improve reliability and scalability.

The approach is simple; it connects to a random server, if this fails it reports an error to the user. If the user attempts to connect again (ie. by invoking another function) the addin will choose a random server to connect to. The following example shows an INI file with multiple servers specified.

server=localhost,localhost:5455,myserver:9000

If a port is not specified it uses the default of 5454.

The addin supports a JSON over HTTP protocol. Each function invocation is a separate HTTP request. The input data is sent via a POST method. The result is a single xloper object encoded in JSON. To enable this feature setup the INI file as follows:

protocol=http
url=http://localhost:8000/FunctionServer

The JSON input request looks like:

{
    "args": [],
    "name": "Math.random",
    "request": "XLLoop",
    "version": "0.1.0"
}

The result JSON looks like:

{
    "num": 0.8091614905358369,
    "type": 1
}

XLLoop can be configured to connect to multiple function servers. The following shows an example of the INI file configuration to achieve this:

providers=Java,Python,Ruby,PHP
include.volatile=false

[Java]
server=localhost

[Python]
server=localhost:5460
function.name=PY

[Ruby]
server=localhost:5470
function.name=RB

[Erlang]
server=localhost:5480
function.name=ERL

[PHP]
protocol=http
url=http://xlloop.sourceforge.net/servers/php/TestServer.php
send.caller.info=true
function.name=LP

Each provider specified in the providers property (comma-separated list) refers to a section in the INI file. Each section accepts all the INI properties listed in the table above (apart from global properties).

This will setup connections to multiple servers. The function.name property is used to set the generic function name registered for that server. For example, to invoke a python function from the server at localhost:5460 you could write the following formula:

=PY("ArgsTest", "Hello World!")

Note that difference between configuring multiple servers for one function provider and configuring mutiple function providers. Multiple function server instances serve up the same functions whereas multiple function providers each provide a different set of functions. Also note that no attempt is made to reconcile function name clashes between function providers.

V0.3.2

• Added support for multiple servers (providers)
• Moved source code to github and refactored addin source folders

V0.3.1

• Added round-robin connection mode for multiple servers in binary mode
• Added retry ability to binary mode
• Added annotation support for function information to reflection-based java functions
• Java server framework now requires Java 1.5 (for annotations)
• Generic function category can be customized
• added ability to load INI keys from an external file
• added ability to load INI keys from the registry

V0.3.0

• Added JSON over HTTP(S) protocol support
• Added native PHP server
• Added support for multiple servers in binary protocol mode
• Functions can now support up to 30 arguments (and variable length)
• Added ability to send caller information (sending sheet and cell)
• Improvements in reliability of binary protocol
• Addin name now defaults to the filename (minus .xll)
• Added an Initialize call when addin first connects. This can send user information (for initializing a user session)

V0.2.2

• Fixed build issue with 0.2.1 release

V0.2.1

• Fixed marshalling issues with empty/long strings

V0.2.0

• Added popup to client for long running operations (with option to cancel request)
• Added native Ruby server
• Added native Python server
• Added native R server
• Fixed native Erlang server
• Buffered streams on java server for improved performance
• Improvements to reliability on binary protocol
• Support up to 512 registered functions
• Reduced xll size by using wcrt

Older Change History