Dymond & Associates  
Home
Products
Benefits
Services
Papers
About
Contact
 

 

Technical Paper:
SAS®Socket Server

Overview
Addressing and Using a Server Socket
Writing a SAS Socket Server
Testing the Server Socket
Writing a Java Socket Client
Read Your SAS License
Appendix: other program listings

Overview

Any computer connected to the Internet that can read and write to a socket can talk to any other computer with these same capabilities.  This means that almost any computer today, regardless of hardware platform, operating system, or programming language, can talk to any other computer over the Internet.   SAS software supports server socket connections, allowing other computers with or without SAS loaded on them to start SAS jobs and recover files from remote locations.

Controlling SAS jobs from remote locations presents some interesting opportunities.  For example, several SAS socket servers are an alternative to multitasking.  Effective multitasking requires expensive hardware and software.  Dispersing several SAS jobs onto smaller machines using sockets avoids these expenses and avoids multitasking's platform dependence.  It can also improve the utilization of the smaller machines.  As an example, in the evening several co-workers in adjacent cubes can leave their workstations on and running a socket server.  One co-worker can then run a production job composed of several SAS jobs by starting jobs on the other machines. Since sockets use the Internet to communicate, it is as easy to use machines from a remote location as it is to use local machines.

Special SAS programs can be made available from a central location.  For example, biotech companies have FDA requirements for using verified software systems. General data manipulation can usually avoid software verification, but activities such as statistical calculations require verification. Biotech companies already have verified SAS systems and if these can be used for functions such as statistics, this will avoid the overhead of verification.  Passing jobs into the SAS systems through a socket connection will make this possible.

Many industries such as banks and telecommunications have a substantial investment in SAS code to run complex production processes. It will be possible to build an external intelligent scheduler/controller for these large production environments if a way can be found to launch SAS jobs and read their output. A Java™-SAS socket connection will make this possible.


This technical paper briefly describes Internet sockets, describes a socket server written in the Base SAS language, and then describes a socket client written in Java that can communicate to the SAS socket server.


Addressing and Using a Server Socket

The Internet converts a server name into an address as:

     http://www.somename.com --> 123.456.789.123

