import javax.jcr.LoginException; //导入依赖的package包/类
protected void activate(ComponentContext ctx) {
    try {
        session = repository.loginService("serviceUser", null);
        observationManager = session.getWorkspace().getObservationManager();

        String[] nodeTypes = {"cq:PageContent"};
        int eventTypes = Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED;
        observationManager.addEventListener(this, eventTypes, "/content", true, null, nodeTypes, true);

        log.info("Activated JCR event listener");
    } catch (LoginException le) {
        log.error("Error activating JCR event listener: {}", le.getMessage());
    } catch (Exception e) {
        log.error("Error activating JCR event listener", e);
    }
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
private byte[] get(final String path) throws LoginException, RepositoryException, IOException {
	byte[] ret = null;
	Session session = null;
	try {
		session = repository.login(new SimpleCredentials("admin", "admin".toCharArray()));
		Binary b = session.getRootNode().getProperty(path).getBinary();
		ret = IOUtils.toByteArray(b.getStream());
		b.dispose();
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		if (session != null) {
			session.logout();
		}
	}
	return ret;
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
public Response handleRequest(Message m, ClassResourceInfo resourceClass) {
    AuthorizationPolicy policy = m.get(AuthorizationPolicy.class);
    if (policy != null) {
        String username = policy.getUserName();
        String password = policy.getPassword();
        try {
            session = JcrSessionUtil.createSession(username, password);
            if (isAuthenticated(session)) {
                HttpServletRequest request = (HttpServletRequest) m.get(AbstractHTTPDestination.HTTP_REQUEST);
                request.setAttribute(AuthenticationConstants.HIPPO_SESSION, session);
                return null;
            } else {
                throw new UnauthorizedException();
            }
        } catch (LoginException e) {
            log.debug("Login failed: {}", e);
            throw new UnauthorizedException(e.getMessage());
        }
    }
    throw new UnauthorizedException();
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Test
public void testNewUserSession() throws LoginException, RepositoryException {
  final JcrSessionFactory sf = getSessionFactory();
  Session session = null;
  try {
    session = sf.newUserSession(
        new SimpleCredentials("anonymous", new char[0]));
    assertThat(session.isLive()).isTrue();
    assertThat(session.getUserID()).isEqualTo("anonymous");
  } finally {
    if (session != null) session.logout();
  }
  try {
    sf.newUserSession(new SimpleCredentials("doesnotexist", new char[0]));
    fail("Should not succeed.");
  } catch (RuntimeException re) {
    assertThat(re.getCause()).isInstanceOf(LoginException.class);
  }
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Activate
public void activate(final Map<String, String> config) throws RepositoryException {
    componentsWithSharedProperties = new HashMap<>();

    // Schedule the initial calculation of components that have shared/global property dialogs.
    scheduleSharedComponentsMapUpdate();

    try {
        // Add an event listener on the /apps directory for component adds/removals to recalculate
        // the set of components that have shared/global property dialogs.
        respositorySession = repository.loginService(SERVICE_NAME, null);
        observationManager = respositorySession.getWorkspace().getObservationManager();

        // Need to listen for "nt:folder" else "nt:unstructured" nodes created/deleted from
        // CRD DE are not captured.
        String[] nodeTypes = {"nt:folder", "nt:unstructured"};
        int eventTypes = Event.NODE_ADDED | Event.NODE_REMOVED;
        observationManager.addEventListener(this, eventTypes, "/apps", true, null, nodeTypes, true);

        log.info("Activated JCR event listener for components with shared/global properties");
    } catch (LoginException le) {
        log.error("Could not get an admin resource resolver to listen for components with shared/global properties");
    } catch (Exception e) {
        log.error("Error activating JCR event listener for components with shared/global properties", e);
    }
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Test
public void testCreateNodeWithAuthentication() throws Exception {
    Exchange exchange = createExchangeWithBody("<message>hello!</message>");
    Exchange out = template.send("direct:a", exchange);
    assertNotNull(out);
    String uuid = out.getOut().getBody(String.class);
    assertNull("Expected body to be null, found JCR node UUID", uuid);
    assertTrue("Wrong exception type", out.getException() instanceof LoginException);
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
private boolean checkLogin(Repository repository) throws RepositoryException {
	boolean loginSuccessful = true;
	Credentials credentials = new SimpleCredentials(userId, userPassword.toCharArray());
	try {
		repository.login(credentials).logout();
	} catch (LoginException e) {
		loginSuccessful = false;
	}
	return loginSuccessful;
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
/**
 * Fetching paged node items.
 *
 * @param statement     SQL2 statement
 * @param maxResultSize Max results returned
 * @param pageNumber    paging number
 * @param workspace     Workspace in repostory.
 * @param nodeType      Node type.
 * @throws javax.jcr.LoginException Login exception.
 * @throws RepositoryException Handling RepositoryException.
 */
protected void executePagedNodesQuery(String statement, int maxResultSize, int pageNumber, String workspace, String nodeType) throws LoginException, RepositoryException {
    List<Node> nodeList = new ArrayList<Node>(0);
    List<Node> nodeListPaged = new ArrayList<Node>(0);
    NodeIterator items = QueryUtil.search(workspace, statement, Query.JCR_SQL2, nodeType);
    while (items.hasNext()) {
        nodeList.add(new I18nNodeWrapper(items.nextNode()));
    }
    int total = nodeList.size();

    // Paging result set
    int startRow = (maxResultSize * (pageNumber - 1));
    int newLimit = maxResultSize;
    if (total > startRow) {
        if (total < startRow + maxResultSize) {
            newLimit = total - startRow;
        }
        nodeListPaged = nodeList.subList(startRow, startRow + newLimit);
    }

    int calcNumPages = total / maxResultSize;
    if ((total % maxResultSize) > 0) {
        calcNumPages++;
    }
    // Set template model properties
    setCount(total);
    setNumPages(calcNumPages);
    setSearchResults(templatingFunctions.asContentMapList(nodeListPaged));
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
public void initialise(Session session) throws LoginException, RepositoryException {
	final NamespaceRegistry registry = session.getWorkspace().getNamespaceRegistry();
	
	if (!Arrays.asList(registry.getPrefixes()).contains("ocm")) {
		session.getWorkspace().getNamespaceRegistry().registerNamespace("ocm", "http://jackrabbit.apache.org/ocm");
	}
	
	Node rootNode = session.getRootNode();
	for( String nodeName : this.mainNodes){
		if(!rootNode.hasNode(nodeName)){
			rootNode.addNode(nodeName);
		}
	}
	session.save();
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
/**
 * Creates a JCR session based upon the provided credentials
 * @param username the username
 * @param password the password
 * @return a {@link javax.jcr.Session}
 * @throws LoginException
 */
public static Session createSession(String username, String password) throws LoginException {
    Session session = null;
    try {
        final HippoRepository repository = HippoRepositoryFactory.getHippoRepository();
        session = repository.login(username, password.toCharArray());
    } catch (LoginException le) {
        throw new LoginException(le);
    } catch (RepositoryException e) {
        log.error("An exception occurred: {}", e);
    }
    return session;
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
public static Repository mockRepository() throws LoginException,
                                         RepositoryException {
    final Repository mockRepo = mock(Repository.class);
    when(mockRepo.login()).thenReturn(
            mock(org.modeshape.jcr.api.Session.class, Mockito.withSettings().extraInterfaces(Session.class)));
    return mockRepo;
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Override
public Session login() throws LoginException, RepositoryException {
	return adminSession = repository.login();
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
public byte[] fetch(final String path) throws LoginException, RepositoryException, IOException {
	if (repository == null) {
		throw new RepositoryException("repo failed to initialize");
	}
	return get(path);
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
public void store(final String path, final byte[] content) throws LoginException, RepositoryException {
	if (repository == null) {
		throw new RepositoryException("repo failed to initialize");
	}
	set(path, content);
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Test(expected = RepositoryException.class)
public void fetchRepositoryNull() throws LoginException, RepositoryException, IOException {
	warehouse = new JcrDAO(null);
	warehouse.fetch("");
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Override
public Session impersonate(Credentials credentials) throws LoginException, RepositoryException {
    return this;
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Override
public Session login(Credentials credentials, String workspaceName) throws LoginException, NoSuchWorkspaceException, RepositoryException {
    return session;
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
@Override
public Session loginService(String s, String s1) throws LoginException, RepositoryException {
    return session;
}
 

import javax.jcr.LoginException; //导入依赖的package包/类
/**
 * Jcr exception translator - it converts specific JSR-170 checked exceptions into unchecked Spring DA
 * exception.
 * @author Guillaume Bort <[email protected]>
 * @author Costin Leau
 * @author Sergio Bossa
 * @author Salvatore Incandela
 * @param ex
 * @return
 */
public static DataAccessException translateException(RepositoryException ex) {
    if (ex instanceof AccessDeniedException) {
        return new DataRetrievalFailureException("Access denied to this data", ex);
    }
    if (ex instanceof ConstraintViolationException) {
        return new DataIntegrityViolationException("Constraint has been violated", ex);
    }
    if (ex instanceof InvalidItemStateException) {
        return new ConcurrencyFailureException("Invalid item state", ex);
    }
    if (ex instanceof InvalidQueryException) {
        return new DataRetrievalFailureException("Invalid query", ex);
    }
    if (ex instanceof InvalidSerializedDataException) {
        return new DataRetrievalFailureException("Invalid serialized data", ex);
    }
    if (ex instanceof ItemExistsException) {
        return new DataIntegrityViolationException("An item already exists", ex);
    }
    if (ex instanceof ItemNotFoundException) {
        return new DataRetrievalFailureException("Item not found", ex);
    }
    if (ex instanceof LoginException) {
        return new DataAccessResourceFailureException("Bad login", ex);
    }
    if (ex instanceof LockException) {
        return new ConcurrencyFailureException("Item is locked", ex);
    }
    if (ex instanceof MergeException) {
        return new DataIntegrityViolationException("Merge failed", ex);
    }
    if (ex instanceof NamespaceException) {
        return new InvalidDataAccessApiUsageException("Namespace not registred", ex);
    }
    if (ex instanceof NoSuchNodeTypeException) {
        return new InvalidDataAccessApiUsageException("No such node type", ex);
    }
    if (ex instanceof NoSuchWorkspaceException) {
        return new DataAccessResourceFailureException("Workspace not found", ex);
    }
    if (ex instanceof PathNotFoundException) {
        return new DataRetrievalFailureException("Path not found", ex);
    }
    if (ex instanceof ReferentialIntegrityException) {
        return new DataIntegrityViolationException("Referential integrity violated", ex);
    }
    if (ex instanceof UnsupportedRepositoryOperationException) {
        return new InvalidDataAccessApiUsageException("Unsupported operation", ex);
    }
    if (ex instanceof ValueFormatException) {
        return new InvalidDataAccessApiUsageException("Incorrect value format", ex);
    }
    if (ex instanceof VersionException) {
        return new DataIntegrityViolationException("Invalid version graph operation", ex);
    }
    // fallback
    return new JcrSystemException(ex);
}