Java PentahoSessionHolder类代码示例

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@Override
public String filter(String schemaUrl, Util.PropertyList connectInfo, InputStream stream)
	throws Exception {
		String schema = super.filter(schemaUrl, connectInfo, stream);
		System.out.println("[CUSTOM.DSP] *********** Started DSP Custom ***********");
		IPentahoSession session = PentahoSessionHolder.getSession();
		// if you need only the default Pentaho username session var, not a specific one,
		// you can change the code with: String usercode = session.getName().toString();
		// this avoid to use a startup kettle job
		String usercode = (String) session.getAttribute("USERNAME");
		try {
			System.out.println("[CUSTOM.DSP] Trying to replace '%USER_NAME%' with session value: "+usercode);
			LOG.info("Trying to replace '%USER_NAME%' with session value: "+usercode);
			schema = schema.replaceAll("%USER_NAME%", usercode);
		}
		catch (PatternSyntaxException pse) {
			System.out.println("[CUSTOM.DSP] Some error during custom schema processing: "+usercode);
			LOG.error("Some error during custom schema processing. " , pse);
			pse.printStackTrace();
		}
	LOG.info("DSP Ended correctly for "+usercode);
	System.out.println("[CUSTOM.DSP] *********** DSP Ended correctly for "+usercode+" ***********");
	return schema;
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@Override public void logout( HttpServletRequest request, HttpServletResponse response, Authentication auth ) {

    if( request != null && request.getAttribute( SPRING_SECURITY_CONTEXT_KEY ) != null ){
      logger.info( "Removing SPRING_SECURITY_CONTEXT_KEY from HttpServletRequest" );
      request.removeAttribute( SPRING_SECURITY_CONTEXT_KEY );
    }

    IPentahoSession pentahoSession = PentahoSessionHolder.getSession();

    if( pentahoSession != null ) {

      if( pentahoSession.getAttribute( IPentahoSession.SESSION_ROLES ) != null ) {
        logger.info( "Removing IPentahoSession.SESSION_ROLES from IPentahoSession" );
        pentahoSession.removeAttribute( IPentahoSession.SESSION_ROLES );
      }

      logger.info( "Marking IPentahoSession as *not* authenticated" );
      pentahoSession.setNotAuthenticated();
    }
  }
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@Before
public void init() throws PlatformInitializationException {
  System.setProperty( "java.naming.factory.initial", "org.osjava.sj.SimpleContextFactory" );
  System.setProperty( "org.osjava.sj.root", "test-src/simple-jndi" );
  System.setProperty( "org.osjava.sj.delimiter", "/" );
  System.setProperty( "PENTAHO_SYS_CFG_PATH", new File( SOLUTION_REPOSITORY + "/pentaho.xml" ).getAbsolutePath() );

  IPentahoSession session = new StandaloneSession();
  PentahoSessionHolder.setSession( session );

  mp.define( IUserRoleListService.class, StubUserRoleListService.class );
  mp.define( UserDetailsService.class, StubUserDetailService.class );
  mp.defineInstance( IAuthorizationPolicy.class, new TestAuthorizationPolicy() );
  mp.setSettingsProvider( new PathBasedSystemSettings() );
  mp.define( ISolutionEngine.class, SolutionEngine.class );
  FileSystemBackedUnifiedRepository repo =  new FileSystemBackedUnifiedRepository( SOLUTION_REPOSITORY );
  mp.defineInstance(  IUnifiedRepository.class, repo );

  mp.start();

  SecurityHelper.getInstance().becomeUser( TEST_USER );
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@Override
public Repository connect( String repositoryName ) throws KettleException {

  IPentahoSession session = PentahoSessionHolder.getSession();
  if ( session == null ) {
    logger.debug( "No active Pentaho Session, attempting to load PDI repository unauthenticated." );
    throw new KettleException( "Attempting to create PDI Repository with no Active PentahoSession. "
        + "This is not allowed." );
  }
  ICacheManager cacheManager = PentahoSystem.getCacheManager( session );

  String sessionName = session.getName();
  Repository repository = (Repository) cacheManager.getFromRegionCache( REGION, sessionName );
  if ( repository == null ) {
    logger.debug( "Repository not cached for user: " + sessionName + ". Creating new Repository." );
    repository = delegate.connect( repositoryName );
    if ( !cacheManager.cacheEnabled( REGION ) ) {
      cacheManager.addCacheRegion( REGION );
    }
    cacheManager.putInRegionCache( REGION, sessionName, repository );
  } else {
    logger.debug( "Repository was cached for user: " + sessionName );
  }
  return repository;
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@Test
public void testCachingFactoryConnect() throws Exception {
  ICacheManager cacheManager = mock( ICacheManager.class );
  PentahoSystem.registerObject( cacheManager );
  IPentahoSession session = new StandaloneSession( "joe" );
  PentahoSessionHolder.setSession( session );

  // Delegate is just a mock. connect will be a cache miss
  IRepositoryFactory mockFactory = mock( IRepositoryFactory.class );
  IRepositoryFactory.CachingRepositoryFactory cachingRepositoryFactory =
      new IRepositoryFactory.CachingRepositoryFactory( mockFactory );

  cachingRepositoryFactory.connect( "foo" );

  verify( mockFactory, times( 1 ) ).connect( "foo" );

  // Test with Cache Hit
  Repository mockRepository = mock( Repository.class );
  when( cacheManager.cacheEnabled( IRepositoryFactory.CachingRepositoryFactory.REGION ) ).thenReturn( true );
  when( cacheManager.getFromRegionCache( IRepositoryFactory.CachingRepositoryFactory.REGION, "joe" ) ).thenReturn(
      mockRepository );

  Repository repo = cachingRepositoryFactory.connect( "foo" );
  assertThat( repo, sameInstance( mockRepository ) );
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  this.testContextManager = new TestContextManager( getClass() );
  this.testContextManager.prepareTestInstance( this );

  KettleEnvironment.init();
  PentahoSessionHolder.setStrategyName( PentahoSessionHolder.MODE_GLOBAL );

  mockVersionManager();
  removePentahoRootFolder();
  startMicroPlatform();

  createSystemUser();
  createTester();

  createPurRepository();
  loginAsTester();
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
private void createUserHomeFolder( final ITenant theTenant, final String theUsername ) {
  IPentahoSession origPentahoSession = PentahoSessionHolder.getSession();
  Authentication origAuthentication = SecurityContextHolder.getContext().getAuthentication();

  String principleId = userNameUtils.getPrincipleId( theTenant, theUsername );
  String authenticatedRoleId = roleNameUtils.getPrincipleId( theTenant, tenantAuthenticatedRole );
  TransactionCallbackWithoutResult callback =
      PurRepositoryTestingUtils.createUserHomeDirCallback( theTenant, theUsername, principleId, authenticatedRoleId,
          repositoryFileDao );
  try {
    loginAsRepositoryAdmin();
    txnTemplate.execute( callback );
  } finally {
    PurRepositoryTestingUtils.setSession( origPentahoSession, origAuthentication );
  }
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@After
public void tearDown() throws Exception {
  cleanupUserAndRoles( testingTenant );
  cleanupUserAndRoles( systemTenant );

  unifiedRepository = null;
  purRepository = null;
  superAdminRole = repositoryAdmin = systemAdmin = tenantAdminRole = tenantAuthenticatedRole = null;
  tenantManager = null;
  userRoleDao = null;
  authorizationPolicy = null;
  roleBindingDaoTarget = null;
  testJcrTemplate = null;
  repositoryFileDao = null;
  txnTemplate = null;
  systemTenant = testingTenant = null;

  mp.stop();
  mp = null;

  JcrRepositoryFileUtils.setRepositoryVersionManager( existingVersionManager );
  PentahoSessionHolder.setStrategyName( PentahoSessionHolder.MODE_INHERITABLETHREADLOCAL );
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
protected void loginAsTenantAdmin() {
  StandaloneSession pentahoSession = new StandaloneSession( "joe" );
  pentahoSession.setAuthenticated( "joe" );
  pentahoSession.setAttribute( IPentahoSession.TENANT_ID_KEY, "acme" );
  final String password = "password";
  List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>( 3 );
  authorities.add( new SimpleGrantedAuthority( "Authenticated" ) );
  authorities.add( new SimpleGrantedAuthority( "acme_Authenticated" ) );
  authorities.add( new SimpleGrantedAuthority( "acme_Admin" ) );
  UserDetails userDetails = new User( "joe", password, true, true, true, true, authorities );
  Authentication auth = new UsernamePasswordAuthenticationToken( userDetails, password, authorities );
  PentahoSessionHolder.setSession( pentahoSession );
  // this line necessary for Spring Security's MethodSecurityInterceptor
  SecurityContextHolder.getContext().setAuthentication( auth );
  repositoryLifecyleManager.newTenant();
  repositoryLifecyleManager.newUser();
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
protected void createUserHomeFolder( final ITenant theTenant, final String theUsername ) {
  IPentahoSession origPentahoSession = PentahoSessionHolder.getSession();
  Authentication origAuthentication = SecurityContextHolder.getContext().getAuthentication();
  StandaloneSession pentahoSession = new StandaloneSession( repositoryAdminUsername );
  pentahoSession.setAuthenticated( null, repositoryAdminUsername );
  PentahoSessionHolder.setSession( pentahoSession );

  String principleId = userNameUtils.getPrincipleId( theTenant, theUsername );
  String authenticatedRoleId = roleNameUtils.getPrincipleId( theTenant, tenantAuthenticatedRoleName );
  TransactionCallbackWithoutResult callback =
      PurRepositoryTestingUtils.createUserHomeDirCallback( theTenant, theUsername, principleId, authenticatedRoleId,
          repositoryFileDao );
  try {
    txnTemplate.execute( callback );
  } finally {
    // Switch our identity back to the original user.
    PurRepositoryTestingUtils.setSession( origPentahoSession, origAuthentication );
  }
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
private void setUpUser() {
  StandaloneSession pentahoSession = new StandaloneSession( userInfo.getLogin() );
  pentahoSession.setAuthenticated( userInfo.getLogin() );
  pentahoSession.setAttribute( IPentahoSession.TENANT_ID_KEY, "/pentaho/" + EXP_TENANT );
  List<GrantedAuthority> authorities = new ArrayList<>( 2 );
  authorities.add( new SimpleGrantedAuthority( "Authenticated" ) );
  authorities.add( new SimpleGrantedAuthority( "acme_Authenticated" ) );
  final String password = "ignored"; //$NON-NLS-1$
  UserDetails userDetails = new User( userInfo.getLogin(), password, true, true, true, true, authorities );
  Authentication authentication = new UsernamePasswordAuthenticationToken( userDetails, password, authorities );
  // next line is copy of SecurityHelper.setPrincipal
  pentahoSession.setAttribute( "SECURITY_PRINCIPAL", authentication );
  PentahoSessionHolder.setSession( pentahoSession );
  SecurityContextHolder.setStrategyName( SecurityContextHolder.MODE_GLOBAL );
  SecurityContextHolder.getContext().setAuthentication( authentication );
  repositoryLifecyleManager.newTenant();
  repositoryLifecyleManager.newUser();
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
/**
 * Logs in with given username.
 * 
 * @param username
 *          username of user
 * @param tenantId
 *          tenant to which this user belongs
 * @tenantAdmin true to add the tenant admin authority to the user's roles
 */
private void login( final String username, final ITenant tenant, String[] roles ) {
  StandaloneSession pentahoSession = new StandaloneSession( username );
  pentahoSession.setAuthenticated( tenant.getId(), username );
  PentahoSessionHolder.setSession( pentahoSession );
  pentahoSession.setAttribute( IPentahoSession.TENANT_ID_KEY, tenant.getId() );
  final String password = "password";

  List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();

  if ( roles != null ) {
    for ( String roleName : roles ) {
      authorities.add( new SimpleGrantedAuthority( roleName ) );
    }
  }
  UserDetails userDetails = new User( username, password, true, true, true, true, authorities );
  Authentication auth = new UsernamePasswordAuthenticationToken( userDetails, password, authorities );
  PentahoSessionHolder.setSession( pentahoSession );
  // this line necessary for Spring Security's MethodSecurityInterceptor
  SecurityContextHolder.getContext().setAuthentication( auth );

  createUserHomeFolder( tenant, username );
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
private boolean clearMondrianCache() {

    try {
      // @see org.pentaho.platform.web.http.api.resources.SystemRefreshResource.flushMondrianSchemaCache();

      IPentahoSession session = PentahoSessionHolder.getSession();

      // Flush the catalog helper (legacy)
      IMondrianCatalogService
          mondrianCatalogService =
          PentahoSystem.get( IMondrianCatalogService.class, "IMondrianCatalogService", session ); //$NON-NLS-1$
      mondrianCatalogService.reInit( session );

      // Flush the IOlapService
      IOlapService olapService = PentahoSystem.get( IOlapService.class, IOlapService.class.getSimpleName(), session );
      olapService.flushAll( session );

    } catch ( Throwable t ) {
      logger.error( t.getMessage(), t );
        /* Do nothing.
         * <p/>
         * This is a simple 'nice-to-have' feature, where we actually clear mondrian cache after the user
         * makes a successful mondrian file change, so that he can immediately see its changes applied.
         * <p/>
         * In some off-chance this doesn't work, user can always do it via PUC > Tools > Refresh > Mondrian Cache.
        */
    }

    return true;
  }
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
@Override protected void service( HttpServletRequest req, HttpServletResponse resp )
    throws ServletException, IOException {

  // We are anonymous for now
  PentahoSessionHolder.setSession( new StandaloneSession( "bob" ) );

  IContentGenerator contentGenerator = (IContentGenerator) applicationContext.getBean( beanId );
  Thread.currentThread().setContextClassLoader( applicationContext.getClassLoader() );

  GeneratorStreamingOutput generatorStreamingOutput = new GeneratorStreamingOutput( contentGenerator,
      new ContentGeneratorDescriptor() {
        @Override public String getContentGeneratorId() {
          return null;
        }

        @Override public String getServicingFileType() {
          return null;
        }

        @Override public String getPluginId() {
          String requestURI = req.getRequestURI();
          if ( requestURI.contains( "/content" ) ) {
            return requestURI.substring( requestURI.indexOf( "/", 1 ) );
          }
          return null;
        }
      },
      req,
      resp,
      Collections.emptyList(),
      null,
      req.getPathInfo() != null ? req.getPathInfo().substring( 1 ) : beanId.substring( beanId.lastIndexOf( "." ) + 1 )
  );

  generatorStreamingOutput.write( resp.getOutputStream(), null );
}
 

import org.pentaho.platform.engine.core.system.PentahoSessionHolder; //导入依赖的package包/类
public static Object getSessionVariable( String varName ) {
  IPentahoSession session = PentahoSessionHolder.getSession();
  if ( session != null ) {
    return session.getAttribute( varName );
  }
  return null;
}