Examples with NameException org.apache.jackrabbit.spi.commons.conversion.NameException used on opensource projects

Example 11 with NameException

use of org.apache.jackrabbit.spi.commons.conversion.NameException in project jackrabbit by apache.

the class NodeImpl method resolveRelativePropertyPath.

/**
     * Returns the id of the property at <code>relPath</code> or <code>null</code>
     * if no property exists at <code>relPath</code>.
     * <p>
     * Note that access rights are not checked.
     *
     * @param relPath relative path of a (possible) property
     * @return the PropertyEntry of the property at <code>relPath</code> or
     * <code>null</code> if no property exists at <code>relPath</code>
     * @throws RepositoryException if <code>relPath</code> is not a valid
     * relative path
     */
private PropertyEntry resolveRelativePropertyPath(String relPath) throws RepositoryException {
    PropertyEntry targetEntry = null;
    try {
        Path rp = session.getPathResolver().getQPath(relPath);
        if (rp.getLength() == 1 && rp.denotesName()) {
            // a single path element must always denote a name. '.' and '..'
            // will never point to a property. If the NodeEntry does not
            // contain such a property entry, the targetEntry is 'null;
            Name propName = rp.getName();
            // check if property entry exists
            targetEntry = getNodeEntry().getPropertyEntry(propName, true);
        } else {
            // build and resolve absolute path
            Path p = getPath(rp).getCanonicalPath();
            try {
                targetEntry = session.getHierarchyManager().getPropertyEntry(p);
            } catch (PathNotFoundException e) {
            // ignore -> return null;
            }
        }
    } catch (NameException e) {
        String msg = "failed to resolve property path " + relPath + " relative to " + safeGetJCRPath();
        log.debug(msg);
        throw new RepositoryException(msg, e);
    }
    return targetEntry;
}

Example 12 with NameException

use of org.apache.jackrabbit.spi.commons.conversion.NameException in project jackrabbit by apache.

the class NodeImpl method resolveRelativeNodePath.

/**
     * Returns the <code>NodeEntry</code> at <code>relPath</code> or
     * <code>null</code> if no node exists at <code>relPath</code>.
     * <p>
     * Note that access rights are not checked.
     *
     * @param relPath relative path of a (possible) node.
     * @return the HierarchyEntry of the node at <code>relPath</code> or
     * <code>null</code> if no node exists at <code>relPath</code>.
     * @throws RepositoryException if <code>relPath</code> is not a valid
     * relative path.
     */
private NodeEntry resolveRelativeNodePath(String relPath) throws RepositoryException {
    NodeEntry targetEntry = null;
    try {
        Path rp = session.getPathResolver().getQPath(relPath);
        // shortcut
        if (rp.getLength() == 1) {
            if (rp.denotesCurrent()) {
                targetEntry = getNodeEntry();
            } else if (rp.denotesParent()) {
                targetEntry = getNodeEntry().getParent();
            } else {
                // try to get child entry + force loading of not known yet
                targetEntry = getNodeEntry().getNodeEntry(rp.getName(), rp.getNormalizedIndex(), true);
            }
        } else {
            // rp length > 1
            Path p = getPath(rp);
            targetEntry = session.getHierarchyManager().getNodeEntry(p.getCanonicalPath());
        }
    } catch (PathNotFoundException e) {
    // item does not exist -> ignore and return null
    } catch (NameException e) {
        String msg = "Invalid relative path: " + relPath;
        log.debug(msg);
        throw new RepositoryException(msg, e);
    }
    return targetEntry;
}

Example 13 with NameException

use of org.apache.jackrabbit.spi.commons.conversion.NameException in project jackrabbit by apache.

the class RepositoryServiceImpl method getPropertyInfo.

@Override
public PropertyInfo getPropertyInfo(SessionInfo sessionInfo, PropertyId propertyId) throws RepositoryException {
    HttpGet request = null;
    try {
        String uri = getItemUri(propertyId, sessionInfo);
        request = new HttpGet(uri);
        HttpResponse response = executeRequest(sessionInfo, request);
        int status = response.getStatusLine().getStatusCode();
        if (status != DavServletResponse.SC_OK) {
            throw ExceptionConverter.generate(new DavException(status, response.getStatusLine().getReasonPhrase()));
        }
        Path path = uriResolver.getQPath(uri, sessionInfo);
        HttpEntity entity = response.getEntity();
        ContentType ct = ContentType.get(entity);
        boolean isMultiValued;
        QValue[] values;
        int type;
        NamePathResolver resolver = getNamePathResolver(sessionInfo);
        if (ct != null && ct.getMimeType().startsWith("jcr-value")) {
            type = JcrValueType.typeFromContentType(ct.getMimeType());
            QValue v;
            if (type == PropertyType.BINARY) {
                v = getQValueFactory().create(entity.getContent());
            } else {
                Reader reader = new InputStreamReader(entity.getContent(), ct.getCharset());
                StringBuffer sb = new StringBuffer();
                int c;
                while ((c = reader.read()) > -1) {
                    sb.append((char) c);
                }
                Value jcrValue = valueFactory.createValue(sb.toString(), type);
                if (jcrValue instanceof QValueValue) {
                    v = ((QValueValue) jcrValue).getQValue();
                } else {
                    v = ValueFormat.getQValue(jcrValue, resolver, getQValueFactory());
                }
            }
            values = new QValue[] { v };
            isMultiValued = false;
        } else if (ct != null && ct.getMimeType().equals("text/xml")) {
            // jcr:values property spooled
            values = getValues(entity.getContent(), resolver, propertyId);
            type = (values.length > 0) ? values[0].getType() : loadType(uri, getClient(sessionInfo), propertyId, sessionInfo, resolver);
            isMultiValued = true;
        } else {
            throw new ItemNotFoundException("Unable to retrieve the property with id " + saveGetIdString(propertyId, resolver));
        }
        return new PropertyInfoImpl(propertyId, path, type, isMultiValued, values);
    } catch (IOException e) {
        throw new RepositoryException(e);
    } catch (DavException e) {
        throw ExceptionConverter.generate(e);
    } catch (NameException e) {
        throw new RepositoryException(e);
    } finally {
        if (request != null) {
            request.releaseConnection();
        }
    }
}

