Changeset 1025

Timestamp:

10/09/06 19:05:53 (2 years ago)

Author:

jmoore

Message:

#326 Implemented WeakHashMap?<Object,EventContext?> for stateful services.

Location:

trunk/components/server/src/ome

Files:

• logic/AbstractBean.java (modified) (3 diffs)
• security/basic/BasicSecuritySystem.java (modified) (1 diff)
• security/basic/CurrentDetails.java (modified) (1 diff)
• security/basic/EventHandler.java (modified) (5 diffs)
• services/RawPixelsBean.java (modified) (2 diffs)
• services/RenderingBean.java (modified) (1 diff)

trunk/components/server/src/ome/logic/AbstractBean.java

@@ -50 +50 @@
 import ome.security.SecuritySystem;
 import ome.services.query.QueryFactory;
+import ome.system.EventContext;
 import ome.system.OmeroContext;
 import ome.system.Principal;
@@ -82 +83 @@
     private @Resource SessionContext sessionContext;
 
+    protected boolean contextLoaded = true; // always true for stateless services.
+
     // ~ Lifecycle implementations
         // =========================================================================
@@ -109 +112 @@
                     (ProxyFactoryBean) applicationContext.getBean(factoryName),
                     context );
+            if (!contextLoaded)
+            {
+                adapter.getUserAttributes().put( EventContext.class, Boolean.TRUE );
+                contextLoaded = true;
+            }
             return adapter.proceed( );   
         } catch (Throwable t) {

trunk/components/server/src/ome/security/basic/BasicSecuritySystem.java

@@ -1013 +1013 @@
         {
                 final Principal p = clearAndCheckPrincipal();
-                throw new UnsupportedOperationException("not implemented.");
+                
+                if ( ! (context instanceof BasicEventContext) )
+                        throw new ApiUsageException( "BasicSecuritySystem can only accept " +
+                                        "BasicEventContext instances.");
+                
+                final BasicEventContext bec = (BasicEventContext) context;
+                final String u_name = bec.getCurrentUserName();
+                final String g_name = bec.getCurrentGroupName();
+                final String t_name = bec.getCurrentEventType();
+                
+                if ( p.getName().equals( u_name ) && 
+                                p.getGroup().equals( g_name ) &&
+                                p.getEventType().equals( t_name ))
+                {
+                        cd.setCurrentEventContext( bec );
+                } 
+                
+                else
+                {
+                        throw new InternalException(String.format(
+                                        "Principal:%s/%s/%s does not match Context:%s/%s/%s",
+                                        p.getName(),p.getGroup(),p.getEventType(),
+                                        u_name,g_name,t_name));
+                }
         }
 

trunk/components/server/src/ome/security/basic/CurrentDetails.java

@@ -96 +96 @@
         return data.get();
     }
+    
+    void setCurrentEventContext( BasicEventContext bec )
+    {
+        data.set( bec );
+    }
 
     private Details getDetails()

trunk/components/server/src/ome/security/basic/EventHandler.java

@@ -58 +58 @@
 import ome.model.meta.EventLog;
 import ome.system.EventContext;
+import ome.tools.spring.AOPAdapter;
 
 /**
@@ -86 +87 @@
     
     // for StatefulServices TODO
-    private Map<Session, Event> events = Collections
-    .synchronizedMap(new WeakHashMap<Session, Event>());
+    private Map<Object, EventContext> objCtxMap = Collections
+    .synchronizedMap(new WeakHashMap<Object, EventContext>());
 
     /** only public constructor, used for dependency injection. Requires an 
@@ -113 +114 @@
     {
         boolean readOnly = checkReadOnly(arg0);
-        secSys.loadEventContext(readOnly);
-        // TODO check for an existing session here.
+        boolean stateful = StatefulServiceInterface.class.isAssignableFrom(
+                        arg0.getThis().getClass());
+        
+        if ( stateful )
+        {
+                        EventContext prevCtx = objCtxMap.get( arg0.getThis() );
+                        boolean      needCtx = false;
+                        if ( arg0 instanceof AOPAdapter )
+                        {
+                                // TODO needs refactoring. Perhaps better to add this to
+                                // SecuritySystem. Or when OmeroContext is reworked, that this
+                                // is added to that interface.
+                                AOPAdapter adapter = (AOPAdapter) arg0;
+                                Map attributes = adapter.getUserAttributes();
+                                if ( attributes != null )
+                                {
+                                        Object o = attributes.get( EventContext.class );
+                                        if ( o instanceof Boolean && ((Boolean)o).booleanValue() )
+                                        {
+                                                needCtx = true;
+                                        }
+                                }
+                        }
+
+                        if ( null == prevCtx )
+                        {
+                                if ( ! needCtx )
+                                {
+                                        throw new InternalException( 
+                                                "Stateful service missing context." );
+                                }
+                                
+                                else 
+                                {
+                                        secSys.loadEventContext(false);
+                                        objCtxMap.put( arg0.getThis(), secSys.getEventContext() );
+                                        prevCtx = secSys.getEventContext();
+                                }       
+                        }
+                        secSys.setEventContext( prevCtx );
+        }
+        
+        else // stateless
+        {
+                // this is usually done manually by stateful services 
+                // in their @PostConstruct methods
+                secSys.loadEventContext(readOnly);
+        }
 
         // now the user can be considered to be logged in.
@@ -134 +181 @@
         } finally {
                 try {
-                        
-                        boolean stateful = (arg0.getThis() instanceof StatefulServiceInterface);
 
                         // on failure, we want to make sure that no one attempts 
@@ -293 +338 @@
         public Object doInHibernate(Session session) 
         throws HibernateException, SQLException {
-                if (session.isDirty())
+                boolean dirty = session.isDirty();
+                if (dirty)
                 {
                         throw new InternalException("Session is dirty. Cannot properly " +

trunk/components/server/src/ome/services/RawPixelsBean.java

@@ -100 +100 @@
     }
     
+    public RawPixelsBean()
+    {
+        super.contextLoaded = false;
+    }
+    
     public final void setPixelsMetadata(IPixels metaService)
     {
@@ -142 +147 @@
     // =========================================================================
     
-    @RolesAllowed("user") 
+    @RolesAllowed("user")
     public void setPixelsId( long pixelsId )
     {

trunk/components/server/src/ome/services/RenderingBean.java

@@ -185 +185 @@
     private transient ReentrantReadWriteLock         rwl 
         = new ReentrantReadWriteLock();
+
+    public RenderingBean()
+    {
+        super.contextLoaded = false;
+    }
     
     /** set injector. For use during configuration. Can only be called once. */