Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2013, Red Hat, Inc., and individual contributors
   * as indicated by the @author tags. See the copyright.txt file in the
   * distribution for a full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.jboss.legacy.jnp.infinispan;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import  org.infinispan.Cache;
 import  org.infinispan.CacheException;
 import  org.jboss.ha.jndi.spi.DistributedTreeManager;
 import  org.jnp.interfaces.Naming;
 import  org.jnp.interfaces.NamingContext;
 import  org.jnp.interfaces.NamingParser;

Author(s):
Emmanuel Hugonnet (c) 2013 Red Hat, inc.
 
 public class InfinispanDistributedTreeManager implements org.jnp.interfaces.Naming, DistributedTreeManager {
 
     static final long serialVersionUID = 6342802270002172451L;
 
     private static Logger log = Logger.getLogger(InfinispanDistributedTreeManager.class);
 
     private static final NamingParser parser = new NamingParser();
 
     public static final String DEFAULT_ROOT = "__HA_JNDI__";
 
     private TreeCache<StringBindingcache;
     private Fqn m_root;
     private Naming haStub;
     private boolean treeRootSet;
     protected boolean acquiredCache = false;
 
     public InfinispanDistributedTreeManager() {
         super();
     }
 
     public Cache<StringBindinggetClusteredCache() {
         return (Cache<StringBinding>) .getCache();
     }
 
     public void setClusteredCache(Cache<StringBindingcache) {
         if () {
             throw new IllegalStateException("Cannot change clusteredCache after call to init()");
         }
         this. = new TreeCacheFactory().createTreeCache(cache);
     }
 
     public void setRootFqn(String rootFqn) {
         if () {
             throw new IllegalStateException("Cannot change rootFqn after call to init()");
         }
 
          = (rootFqn == null) ? null : Fqn.fromString(rootFqn);
     }
 
     public String getRootFqn() {
         return  == null ?  : .toString();
     }
 
    @SuppressWarnings("unchecked")
    @Override
    public void init() {
        if (this. == null) {
            throw new IllegalStateException("No clustered cache available");
        }
        .debug("initializing HAJNDITreeCache root");
        this.putTreeRoot();
    }
    @Override
    public void shutdown() {
        .stop();
    }
    @Override
    public Naming getHAStub() {
        return this.;
    }
    @Override
    public void setHAStub(Naming stub) {
        this. = stub;
    }
    @Override
    public void bind(Name nameObject objString classNamethrows NamingException {
        if (.isTraceEnabled()) {
            .trace("bind, name=" + name);
        }
        this.internalBind(nameobjclassNamefalse);
    }
    @Override
    public void rebind(Name nameObject objString classNamethrows NamingException {
        if (.isTraceEnabled()) {
            .trace("rebind, name=" + name);
        }
        this.internalBind(nameobjclassNametrue);
    }
    @Override
    public void unbind(Name namethrows NamingException {
        if (.isTraceEnabled()) {
            .trace("unbind, name=" + name);
        }
        if (name.isEmpty()) {
            // Empty names are not allowed
            throw new InvalidNameException();
        }
        // is the name a context?
        try {
            Fqn temp = Fqn.fromRelativeFqn(this., Fqn.fromString(name.toString()));
            // TODO why not jst call remove -- why hasChild first?
            if (this..getRoot().hasChild(temp)) {
                this..removeNode(temp);
                return;
            }
        } catch (CacheException ce) {
            // don't chain CacheException since JBoss Cache may not be on remote client's classpath
            NamingException ne = new NamingException(ce.getClass().getName() + ": " + ce.getMessage());
            ne.setStackTrace(ce.getStackTrace());
            throw ne;
        }
        int size = name.size();
        // get the context and key
        Fqn ctx;
        String key = name.get(size - 1);
        if (size > 1) {
            String prefix = name.getPrefix(size - 1).toString();
            Fqn fqn = Fqn.fromString(prefix);
            ctx = Fqn.fromRelativeFqn(this.fqn);
        } else {
            ctx = this.;
        }
        try {
            Object removed = this..remove(ctxkey);
            if (removed == null) {
                if (!this..getRoot().hasChild(ctx)) {
                    throw new NotContextException(name.getPrefix(size - 1).toString() + " not a context");
                }
                throw new NameNotFoundException(key + " not bound");
            }
        } catch (CacheException ce) {
            // don't chain CacheException since JBoss Cache may not be on remote client's classpath
            NamingException ne = new NamingException(ce.getClass().getName() + ": " + ce.getMessage());
            ne.setStackTrace(ce.getStackTrace());
            throw ne;
        }
    }
    public Object lookup(Name namethrows NamingException {
        boolean trace = .isTraceEnabled();
        if (trace) {
            .trace("lookup, name=" + name);
        }
        if (name.isEmpty()) {
            // Return this
            return new NamingContext(null.parse(""), this.getHAStub());
        }
        // is the name a context?
        try {
            Node<StringBindingn = this..getRoot().getChild(Fqn.fromRelativeFqn(this., Fqn.fromString(name.toString())));
            if (n != null) {
                Name fullName = (Namename.clone();
                return new NamingContext(nullfullNamethis.getHAStub());
            }
        } catch (CacheException ce) {
            // don't chain CacheException since JBoss Cache may not be on remote client's classpath
            NamingException ne = new NamingException(ce.getClass().getName() + ": " + ce.getMessage());
            ne.setStackTrace(ce.getStackTrace());
            throw ne;
        }
        int size = name.size();
        // get the context and key
        Fqn ctx;
        String key = name.get(size - 1);
        if (size > 1) {
            String prefix = name.getPrefix(size - 1).toString();
            Fqn fqn = Fqn.fromString(prefix);
            ctx = Fqn.fromRelativeFqn(this.fqn);
        } else {
            ctx = this.;
        }
        try {
            Binding b = this..get(ctxkey);
            // if key not in cache, return null
            return (b != null) ? b.getObject() : null;
        } catch (CacheException ce) {
            // don't chain CacheException since JBoss Cache may not be on remote client's classpath
            NamingException ne = new NamingException(ce.getClass().getName() + ": " + ce.getMessage());
            ne.setStackTrace(ce.getStackTrace());
            throw ne;
        }
    }
    public Collection<NameClassPairlist(Name namethrows NamingException {
        if (.isTraceEnabled()) {
            .trace("list, name=" + name);
        }
        // get the context
        Fqn ctx;
        String ctxName = "";
        int size = name.size();
        if (size >= 1) {
            ctxName = name.toString();
            Fqn fqn = Fqn.fromString(ctxName);
            ctx = Fqn.fromRelativeFqn(this.fqn);
        } else {
            ctx = this.;
        }
        boolean exists = this..getRoot().hasChild(ctx);
        if (!exists) {
            try {
                return Collections.list(new InitialContext().list(name));
            } catch (NamingException e) {
                throw new NotContextException(ctxName + " not a context");
            }
        }
        try {
            List<NameClassPairlist = new LinkedList<NameClassPair>();
            Node<StringBindingbase = this..getRoot().getChild(ctx);
            if (base != null) {
                for (Binding b : base.getData().values()) {
                    list.add(new NameClassPair(b.getName(), b.getClassName(), true));
                }
                // Why doesn't this return Set<String>?
                Set<Objectchildren = base.getChildrenNames();
                if (children != null && !children.isEmpty()) {
                    for (Object child : children) {
                        String node = (Stringchild;
                        Name fullName = (Namename.clone();
                        fullName.add(node);
                        list.add(new NameClassPair(node, NamingContext.class.getName(), true));
                    }
                }
            }
            return list;
        } catch (CacheException ce) {
            // don't chain CacheException since JBoss Cache may not be on remote client's classpath
            NamingException ne = new NamingException(ce.getClass().getName() + ": " + ce.getMessage());
            ne.setStackTrace(ce.getStackTrace());
            throw ne;
        }
    }
    public Collection<BindinglistBindings(Name namethrows NamingException {
        if (.isTraceEnabled()) {
            .trace("listBindings, name=" + name);
        }
        // get the context
        Fqn ctx;
        String ctxName = "";
        int size = name.size();
        if (size >= 1) {
            ctxName = name.toString();
            Fqn fqn = Fqn.fromString(ctxName);
            ctx = Fqn.fromRelativeFqn(this.fqn);
        } else {
            ctx = this.;
        }
        boolean exists = this..getRoot().hasChild(ctx);
        if (!exists) {
            // not found in global jndi, look in local.
            try {
                return Collections.list(new InitialContext().listBindings(name));
            } catch (NamingException e) {
                throw new NotContextException(ctxName + " not a context");
            }
        }
        try {
            List<Bindinglist = new LinkedList<Binding>();
            Node<StringBindingnode = this..getRoot().getChild(ctx);
            if (node != null) {
                Map<StringBindingdata = node.getData();
                if (data != null && !data.isEmpty()) {
                    list.addAll(data.values());
                }
                // Why doesn't this return Set<String>?
                Set<Objectchildren = node.getChildrenNames();
                if (children != null && !children.isEmpty()) {
                    for (Object obj : children) {
                        String child = (Stringobj;
                        Name fullName = (Namename.clone();
                        fullName.add(child);
                        NamingContext subCtx = new NamingContext(nullfullNamethis.getHAStub());
                        list.add(new Binding(child, NamingContext.class.getName(), subCtxtrue));
                    }
                }
            }
            return list;
        } catch (CacheException ce) {
            // don't chain CacheException since JBoss Cache may not be on remote client's classpath
            NamingException ne = new NamingException(ce.getClass().getName() + ": " + ce.getMessage());
            ne.setStackTrace(ce.getStackTrace());
            throw ne;
        }
    }
    @Override
    public Context createSubcontext(Name namethrows NamingException {
        if (.isTraceEnabled()) {
            .trace("createSubcontext, name=" + name);
        }
        int size = name.size();
        if (size == 0) {
            throw new InvalidNameException("Cannot pass an empty name to createSubcontext");
        }
        // does the new context already exist?
        String str = name.toString();
        Fqn fqn = Fqn.fromString(str);
        Fqn ctx = Fqn.fromRelativeFqn(this.fqn);
        if (this..getRoot().hasChild(ctx)) {
            throw new NameAlreadyBoundException();
        }
        // does the prefix context already exist?
        Fqn pctx;
        String newctx = name.get(size - 1);
        if (size > 1) {
            String prefix = name.getPrefix(size - 1).toString();
            Fqn fqn2 = Fqn.fromString(prefix);
            pctx = Fqn.fromRelativeFqn(this.fqn2);
        } else {
            pctx = this.;
        }
        boolean exists = this..getRoot().hasChild(pctx);
        if (!exists) {
            throw new NotContextException(name.getPrefix(size - 1).toString());
        }
        Fqn newf = Fqn.fromRelativeFqn(pctx, Fqn.fromString(newctx));
        try {
            this..put(newfnew HashMap<StringBinding>());
        } catch (CacheException ce) {
            // don't chain CacheException since JBoss Cache may not be on remote client's classpath
            NamingException ne = new NamingException(ce.getClass().getName() + ": " + ce.getMessage());
            ne.setStackTrace(ce.getStackTrace());
            throw ne;
        }
        Name fullName = .parse("");
        fullName.addAll(name);
        return new NamingContext(nullfullNamethis.getHAStub());
    }
    private void putTreeRoot() throws CacheException {
        if (this. == null) {
            setRootFqn();
        }
        if (!this..getRoot().hasChild(this.)) {
            this..put(this., Collections.<StringBinding>emptyMap());
            this. = true;
        }
    }
    private void internalBind(Name nameObject objString classNameboolean rebindthrows NamingException {
        if (name.isEmpty()) {  // Empty names are not allowed
            throw new InvalidNameException();
        }
        int size = name.size();
        // get the context and key
        Fqn ctx;
        String key = name.get(size - 1);
        if (size > 1) {
            String prefix = name.getPrefix(size - 1).toString();
            Fqn fqn = Fqn.fromString(prefix);
            ctx = Fqn.fromRelativeFqn(this.fqn);
        } else {
            ctx = this.;
        }
        boolean exists = this..getRoot().hasChild(ctx);
        if (!exists) {
            throw new NotContextException(name.getPrefix(size - 1).toString() + " not a context");
            // note - NamingServer throws a CannotProceedException if the client attempts to bind
            //        to a Reference object having an "nns" address.  This implementation simply
            //        throws the NotContextException that's used when "nns" isn't present.
        }
        if (!rebind) {
            Node<StringBindingnode = this..getRoot().getChild(ctx);
            if ((node != null) && (node.get(key) != null)) {
                throw new NameAlreadyBoundException(key);
            }
        }
        this..put(ctxkeynew Binding(keyclassNameobjtrue));
    }
New to GrepCode? Check out our FAQ X