Example 14 with NameException

use of org.apache.jackrabbit.spi.commons.conversion.NameException in project jackrabbit by apache.

the class Locked method with.

/**
     * Executes the method {@link #run} within the scope of a lock held on
     * <code>lockable</code>.
     *
     * @param lockable the node where the lock is obtained from.
     * @param isDeep   <code>true</code> if <code>lockable</code> will be locked
     *                 deep.
     * @param timeout  time in milliseconds to wait at most to aquire the lock.
     * @return the object returned by {@link #run} or {@link #TIMED_OUT} if the
     *         lock on <code>lockable</code> could not be aquired within the
     *         specified timeout.
     * @throws IllegalArgumentException if <code>timeout</code> is negative or
     *                                  <code>lockable</code> is not
     *                                  <i>mix:lockable</i>.
     * @throws RepositoryException      if {@link #run} throws an exception.
     * @throws UnsupportedRepositoryOperationException
     *                                  if this repository does not support
     *                                  locking.
     * @throws InterruptedException     if this thread is interrupted while
     *                                  waiting for the lock on node
     *                                  <code>lockable</code>.
     */
public Object with(Node lockable, boolean isDeep, long timeout) throws UnsupportedRepositoryOperationException, RepositoryException, InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout must be >= 0");
    }
    Session session = lockable.getSession();
    NamePathResolver resolver = new DefaultNamePathResolver(session);
    Lock lock;
    EventListener listener = null;
    try {
        // check whether the lockable can be locked at all
        if (!lockable.isNodeType(resolver.getJCRName(NameConstants.MIX_LOCKABLE))) {
            throw new IllegalArgumentException("Node is not lockable");
        }
        lock = tryLock(lockable, isDeep);
        if (lock != null) {
            return runAndUnlock(lock);
        }
        if (timeout == 0) {
            return TIMED_OUT;
        }
        long timelimit;
        if (timeout == Long.MAX_VALUE) {
            timelimit = Long.MAX_VALUE;
        } else {
            timelimit = System.currentTimeMillis() + timeout;
        }
        // node is locked by other session -> register event listener if possible
        if (isObservationSupported(session)) {
            ObservationManager om = session.getWorkspace().getObservationManager();
            listener = new EventListener() {

                public void onEvent(EventIterator events) {
                    synchronized (this) {
                        this.notify();
                    }
                }
            };
            om.addEventListener(listener, Event.PROPERTY_REMOVED, lockable.getPath(), false, null, null, true);
        }
        // the current thread when the lockable node is possibly unlocked
        for (; ; ) {
            synchronized (this) {
                lock = tryLock(lockable, isDeep);
                if (lock != null) {
                    return runAndUnlock(lock);
                } else {
                    // check timeout
                    if (System.currentTimeMillis() > timelimit) {
                        return TIMED_OUT;
                    }
                    if (listener != null) {
                        // event listener *should* wake us up, however
                        // there is a chance that removal of the lockOwner
                        // property is notified before the node is acutally
                        // unlocked. therefore we use a safety net to wait
                        // at most 1000 millis.
                        this.wait(Math.min(1000, timeout));
                    } else {
                        // repository does not support observation
                        // wait at most 50 millis then retry
                        this.wait(Math.min(50, timeout));
                    }
                }
            }
        }
    } catch (NameException e) {
        throw new RepositoryException(e);
    } finally {
        if (listener != null) {
            session.getWorkspace().getObservationManager().removeEventListener(listener);
        }
    }
}

Example 15 with NameException

use of org.apache.jackrabbit.spi.commons.conversion.NameException in project jackrabbit by apache.

the class PathConstraint method create.

static PathConstraint create(String jcrPath, PathResolver resolver) throws InvalidConstraintException {
    try {
        // constraint format: absolute or relative path with optional
        // trailing wild card
        boolean deep = jcrPath.endsWith(JCR_WILDCARD);
        Path path;
        if (JCR_WILDCARD.equals(jcrPath)) {
            path = PATH_FACTORY.getRootPath();
        } else {
            if (deep) {
                // trim trailing wild card before building path
                jcrPath = jcrPath.substring(0, jcrPath.length() - JCR_WILDCARD.length());
            }
            path = resolver.getQPath(jcrPath);
        }
        StringBuffer definition = new StringBuffer(path.getString());
        if (deep) {
            definition.append(WILDCARD);
        }
        return new PathConstraint(definition.toString(), path, deep);
    } catch (NameException e) {
        String msg = "Invalid path expression specified as value constraint: " + jcrPath;
        log.debug(msg);
        throw new InvalidConstraintException(msg, e);
    } catch (NamespaceException e) {
        String msg = "Invalid path expression specified as value constraint: " + jcrPath;
        log.debug(msg);
        throw new InvalidConstraintException(msg, e);
    }
}