Create a Java-based Liberator auth module

Conflicts: OpenPermissioning JavaOpenPermissioning PermissioningService TokenPermissioning

Boot-strapping the Deployment Framework

   Unpacking PermissioningJavaBlade kit PermissioningJavaBlade-000001.zip
   PermissioningJavaBlade-000001.zip successfully unpacked and stored in kits/archive

   Activating PermissioningJavaBlade

   Blades ok

Deployment Framework           6.0.4-267113

   Core components                Version
   -----------------------------------------------------------
   Liberator                      6.1.0-275608
   Transformer                    6.1.0-275716

   Deployed blades                Version            State
   -----------------------------------------------------------
   PricingAdapter                 2013.09.27.1138    Active
   PermissioningJavaBlade                            Active

   Built-in blades                                   State
   -----------------------------------------------------------
   BlotterExport                                     Inactive
   DemoDataSource                                    Inactive
   DirectConnection                                  Active
   HTTP                                              Active
   HTTPS                                             Inactive
   JavaOpenPermissioning                             Inactive
   LiberatorJMX                                      Active
   LiberatorWebsite                                  Active
   MinimalLiberatorWebsite                           Inactive
   OpenPermissioning                                 Inactive
   ServerIdentification                              Active
   TransformerJMX                                    Active

package example.permissioning;

import java.util.Map;
import java.util.logging.Logger;

import com.caplin.server.auth.AuthenticationResult;
import com.caplin.server.auth.AuthenticationUser;
import com.caplin.server.auth.Authenticator;
import com.caplin.server.auth.DelayedResultReceiver;
import com.caplin.server.auth.MapObject;
import com.caplin.server.auth.PermissionUpdateType;
import com.caplin.server.auth.RTTPObject;
import com.caplin.server.auth.ServerNode;
import com.caplin.server.auth.SessionManager;
import com.caplin.server.auth.UserSession;
import com.caplin.server.logging.ServerLevel;

/**
 *
 * A simple Java Authenticator implementation that rejects attempts
 * to log in to the Liberator.
 * It also logs debug information to the Liberator's auth-rttp.log
 * logfile using the native logger.
 */
public class SimplePermissioning implements Authenticator
{
   private Logger logger;

   public void initialise( SessionManager sessionManager,
                           DelayedResultReceiver delayedResultReceiver,
                           ServerNode serverNode,
                           String loggerName )
   {
      this.logger = Logger.getLogger(loggerName);

      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: initialise called: delayedResultReceiver={0}, serverNode={1}, loggerName={2}",
                 new Object[] {delayedResultReceiver, serverNode, loggerName});
   }

   public AuthenticationResult checkUser( UserSession session )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: checkUser called: userSession={0}",
                 new Object[] {session});
      return AuthenticationResult.INVALID_USER; // All user login attempts are invalid.
   }

   public AuthenticationResult releaseUser( UserSession session )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: releaseUser called: userSession={0}",
                  new Object[] {session});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult newObject( RTTPObject object, RTTPObject parent )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: newObject called: object={0}, parent={1}",
                 new Object[] {object, parent});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult releaseObject( RTTPObject object )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning releaseObject called: object={0}",
                 new Object[] {object});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult checkRead( UserSession session, RTTPObject object, String requestedName )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: checkRead called: sessionId={0}, object={1}",
                 new Object[] {session.getSessionId(),
                 object});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult checkWrite( UserSession session, RTTPObject object, String requestedName,
                                           Map<String, String> fields )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: checkWrite called: sessionId={0}, object={1}, fieldMap={2}",
                 new Object[] {session.getSessionId(),
                 object,
                 fields});
      return AuthenticationResult.DENY;
   }

   public AuthenticationResult mapObject( UserSession session, MapObject mapObject )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: mapObject called: sessionId={0}, mapObject={1}",
                  new Object[] {session.getSessionId(),
                  mapObject});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult requestObject( UserSession session, RTTPObject object )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: requestObject: sessionId={0}, object={1}",
                 new Object[] {session.getSessionId(),
                 object});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult discardObject( UserSession session, RTTPObject object )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: discardObject: sessionId={0}, object={1}",
                 new Object[] {session.getSessionId(),
                 object});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult authoriseHTTP( AuthenticationUser user )
   {
   logger.log(ServerLevel.DEBUG_LEVEL,
              "SimplePermissioning: authoriseHTTP called: user={0}",
              new Object[] {user});
   return AuthenticationResult.OK;
   }

   public AuthenticationResult checkUpdate( UserSession session, RTTPObject object,
                                            String data )
  {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: checkUpdate called: sessionId={0}, object={1}, data={2}",
                 new Object[] {session.getSessionId(),
                 object,
                 data});
      return AuthenticationResult.OK;
   }

   public AuthenticationResult checkPermissionUpdate( UserSession session, RTTPObject object,
                                                      String key, Map<String,
                                                      String> fieldValues )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: checkPermissionUpdate called: sessionId={0}, object={1}, key={2}, fieldValueMap={3}",
                 new Object[] {session.getSessionId(),
                 object,
                 key,
                 fieldValues});
      return AuthenticationResult.OK;
   }

   public void globalPermissionUpdate( RTTPObject object, String key,
                                       Map<String, String> fieldValues,
                                       PermissionUpdateType type )
   {
      logger.log(ServerLevel.DEBUG_LEVEL,
                 "SimplePermissioning: globalPermissionUpdate called: object={0}, key={1}, fieldValueMap={2}",
                 new Object[] {object, key, fieldValues});
   }

   public void shutdown()
   {
      logger.log(ServerLevel.DEBUG_LEVEL, "SimplePermissioning: shutdown called");
      // do nothing
   }
}