When a client contacts a server it expects to connect to a particular application.  The server may be running hundreds of applications, and the client finds the one it wants by knowing the correct port number on the server.  For example, if the client is a web browser, it expects the application on the server to be a web server that by common agreement is located at port 80.  So in this case:

     browser(http://www.somename.com) --> 123.456.789.123: 80

A web server is just one type of application that can run on the server.  Many applications other than web servers can be running behind their own designated ports, and many types of clients other than web browsers can connect to them if they know both the server address and the port number.  Once a connection is made, the client and server communicate by reading and writing messages to each other.  The format of the messages is determined by the programming language used, but this usually looks like text strings or files.  How the client and server application interpret these messages depends entirely on how they were programmed.


Writing a SAS Socket Server

A SAS socket server can be written using only the Base SAS language.  It does not require any additional software such as SAS/IntrNet or SAS/Connect.  We will write and explain a simple but useful server that allows a client (written in any language) to run specific SAS programs and to read specific files back to the client.  Adding controls for specific programs and files adds some clutter to the example, but this is justified by the need to consider security for any application exposed to the Internet.  An exposed server application would also need user name and password controls, but even if a hacker obtained these the specific program and file controls shown here would provide limits and protection. 

SAS uses a file to represent the socket connection.  File writes and reads are used to pass information to and from the SAS server.  This example is written in SAS version 8 and the socket server only allows one connection at a time, and this connection only exists within the scope of a data step.  The client connects to the server, the client passes a message to the server, the server passes a message back to the client, and the server ends the connection.  For anyone new to the Internet this can seem like a strange way of doing things, but it is in fact the way most client-server Internet applications function.  Message synchronization occurs only within the scope of the connection.  There is no "state" or "data persistence" between one connection and the next - the server has no information about any previous requests from a particular client.  This works well because the server is only asked to run a program or return a file.  Any "state" should be maintained on the client side of the connection.

Below is the SAS server file listing.  Notes in the body of the code are expanded below the listing.

  

   /*---------------------------------------------------------------------------*/
   /*  ...socketDemo\server.sas                                                 */
   /*                                                                           */
   /*   A socket server written in Base SAS(r).                                 */
   /*                                                                           */
   /*   It will run specific SAS programs based on the client commands:         */
   /*      LAUNCH RUNTHIS                                                       */
   /*      LAUNCH RUNTHAT                                                       */
   /*                                                                           */
   /*   It will return specific files based on the client commands:             */
   /*      QUERY READTHIS                                                       */
   /*      QUERY READTHAT                                                       */
   /*                                                                           */
   /*   It will stop the loop based on the client command:                      */
   /*      BYE                                                                  */
   /*                                                                           */
   /*  NOTE:  This code is informational only.  It is not supported.  It has    */
   /*         not underdone a security audit and should not be used without     */
   /*         review and enhancement by qualified technical staff.              */
   /*                                                                           */
   /*                                                                           */
   /*    Copyright (C) 2003 Dymond and Associates, LLC, All rights reserved.    */
   /*---------------------------------------------------------------------------*/
options source notes noxwait;
filename _ALL_ CLEAR;
proc printto log = log; run;                              /* reset SAS log file */
%global launch loop thisroot;

/*** change 'thisroot' to match your directory                                ***/
%let thisroot = c:\datasets\code\socketDemo;                      [note 1]
/*** The socket server runs on 'localhost' port 5100                          ***/
filename srvsoc SOCKET 'localhost:5100' SERVER reconn=0 ;         [note 2]
/*** Files to query (client can request they be returned from the server)     ***/
%let READTHIS = &thisroot.\readthisfile.txt;
%let READTHAT = &thisroot.\readthatfile.txt;
filename READTHIS  "&READTHIS";
filename READTHAT  "&READTHAT";
/*  Only these files can be requested from the server                           */
%let querylist = *READTHIS*READTHAT*;
/***  Programs that can be run on the server.                                 ***/
%let RUNTHIS = &thisroot.\runthisprogram.sas;
%let RUNTHAT = &thisroot.\runthatprogram.sas;
/*  Only these sas programs can be run (launched) from the server               */
%let launchlist = *RUNTHIS*RUNTHAT*;

/*  In the 'query' section of the data step files can be selected for return    */
/*  from the server.  Only allow files that physically exist.                   */
%macro goodfiles;
   %if %sysfunc(fexist(READTHIS)) %then
      if argument='READTHIS' then infile READTHIS end=lastrow %str(;);
   %if %sysfunc(fexist(READTHAT)) %then
      if argument='READTHAT' then infile READTHAT end=lastrow %str(;);
%mend goodfiles;

/*-----------------------------------------------------------------------------*/
/*  The macro loop will run as long as &loop>0.  The data step inside the loop  */
/*  will allow one new connection that will exist only within the scope of the  */
/*  step.  Ending the data step disconnects the client socket.                  */
/*  The data step waits at the line 'input' until a line is provided by the     */
/*  client socket.                                                              */
/*-----------------------------------------------------------------------------*/
%macro sassrv;
%do %while(&loop);                                                [note 3]
   %put STARTING SAS SOCKET SERVER LOOP;
   %let launch=;
      /*------------------------------------------------------------------------*/
      /* Send log to server log file.                                           */
      /*------------------------------------------------------------------------*/
      /*proc printto log = "&srvlog"; run; */
      /*------------------------------------------------------------------------*/
      /* Wait for client to connect, then read one line.  Parse the line and    */
      /* bind 'command' and 'argument' variables.                               */
      /*------------------------------------------------------------------------*/
   data _null_;
      length linein command argument $ 256;
      infile srvsoc;                 [note 4]  /* point to server as input file */
      input;                 [note 5] /* wait here to read one line from client */
      linein=left(_infile_);
      linein=substr(linein,1,length(linein)-1);      /* trailing crud character */
      put linein=;
      if upcase(linein)=:'BYE' then do;
          command='BYE';
      end;
      else if upcase(linein)=:'QUERY' then do;
         arg= trim(left(substr(linein,6)));
         command='QUERY';
         argument=trim(arg);
      end;
      else if upcase(linein)=:'LAUNCH' then do;
         arg= trim(left(substr(linein,7)));
         command='LAUNCH';
         argument=trim(arg);
      end;
      else do;
         file  log;
         put 'Cannot parse command.';
         file srvsoc;
         put 'Cannot parse command.';
      end;
      file  log;
      put command=;
      put argument=;
      /*------------------------------------------------------------------------*/
      /* BYE: Shutdown server if requested.                          [note 6]   */
      /*------------------------------------------------------------------------*/
      if command='BYE' then do;
         file  log;
         put 'Server stop is being requested by client.';    /* send to sas log */
         file srvsoc;
         put 'Server stop is being requested by client.';     /* send to client */
         call symput('loop','0');                     /* stop loop on next pass */
      end;
      /*------------------------------------------------------------------------*/
      /* QUERY: Write a predefined file to the client.                          */
      /*------------------------------------------------------------------------*/
      if command='QUERY' then do;
         if NOT index("&querylist",'*'||trim(argument)||'*') then do;
            file log;
            put 'This file cannot be queried';
            file srvsoc;
            put 'This file cannot be queried';
         end;
         else if NOT fexist(argument) then do;
            file log;
            put 'The file does not exist';
            file srvsoc;
            put 'The file does not exist';
         end;
         else do;
               file log;
               put 'Ready to read a file';
               file srvsoc;
               put 'Ready to read a file';
               %goodfiles;                       [note 7]  /* select the infile */
               do until(lastrow);
                  input;
                  put _infile_;
               end;
         end;
      end;
      /*------------------------------------------------------------------------*/
      /* LAUNCH: Run a predefined program.                                      */
      /*------------------------------------------------------------------------*/
      if command='LAUNCH' then do;
         if NOT index("&launchlist",'*'||trim(argument)||'*') then do;
            file log;
            put 'This file cannot be run';
            file srvsoc;
            put 'This file cannot be run';
         end;
         else do;
            file log;
            put 'Launching program ' argument;
            file srvsoc;
            put 'Launching program ' argument;
            call symput('launch',trim(argument));
         end;
      end;
      stop;
   run;
   /*---------------------------------------------------------------------------*/
   /* RUN SAS PROGRAM:  use %include to start a sas program.         [note 8]   */
   /*---------------------------------------------------------------------------*/
   %put launch=***&launch***;
   %if &launch^=  %then %do;
      %include "&&&launch";
   %end;
   /*---------------------------------------------------------------------------*/
   /* Release the SAS log.                                                      */
   /*---------------------------------------------------------------------------*/
   proc printto log=log; run;
%end;
%mend sassrv;
%let loop=1;
%sassrv;

 


[note 1]
This is the directory where this program runs.  Change it to match your computer.

[note 2]
SAS makes it easy to establish a socket by using a FILENAME statement.  This line of code creates a server socket named "srvsoc" at port 5100 on the computer where the code is running.  The Base SAS code can now address this socket as if it was a file.  Only one connection at a time is allowed to the server.

"localhost" is the loopback address for your local computer and allows testing without being connected to the outside Internet.  Change this as 'www.somename.com' to connect to a remote machine.

[note 3]
This is the beginning of a macro loop that will run as long as the loop variable &loop > 1.  The top part of the loop contains a data _null_ step that will service the socket connection.  The bottom part has a few lines of macro code that are used to start a SAS program if this was requested.

[note 4]
Read data from the "file" srvsoc.

[note 5]
The data _null_ step will wait here until a client connects and transmits a "file."  Only one line which should contain the command to the server is read.  The connection will exist until the end of this data step at which time the server will end the connection with the client.

Note that this line is the only point where the server is able to receive a new connection.  When the code is executing elsewhere within the macro loop the server will not respond to a client's request for a connection.

[note 6]
There will be one write to the SAS log (file log) and a second write to the client through the socket (file srvsoc).

[note 7]
The macro "goodfiles" ensures that lines of code containing the INFILE statement will be written only when the referenced file actually exists.

[note 8]
This macro code occurs after the end of the data _null_ step (and the end of the client socket connection) and uses a %INCLUDE to run a specific SAS program if this was requested.  


Testing the Server Socket

Begin by starting the SAS program shown above.  The macro loop will cause the job to be continuously "running" in the SAS program window.

A telnet window is a simple way to test a socket server.  On a Windows® machine, use

   Start -> Run -> telnet

to start the telnet application.  When the telnet window opens use

   Connect -> Remote System...

and then enter the connection information as:

   Host Name:  localhost
   Port:       5100
   TermType:   vt100


If a connection is made the text at the top of the telnet window should change from "Telnet-[None]" to "Telnet-localhost."  The connection to the server can be confirmed by entering a few random key strokes followed by a carriage return.  The server should respond with the message "Cannot parse command" and the socket connection should be released.  If this is successful the remainder of the server functions can be exercised.  Recall that the server ends the connection and it will have to be reestablished each time prior to issuing a command.


Writing a Java Socket Client

We want to replace the manual telnet window with a client written in some programming language.  A number of languages are capable of doing this, and the socket client shown below is written in Java.  This client is run from a DOS window.  It attempts to connect to the socket server, transfer the command line arguments to the socket server, and then read and echo all the lines returned from the socket server.

  

import java.io.*;
import java.net.*;
                
/*===================================================================*
 * ...socketDemo\Client.java                                         *
 *                                                                   *
 *                                                                   *
 * A Java client socket talking to a SAS server socket.              *
 *                                                                   *
 *                                                                   *
 *       Copyright (C) 2003 by Dymond and Associates, LLC.           *
 *                      All rights reserved.                         *
 *===================================================================*/
 /**
  * Usage:                                                       [note 1]
  *   java Client BYE                                 //stop SAS server
  *   java Client "QUERY READTHIS"        // read files from SAS server
  *   java Client "QUERY READTHAT"
  *   java Client "LAUNCH RUNTHIS"          // start jobs on SAS server
  *   java Client "LAUNCH RUNTHAT"
  */
                
public class Client {
   //----------------------------------------------------------------//
   // constructor                                                    //
   //----------------------------------------------------------------//
   public Client(String[] args) {
      super();
      String linein;
      Socket client = null;
      int counter = 0;
System.out.println("args: "+args[0]);
      //-------------------------------------------------------------//
      // Loop while trying to connect to the SAS server socket.      //
      // Sleep for one second between attempts to connect.           //
      //-------------------------------------------------------------//
      while(true) {                                            [note 2]
         try {
            client = new Socket("localhost",5100);     //try to connect
            if (client!=null) { break; }               //got connection
         }
         catch (IOException exc) {             //did not get connection
            counter++;
            if (counter>10) {
               System.out.println("Java client timed out waiting for a socket.");
               System.out.println("LAST EXCEPTION: "+exc);
               return;
            }
            else {
               try { Thread.sleep(1000); }           //sleep one second
               catch (InterruptedException iexc) {}
            }
         }
      }
         
      //-------------------------------------------------------------//
      // Send the command line argument out the socket.              //
      //-------------------------------------------------------------//
      try {
         BufferedReader inSoc = new BufferedReader(
            new InputStreamReader(client.getInputStream()));
         PrintWriter outSoc = new PrintWriter(
            new BufferedOutputStream(client.getOutputStream()), true);
         outSoc.println(args[0]);                              [note 3]
      //-------------------------------------------------------------//
      // Read what comes back and echo it to sysout.                 //
      //-------------------------------------------------------------//
         System.out.println("Beginning read loop.");
         while(true) {                                         [note 4]
            linein=inSoc.readLine();
                
            if (linein==null ||
               linein.trim().equalsIgnoreCase("BYE") ) {
               break;
            }
            else {
               System.out.println("from sas: "+linein);
            }
         }
         client.close();
      } catch (Exception exc) {
         System.out.println("Error: "+exc);
      }
   } // end constructor
                
   //----------------------------------------------------------------//
   // main()                                                         //
   //----------------------------------------------------------------//
   public static void main(String[] args) {
      Client cl = new Client(args);
   } // end main
                
} //end class Client

 

 

[note 1]
This client socket is run from the command line with the directory set to the location of the compiled Java program (Client.class).  An example of the command line is:

   c:\some_directory>java Client "QUERY READTHIS"

where java starts the Java virtual machine, Client is the name of the java program to run, and "QUERY READTHIS" is the argument passed to the java program that is in turn sent as a message to the SAS socket server.

[note 2]
The client will make 10 tries to connect to the server with a one second rest between tries.  This loop begins with an attempt to connect to the socket server at address "localhost" and port 5100.  If a connection is successful, as indicated the object "client" being non-null, the loop is exited.  If unsuccessful, control passes to the the catch block that increments and examines to loop counter.  If the loop counter exceeds 10 the program ends with an error message.  Otherwise, it sleeps for one second and returns to the top of the loop.

[note 3]
After creating inSoc and outSoc objects to read and write to the socket, the program sends the arguments from the command line to the socket server.  Only the one line is transmitted to the server.

[note 4]
The client begins a read loop that will read as  many lines as are sent back from the server.  Each line is echoed to the DOS window.  When the server has finished sending lines it will close the socket connection.  The client closes the connection on its end and finishes.

Read Your SAS License

Read your SAS license and be sure that it allows you to do whatever you are planning!



Appendix: runthisprogram.sas and runthatprogram.sas program listings

The runthisprogram.sas and runthatprogram.sas listings are shown below.  All the code for the socket server project can be downloaded in a zip file. 

   /*---------------------------------------------------------------------------*/
   /*  ...socketDemo\runthisprogram.sas                                         */
   /*                                                                           */
   /*   Test Base SAS server communicating to Java sockets.                     */
   /*   Write a file named c:\datasets\code\socketDemo\readthisfile.txt         */
   /*                                                                           */
   /*---------------------------------------------------------------------------*/
options source notes;
/* change this file path for your system.                                       */
filename out "c:\datasets\code\socketDemo\readthisfile.txt" ;
data _null_;
   dt= datetime();
   file out;
   put "datetime: " dt datetime18.;
   put "This is line 2 in the file 'readthisfile.'";
   put "This is line 3 in the file 'readthisfile.'";
   put "This is line 4 in the file 'readthisfile.'";
run;




                
   /*---------------------------------------------------------------------------*/
   /*  ...\runthatprogram.sas                                                   */
   /*                                                                           */
   /*   Test Base SAS server communicating to Java sockets.                     */
   /*   Write a file named c:\datasets\code\socketDemo\readthatfile.txt         */
   /*                                                                           */
   /*---------------------------------------------------------------------------*/
options source notes;
/* change this file path for your system.                                       */
filename out "c:\datasets\code\socketDemo\readthatfile.txt" ;
data _null_;
   dt= datetime();
   file out;
   put "datetime: " dt datetime18.;
   put "This is line 2 in the file 'readthatfile.'";
   put "This is line 3 in the file 'readthatfile.'";
   put "This is line 4 in the file 'readthatfile.'";
run;
 
 

              
 

              		
             
          

        

        

      

        

          

            
            
            
            
            
          

        

      

    

  

  

    ©2005 Dymond and Associates, LLC