Package org.jboss.util

Examples of org.jboss.util.CachePolicy

493
494
495
496
497
498
499
500
501
502
503
    * @param instance the SecurityDomain instance to bind
    */
   public synchronized void registerSecurityDomain(String securityDomain, SecurityDomain instance)
   {
      log.debug("Added "+securityDomain+", "+instance+" to map");
      CachePolicy authCache = lookupCachePolicy(securityDomain);
      SecurityDomainContext sdc = new SecurityDomainContext(instance, authCache);
      securityDomainCtxMap.put(securityDomain, sdc);
      // See if the security mgr supports an externalized cache policy
      setSecurityDomainCache(instance, authCache);
   }
View Full Code Here
508
509
510
511
512
513
514
515
516
517
518
    */
   private static CachePolicy getCachePolicy(String securityDomain)
   {
      if( securityDomain.startsWith(SECURITY_MGR_PATH) )
         securityDomain = securityDomain.substring(SECURITY_MGR_PATH.length()+1);
      CachePolicy cache = null;
      try
      {
         SecurityDomainContext sdc = lookupSecurityDomain(securityDomain);
         if( sdc != null )
            cache = sdc.getAuthenticationCache();
View Full Code Here
531
532
533
534
535
536
537
538
539
540
541
    looking up the CachePolicy for a domain. If this fails then the cacheJndiName
    location is treated as a single CachePolicy for all security domains.
    */
   private static CachePolicy lookupCachePolicy(String securityDomain)
   {
      CachePolicy authCache = null;
      String domainCachePath = cacheJndiName + '/' + securityDomain;
      try
      {
         InitialContext iniCtx = new InitialContext();
         authCache = (CachePolicy) iniCtx.lookup(domainCachePath);
View Full Code Here
638
639
640
641
642
643
644
645
646
647
648
         Constructor ctor = securityMgrClass.getConstructor(parameterTypes);
         CallbackHandler handler = (CallbackHandler) callbackHandlerClass.newInstance();
         Object[] args = {securityDomain, handler};
         AuthenticationManager securityMgr = (AuthenticationManager) ctor.newInstance(args);
         log.debug("Created securityMgr="+securityMgr);
         CachePolicy cachePolicy = lookupCachePolicy(securityDomain);
         sdc = new SecurityDomainContext(securityMgr, cachePolicy);
         // See if the security mgr supports an externalized cache policy
         setSecurityDomainCache(securityMgr, cachePolicy);
         if(deepCopySubjectMode)
            setDeepCopySubjectOption(securityMgr, true);
View Full Code Here
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
      byte[] clientChallenge = (byte[]) args[1];

      try
      {
         InitialContext iniCtx = new InitialContext();
         CachePolicy cache = (CachePolicy) iniCtx.lookup(cacheJndiName);
         SRPSessionKey key;
         if (userPrincipal instanceof SRPPrincipal)
         {
            SRPPrincipal srpPrincpal = (SRPPrincipal) userPrincipal;
            key = new SRPSessionKey(username, srpPrincpal.getSessionID());
         }
         else
         {
            key = new SRPSessionKey(username);
         }
         Object cacheCredential = cache.get(key);
         if (cacheCredential == null)
         {
            throw new SecurityException("No SRP session found for: " + key);
         }
         log.debug("Found SRP cache credential: " + cacheCredential);
View Full Code Here
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
      return initializer;
   }
  
   public CtClassCache createCache()
   {
      CachePolicy policy = null;
      if (policyClass == TimedCachePolicy.class)
         policy = new TimedCachePolicy(lifetime, true, resolution);
      else if (policyClass == LRUCachePolicy.class)
         policy = new LRUCachePolicy(min, max);
      else
      {
         try
         {
            policy = policyClass.newInstance();
         }
         catch(Exception e)
         {
            throw new IllegalStateException("Could not instantiate " + policyClass.getName(), e);
         }
      }
   
      try
      {
         policy.create();
         policy.start();
      }
      catch(Exception e)
      {
         throw new IllegalStateException("Error starting domain cache", e);
      }
View Full Code Here
84
85
86
87
88
89
90
91
92
93
94
      synchronized (getCacheLock())
      {
         BeanCacheSnapshot snapshot = (BeanCacheSnapshot)s;
         snapshot.m_passivatingBeans = 0;
         CachePolicy policy = getCache();
         if (policy instanceof Monitorable)
         {
            ((Monitorable)policy).sample(s);
         }
      }
View Full Code Here
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
      EnterpriseContext ctx;

      synchronized (getCacheLock())
      {
         CachePolicy cache = getCache();
         ctx = (EnterpriseContext)cache.get(id);
         if (ctx == null)
         {
            try
            {
               ctx = acquireContext();
               setKey(id, ctx);
               if (doActivate(ctx) == false)
                  // This is a recursive activation
                  return ctx;
               logActivation(id);
               // the cache will throw an IllegalStateException if we try to insert
               // something that is in the cache already, so we don't check here
               cache.insert(id, ctx);
            }
            catch (Throwable x)
            {
               log.debug("Activation failure", x);
               throw new NoSuchObjectException(x.getMessage());
View Full Code Here
224
225
226
227
228
229
230
231
232
233
234
/* 270 */         log.trace("SetCacheTimeOut:Failed to look up SecurityDomainCtx:" + securityDomain);
/*     */       }
/*     */     }
/* 273 */     if (securityDomainCtx != null)
/*     */     {
/* 275 */       CachePolicy cache = securityDomainCtx.getAuthenticationCache();
/* 276 */       if ((cache != null) && ((cache instanceof TimedCachePolicy)))
/*     */       {
/* 278 */         TimedCachePolicy tcp = (TimedCachePolicy)cache;
/* 279 */         synchronized (tcp)
/*     */         {
View Full Code Here
178
179
180
181
182
183
184
185
186
187
188
/* 266 */     SecurityConfiguration.setDeepCopySubjectMode(flag);
/*     */   }
/*     */
/*     */   public void setCacheTimeout(String securityDomain, int timeoutInSecs, int resInSecs)
/*     */   {
/* 279 */     CachePolicy cache = getCachePolicy(securityDomain);
/* 280 */     if ((cache != null) && ((cache instanceof TimedCachePolicy)))
/*     */     {
/* 282 */       TimedCachePolicy tcp = (TimedCachePolicy)cache;
/* 283 */       synchronized (tcp)
/*     */       {
View Full Code Here
TOP

Related Classes of org.jboss.util.CachePolicy

  • org.jboss.classpool.base.CtClassCacheFactory
  • org.jboss.ejb.plugins.AbstractInstanceCache
  • org.jboss.metadata.plugins.cache.CachePolicyCacheFactory
  • org.jboss.metadata.plugins.cache.SynchronizedCachePolicyFactory
  • org.jboss.security.auth.AuthenticationCacheFlushThread
  • org.jboss.security.integration.JNDIBasedSecurityManagement
  • org.jboss.security.plugins.AuthorizationManagerService
  • org.jboss.security.plugins.JaasSecurityManagerService
  • org.jboss.security.srp.jaas.SRPCacheLoginModule
  • org.jboss.test.security.interceptors.SRPCacheInterceptor
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.