Home > Sample chapters

Service Fabric on Linux

Using Communication Listeners

To create a service that listens to client requests, you need to create and register a CommunicationListener implementation. This process is very similar to what you did in Chapter 2. Perform the following steps to create a Java-based calculator service that provides a REST API for add and subtract calculations:

  1. In Eclipse, create a new Service Fabric application named CalculatorApplication with a stateless service named Calculator.

  2. Add a new CalculatorServer class to the project. This class contains nothing specific to Service Fabric. It uses com.sun.net.httpserver.HttpServer to handle add and subtract requests from clients.

    package statelessservice;
    
    import com.sun.net.httpserver.*;
    import java.net.InetSocketAddress;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.io.UnsupportedEncodingException;
    import java.util.HashMap;
    import java.util.Map;
    
    public class CalculatorServer {
            private HttpServer server;
        private int port;
        public CalculatorServer(int port) {
                this.port = port;
        }
        public void start() throws IOException {
                server = HttpServer.create(new InetSocketAddress(port),0);
                HttpHandler add = new HttpHandler() {
                        @Override
                        public void handle(HttpExchange h) throws IOException {
                                byte[] buffer = CalculatorServer.handleCalculation
                                    (h.getRequestURI().getQuery(), "add");
                                h.sendResponseHeaders(200, buffer.length);
                                OutputStream os = h.getResponseBody();
                                os.write(buffer);
                                os.close();
                        }
                };
                HttpHandler subtract = new HttpHandler() {
                        @Override
                        public void handle(HttpExchange h) throws IOException {
                                byte[] buffer = CalculatorServer.handleCalculation
                                    (h.getRequestURI().getQuery(), "subtract");
                                h.sendResponseHeaders(200, buffer.length);
                                OutputStream os = h.getResponseBody();
                                os.write(buffer);
                                os.close();
                        }
                };
                server.createContext("/api/add", add);
                server.createContext("/api/subtract", subtract);
                server.setExecutor(null);
                server.start();
        }
        public void stop() {
                server.stop(10);
        }
        public static Map<String, String> queryToMap(String query) {
                Map<String, String> map = new HashMap<String, String>();
                for (String param: query.split("&")) {
                        String pair[] = param.split("=");
                        if (pair.length > 1) {
                                map.put(pair[0], pair[1]);
                        } else {
                                map.put(pair[0], "0");
                        }
                }
                return map;
        }
        public static byte[] handleCalculation(String query, String type)
            throws UnsupportedEncodingException {
                byte[] buffer = null;
                Map<String, String> parameters = CalculatorServer.queryToMap(query);
                int c = 0;
                try
                {
                    int a = Integer.parseInt(parameters.get("a"));
                    int b = Integer.parseInt(parameters.get("b"));
                    if (type.equals("add")) {
                            c = a + b;
                    } else {
                            c = a - b;
                    }
                    buffer = Integer.toString(c).getBytes("UTF-8");
                } catch (NumberFormatException e) {
                        buffer = ("Invalid parameters").getBytes("UTF-8");
                }
                return buffer;
        }
    }
  3. Add a WebCommunicationListener class to the project. This class implements microsoft.servicefabric.services.communication.runtime.CommunicationListener and overrides the openAsync, closeAsync, and abort methods.

    package statelessservice;
    
    import java.util.concurrent.CompletableFuture;
    import java.io.IOException;
    import microsoft.servicefabric.services.communication.runtime.CommunicationListener;
    import microsoft.servicefabric.services.runtime.StatelessServiceContext;
    import system.fabric.description.EndpointResourceDescription;
    import system.fabric.CancellationToken;
    
    public class WebCommunicationListener implements CommunicationListener {
        private StatelessServiceContext context;
        private CalculatorServer server;
        private String webEndpointName = "ServiceEndpoint";
        private int port;
        public WebCommunicationListener(StatelessServiceContext context) {
                this.context = context;
                EndpointResourceDescription endpoint =
                    this.context.getCodePackageActivationContext().getEndpoint
                        (webEndpointName);
            this.port = endpoint.getPort();
        }
    
        @Override
        public CompletableFuture<String> openAsync(CancellationToken cancellationToken) {
                CompletableFuture<String> str = new CompletableFuture<>();
                String address = String.format("http://%s:%d/api",
                    this.context.getNodeContext().getIpAddressOrFQDN(), this.port);
                str.complete(address);
                try
                {
                    server = new CalculatorServer(port);
                    server.start();
                } catch (IOException e) {
                        throw new RuntimeException(e);
                }
                return str;
        }
    
        @Override
        public CompletableFuture<?> closeAsync(CancellationToken cancellationToken) {
                CompletableFuture<Boolean> task = new CompletableFuture<>();
                task.complete(Boolean.TRUE);
                if (server != null) {
                        server.stop();
                }
                return task;
        }
    
        @Override
        public void abort() {
                if (server != null) {
                        server.stop();
                }
        }
    }
  4. Modify CalculatorService to return WebCommunicationListener from the overridden createServiceInstanceListeners method:

    import java.util.ArrayList;
    ...
    public class CalculatorService extends StatelessService {
        @Override
        protected List<ServiceInstanceListener> createServiceInstanceListeners() {
            ArrayList<ServiceInstanceListener> listeners = new ArrayList();
            listeners.add(new ServiceInstanceListener((context) -> {
                    return new WebCommunicationListener(context);
            }));
            return listeners;
        }
    }
  5. Modify the CalculatorApplicationApplication\CalculatorPkg\ServiceManifest.xml file to define an endpoint resource named ServiceEndpoint:

    <Resources>
        <Endpoints>
            <Endpoint Name="ServiceEndpoint" Protocol="http" Port="8182" />
        </Endpoints>
    </Resources>
  6. Build and deploy the application. Afterward, you should be able to use a browser and send requests such as http://localhost:8182/api/add?a=100&b=200 and http://localhost:8182/api/subtract?a=100&b=200. You should also get corresponding outputs (300 and –100).