public boolean isEmpty() { return size() == 0; }
@Override public Results searchCollectionConsistent( String collectionName, Query query, int expectedResults ) throws Exception { Results results; long maxLength = entityManagerFig.pollForRecordsTimeout(); long sleepTime = entityManagerFig.sleep(); boolean found; long current = System.currentTimeMillis(), length = 0; do { results = searchCollection( collectionName, query ); length = System.currentTimeMillis() - current; found = expectedResults == results.size(); if ( found ) { break; } logger.info("Sleeping {} ms during searchCollectionConsistent", sleepTime); Thread.sleep( sleepTime ); } while ( !found && length <= maxLength ); logger.info( "Consistent Search finished in {}, results={}, expected={}...dumping stack", length, results.size(), expectedResults ); return results; }
@Override public boolean hasNext() { if ( source == null ) { return false; } if ( currentIterator != null && currentIterator.hasNext() ) { return true; } while ( source.hasNext() ) { EntityRef ref = source.next(); Results r = getResultsFor( ref ); if ( r.size() > 0 ) { currentIterator = new PagingResultsIterator( r, query.getResultsLevel(), null); return currentIterator.hasNext(); } } currentIterator = null; source = null; return false; }
public int calculatePasswordHistorySizeForUser( UUID userId ) throws Exception { if(logger.isTraceEnabled()){ logger.trace( "calculatePasswordHistorySizeForUser {}", userId.toString() ); } int size = 0; EntityManager em = emf.getEntityManager( smf.getManagementAppId() ); Results orgResults = em.getCollection( new SimpleEntityRef( User.ENTITY_TYPE, userId ), Schema.COLLECTION_GROUPS, null, 10000, Level.REFS, false ); if(logger.isTraceEnabled()){ logger.trace(" orgResults.size() = {}", orgResults.size()); } for ( EntityRef orgRef : orgResults.getRefs() ) { Map<Object, Object> properties = em.getDictionaryAsMap( orgRef, ORGANIZATION_PROPERTIES_DICTIONARY ); if ( properties != null ) { OrganizationInfo orgInfo = new OrganizationInfo( null, null, properties ); if(logger.isTraceEnabled()){ logger.trace( " orgInfo.getPasswordHistorySize() = {}", orgInfo.getPasswordHistorySize() ); } size = Math.max( orgInfo.getPasswordHistorySize(), size ); } } return size; }
@Override public List<OrganizationInfo> getOrganizations( UUID startResult, int count ) throws Exception { // still need the bimap to search for existing BiMap<UUID, String> organizations = HashBiMap.create(); EntityManager em = emf.getEntityManager(smf.getManagementAppId()); Results results = em.getCollection(em.getApplicationRef(), Schema.COLLECTION_GROUPS, startResult, count, Level.ALL_PROPERTIES, false); List<OrganizationInfo> orgs = new ArrayList<>( results.size() ); OrganizationInfo orgInfo; for ( Entity entity : results.getEntities() ) { String path = ( String ) entity.getProperty( PROPERTY_PATH ); if ( organizations.containsValue( path ) ) { path += "DUPLICATE"; } orgInfo = new OrganizationInfo( entity.getUuid(), path ); orgs.add( orgInfo ); organizations.put( entity.getUuid(), path ); } return orgs; }
@Override public JobStat getStatsForJob( String jobName, UUID jobId ) throws Exception { EntityManager em = emf.getEntityManager( emf.getManagementAppId() ); Query query = Query.fromQL( "select * where " + JOB_NAME + " = '" + jobName + "' AND " + JOB_ID + " = " + jobId ); Results r = em.searchCollection( em.getApplicationRef(), "job_stats", query ); if ( r.size() == 1 ) { return ( JobStat ) r.getEntity(); } return null; }
@Override public void removeAdminUserFromOrganization( UUID userId, UUID organizationId, boolean force ) throws Exception { if ( ( userId == null ) || ( organizationId == null ) ) { return; } EntityManager em = emf.getEntityManager( smf.getManagementAppId() ); try { Results collection = em.getCollection( new SimpleEntityRef( Group.ENTITY_TYPE, organizationId ), "users", null, 2, Level.IDS, false ); int size = collection.size(); if ( !force && (size == 0 || (size == 1 && collection.getId() == userId))) { throw new Exception(); } } catch ( Exception e ) { throw new UnableToLeaveOrganizationException( "Organizations must have at least one member." ); } em.removeFromCollection(new SimpleEntityRef(Group.ENTITY_TYPE, organizationId), "users", new SimpleEntityRef(User.ENTITY_TYPE, userId)); invalidateManagementAppAuthCache(); }
@Test public void testCreateAndDelete() throws Exception { logger.info( "EntityDaoTest.testCreateAndDelete" ); EntityManager em = app.getEntityManager(); String name = "test.thing" + UUIDUtils.newTimeUUID(); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "name", name ); properties.put( "foo", "bar" ); logger.info( "Starting entity create" ); Entity thing = em.create( "thing", properties ); logger.info( "Entity created" ); app.waitForQueueDrainAndRefreshIndex(); logger.info( "Starting entity delete" ); em.delete( thing ); logger.info( "Entity deleted" ); app.waitForQueueDrainAndRefreshIndex(); // now search by username, no results should be returned final Query emailQuery = Query.fromQL( "name = '" + name + "'" ); Results r = em.searchCollection( em.getApplicationRef(), "thing", emailQuery ); assertEquals( 0, r.size() ); }
@Test public void testKeywordsOrQuery() throws Exception { logger.debug( "testKeywordsOrQuery" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "title", "Galactians 2" ); properties.put( "keywords", "Hot, Space Invaders, Classic" ); em.create( "game", properties ); properties = new LinkedHashMap<String, Object>(); properties.put( "title", "Bunnies Extreme" ); properties.put( "keywords", "Hot, New" ); em.create( "game", properties ); properties = new LinkedHashMap<String, Object>(); properties.put( "title", "Hot Shots" ); properties.put("keywords", "Action, New"); em.create( "game", properties ); app.waitForQueueDrainAndRefreshIndex(); Query query = Query.fromQL( "select * where keywords contains 'hot' or title contains 'hot'" ); Results r = em.searchCollection( em.getApplicationRef(), "games", query ); logger.info(JsonUtils.mapToFormattedJsonString(r.getEntities())); assertEquals( 3, r.size() ); }
@Test public void testSelectTerms() throws Exception { logger.debug( "testSelectTerms" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "username", "edanuff" ); properties.put( "email", "ed@anuff.com" ); em.create( "user", properties ); app.waitForQueueDrainAndRefreshIndex(); String s = "select username, email where username = 'edanuff'"; Query query = Query.fromQL( s ); Results r = em.searchCollection( em.getApplicationRef(), "users", query ); assertTrue( r.size() == 1 ); // selection results should be a list of lists // List<Object> sr = query.getSelectionResults( r ); // assertTrue( sr.size() == 1 ); // List firstResult = ( List ) sr.get( 0 ); // assertTrue( "edanuff".equals( firstResult.get( 0 ) ) ); // assertTrue( "ed@anuff.com".equals( firstResult.get( 1 ) ) ); }
@Test public void testRedefineTerms() throws Exception { logger.debug( "testRedefineTerms" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "username", "edanuff" ); properties.put( "email", "ed@anuff.com" ); em.create( "user", properties ); app.waitForQueueDrainAndRefreshIndex(); String s = "select {name: username, email: email} where username = 'edanuff'"; Query query = Query.fromQL( s ); Results r = em.searchCollection( em.getApplicationRef(), "users", query ); assertTrue( r.size() == 1 ); // TODO: do we need selection results? // selection results should be a list of lists // List<Object> sr = query.getSelectionResults( r ); // assertTrue( sr.size() == 1 ); // Map firstResult = ( Map ) sr.get( 0 ); // assertTrue( "edanuff".equals( firstResult.get( "name" ) ) ); // assertTrue( "ed@anuff.com".equals( firstResult.get( "email" ) ) ); }
@Test public void groupTitleSearch() throws Exception { logger.debug( "groupTitleSearch" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); String titleName = "groupName" + UUIDUtils.newTimeUUID(); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "title", titleName ); properties.put( "path", "testPath" ); properties.put( "name", "testName" ); Entity group = em.create( "group", properties ); assertNotNull( group ); app.waitForQueueDrainAndRefreshIndex(); // EntityRef final Query query = Query.fromQL( "title = '" + titleName + "'" ); Results r = em.searchCollection( em.getApplicationRef(), "groups", query ); assertTrue( r.size() > 0 ); Entity returned = r.getEntities().get( 0 ); assertEquals( group.getUuid(), returned.getUuid() ); }
@Test public void groupNameSearch() throws Exception { logger.debug( "groupNameSearch" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); String groupName = "groupName" + UUIDUtils.newTimeUUID(); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "title", "testTitle" ); properties.put( "path", "testPath" ); properties.put( "name", groupName ); Entity group = em.create( "group", properties ); assertNotNull( group ); app.waitForQueueDrainAndRefreshIndex(); // EntityRef final Query query = Query.fromQL( "name = '" + groupName + "'" ); Results r = em.searchCollection( em.getApplicationRef(), "groups", query ); assertTrue( r.size() > 0 ); Entity returned = r.getEntities().get( 0 ); assertEquals( group.getUuid(), returned.getUuid() ); }
@Test public void userLastNameSearch() throws Exception { logger.debug( "userLastNameSearch" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); String lastName = "lastName" + UUIDUtils.newTimeUUID(); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "username", "edanuff" ); properties.put( "email", "ed@anuff.com" ); properties.put( "lastname", lastName ); Entity user = em.create( "user", properties ); assertNotNull( user ); app.waitForQueueDrainAndRefreshIndex(); // EntityRef final Query query = Query.fromQL( "lastname = '" + lastName + "'" ); Results r = em.searchCollection( em.getApplicationRef(), "users", query ); assertTrue( r.size() > 0 ); Entity returned = r.getEntities().get( 0 ); assertEquals( user.getUuid(), returned.getUuid() ); }
@Test public void userMiddleNameSearch() throws Exception { logger.debug( "userMiddleNameSearch" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); String middleName = "middleName" + UUIDUtils.newTimeUUID(); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "username", "edanuff" ); properties.put( "email", "ed@anuff.com" ); properties.put( "middlename", middleName ); Entity user = em.create( "user", properties ); assertNotNull( user ); app.waitForQueueDrainAndRefreshIndex(); // EntityRef final Query query = Query.fromQL( "middlename = '" + middleName + "'" ); Results r = em.searchCollection( em.getApplicationRef(), "users", query ); assertTrue( r.size() > 0 ); Entity returned = r.getEntities().get( 0 ); assertEquals( user.getUuid(), returned.getUuid() ); }
@Test public void nameIdentifierTest() throws Exception { logger.debug( "nameIdentifierTest" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "keywords", "blah,test,game" ); properties.put( "title", "Solitaire" ); properties.put( "name", "test" ); Entity game1 = em.create( "games", properties ); assertNotNull( game1 ); //we create 2 entities, otherwise this test will pass when it shouldn't properties.put( "name", "test2" ); Entity game2 = em.create( "game", properties ); assertNotNull( game2 ); app.waitForQueueDrainAndRefreshIndex(); // overlap Query query = new Query(); query.addIdentifier( Identifier.fromName( "test" ) ); Results r = em.searchCollection( em.getApplicationRef(), "games", query ); assertEquals( "We should only get 1 result", 1, r.size() ); assertNull( "No cursor should be present", r.getCursor() ); assertEquals( "Saved entity returned", game1, r.getEntity() ); }
private void checkApplicationsOk( String orgName) throws Exception { if (logger.isDebugEnabled()) { logger.debug("\n\nChecking applications OK\n"); } for (int i=0; i<10; i++) { String appName = orgName + "/application" + i; UUID uuid = setup.getEmf().lookupApplication(appName); assertTrue ("Should be able to get application", uuid != null ); EntityManager em = setup.getEmf().getEntityManager( uuid ); Application app = em.getApplication(); assertEquals( appName, app.getName() ); Results results = em.searchCollection( em.getApplicationRef(), "things", Query.fromQL("select *")); assertEquals( "Should have 10 entities", 10, results.size() ); } }
@Test public void uuidIdentifierTest() throws Exception { logger.debug( "uuidIdentifierTest" ); EntityManager em = app.getEntityManager(); assertNotNull( em ); Map<String, Object> properties = new LinkedHashMap<String, Object>(); properties.put( "keywords", "blah,test,game" ); properties.put( "title", "Solitaire" ); Entity game1 = em.create( "game", properties ); assertNotNull( game1 ); //we create 2 entities, otherwise this test will pass when it shouldn't Entity game2 = em.create( "game", properties ); assertNotNull( game2 ); app.waitForQueueDrainAndRefreshIndex(); // overlap Query query = new Query(); query.addIdentifier( Identifier.fromUUID( game1.getUuid() ) ); Results r = em.searchCollection( em.getApplicationRef(), "games", query ); assertEquals( "We should only get 1 result", 1, r.size() ); assertNull( "No cursor should be present", r.getCursor() ); assertEquals( "Saved entity returned", game1, r.getEntity() ); }
private int countEntities( EntityManager em, String collectionName, int expectedEntities) throws Exception { app.waitForQueueDrainAndRefreshIndex(); Query q = Query.fromQL( "select * where key1=1000" ).withLimit( 1000 ); Results results = em.searchCollectionConsistent( em.getApplicationRef(), collectionName, q, expectedEntities ); int count = 0; while ( true ) { count += results.size(); if ( results.hasCursor() ) { logger.info( "Counted {} : query again with cursor", count ); q.setCursor( results.getCursor() ); results = em.searchCollection( em.getApplicationRef(), collectionName, q ); } else { break; } } assertEquals( "Did not get expected entities", expectedEntities, count ); return count; }
private int countEntities( EntityManager em, String collectionName, int expectedEntities) throws Exception { app.waitForQueueDrainAndRefreshIndex(); Query q = Query.fromQL( "select * where key1=1000" ).withLimit( 1000 ); Results results = em.searchCollectionConsistent( em.getApplicationRef(), collectionName, q, expectedEntities ); int count = 0; while ( true ) { count += results.size(); if ( results.hasCursor() ) { logger.info( "Counted {} : query again with cursor", count ); q.setCursor( results.getCursor() ); results = em.searchCollection( em.getApplicationRef(), collectionName, q ); } else { break; } } assertEquals( "Did not get expected entities", expectedEntities, count ); return count; }