import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
protected void initUserRoleListService() {
  
  //If SAML is selected, default to the native user role list service
  if( getSelectedAuthorizationProvider().equals( getSamlId() ) ) {
    setService( getSamlUserRoleListService() );
    return;
  }

  Map<String, String> props = new HashMap<>();
  props.put( PROVIDER_NAME, getSelectedAuthorizationProvider() );

  IUserRoleListService userRoleListService;

  if ( ( userRoleListService = PentahoSystem.get( IUserRoleListService.class, null, props ) ) != null ) {

    setService( userRoleListService );

  } else {
    logger.error( "No IUserRoleListService found for providerName '" + getSelectedAuthorizationProvider() + "'" );
  }
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
@Test
public void testCreateProxy() throws Exception {
  ProxyFactoryImpl proxyFactory = new ProxyFactoryImpl( null );
  IProxyCreator<String> creator = mock( IProxyCreator.class );
  when( creator.supports( String.class )).thenReturn( true );

  String target = "Hello World";
  when( creator.create( target ) ).thenReturn( "Good Night" );
  proxyFactory.setCreators( Collections.<IProxyCreator<?>>singletonList( creator ) );

  IProxyRegistration proxy = proxyFactory
      .createAndRegisterProxy( target, Collections.<Class<?>>singletonList( CharSequence.class ),
          Collections.<String, Object>singletonMap( "key", "master" ) );
  assertNotNull( proxy );

  CharSequence registeredString = PentahoSystem.get( CharSequence.class, null, Collections.singletonMap( "key", "master" ) );
  assertEquals( "Good Night", registeredString );

  // Test plain create
  String plainProxy = proxyFactory.createProxy( target );
  assertNotNull( proxy );
  assertEquals( "Good Night", plainProxy );

}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
protected <T extends IDBDatasourceService> DataSource getNamedDataSourceFromService(
  Class<T> dataSourceServiceInterface, String dataSourceName ) throws DataSourceNamingException {
  T datasourceService = PentahoSystem.get( dataSourceServiceInterface, null );

  IDBDatasourceService service =
    ( datasourceService == null ) ? PentahoSystem.get( IDBDatasourceService.class, null ) : datasourceService;

  if ( service != null ) {
    try {
      return service.getDataSource( dataSourceName );
    } catch ( DBDatasourceServiceException ex ) {
      throw new DataSourceNamingException( ex );
    }
  }
  return null;
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
private TransMeta createTransMetaJCR( Repository repository ) throws ActionExecutionException {
  TransMeta transMeta = new TransMeta();
  try {

    IUnifiedRepository unifiedRepository = PentahoSystem.get( IUnifiedRepository.class, null );
    RepositoryFile transFile = unifiedRepository.getFile( idTopath( transformation ) );
    transMeta = repository.loadTransformation( new StringObjectId( (String) transFile.getId() ), null );
  } catch ( Throwable e ) {
    throw new ActionExecutionException( org.pentaho.platform.plugin.kettle.messages.Messages.getInstance()
        .getErrorString( "PdiAction.ERROR_0006_FAILED_TRANSMETA_CREATION", directory, transformation ), e ); //$NON-NLS-1$
  }
  if ( arguments != null ) {
    transMeta.setArguments( arguments );
  }
  if ( logLevel != null ) {
    transMeta.setLogLevel( LogLevel.getLogLevelForCode( logLevel ) );
  }

  populateInputs( transMeta, transMeta );

  return transMeta;
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
private JobMeta createJobMetaJCR( Repository repository ) throws ActionExecutionException {
  JobMeta jobMeta = new JobMeta();
  try {

    IUnifiedRepository unifiedRepository = PentahoSystem.get( IUnifiedRepository.class, null );
    RepositoryFile jobFile = unifiedRepository.getFile( idTopath( job ) );
    jobMeta = repository.loadJob( new StringObjectId( (String) jobFile.getId() ), null );
  } catch ( Throwable e ) {
    throw new ActionExecutionException( org.pentaho.platform.plugin.kettle.messages.Messages.getInstance()
        .getErrorString( "PdiAction.ERROR_0006_FAILED_TRANSMETA_CREATION", directory, transformation ), e ); //$NON-NLS-1$
  }
  if ( arguments != null ) {
    jobMeta.setArguments( arguments );
  }
  if ( logLevel != null ) {
    jobMeta.setLogLevel( LogLevel.getLogLevelForCode( logLevel ) );
  }

  populateInputs( jobMeta, jobMeta );

  return jobMeta;
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
@Override
public void createContent( OutputStream outputStream ) throws Exception {

  IPluginResourceLoader resourceLoader = PentahoSystem.get( IPluginResourceLoader.class );
  IPluginManager pluginManager = PentahoSystem.get( IPluginManager.class );
  ClassLoader classLoader = pluginManager.getClassLoader( pluginId );
  String filePath = !viewerFilePath.startsWith( "/" ) ? "/" + viewerFilePath : viewerFilePath;

  String viewer =
      IOUtils
          .toString( resourceLoader.getResourceAsStream( classLoader, filePath ), LocaleHelper.getSystemEncoding() );

  viewer = doResourceReplacement( viewer );

  InputStream is = IOUtils.toInputStream( viewer, LocaleHelper.getSystemEncoding() );

  IOUtils.copy( is, outputStream );
  outputStream.flush();
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的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.PentahoSystem; //导入依赖的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.PentahoSystem; //导入依赖的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.PentahoSystem; //导入依赖的package包/类
@Override
public List<String> getSystemRoles() {
  if ( systemRoles == null ) {
    systemRoles = PentahoSystem.get( ArrayList.class, "singleTenantSystemAuthorities", null );
  }
  return systemRoles;
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
public static GrantedAuthority getDefaultRole() {
  if ( defaultRole == null ) {
    String defaultRoleAsString = PentahoSystem.get( String.class, "defaultRole", null );
    if ( defaultRoleAsString != null && defaultRoleAsString.length() > 0 ) {
      defaultRole = new SimpleGrantedAuthority( defaultRoleAsString );
    }
  }
  return defaultRole;
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
public KarafFeatureWatcherImpl( BundleContext bundleContext ) {

    this.bundleContext = bundleContext;
    // Default timeout of 2 minutes can be overridden in server.properties
    timeout =
        PentahoSystem.getApplicationContext().getProperty( KARAF_TIMEOUT_PROPERTY ) == null ? 2 * 60 * 1000L : Long
            .valueOf( PentahoSystem.getApplicationContext().getProperty( KARAF_TIMEOUT_PROPERTY ) );
  }
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
public KarafBlueprintWatcherImpl( BundleContext bundleContext ) {

    this.bundleContext = bundleContext;
    // Default timeout of 2 minutes can be overridden in server.properties
    timeout =
      PentahoSystem.getApplicationContext().getProperty( KARAF_TIMEOUT_PROPERTY ) == null ? 2 * 60 * 1000L : Long
        .valueOf( PentahoSystem.getApplicationContext().getProperty( KARAF_TIMEOUT_PROPERTY ) );
  }
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
@Test
@SuppressWarnings( "unchecked" )
public void testStart() throws Exception {
  BundleContext bundleContext = mock( BundleContext.class );
  ServiceReference<ConfigurationAdmin> adminRef = (ServiceReference<ConfigurationAdmin>) mock( ServiceReference.class);
  when( bundleContext.getServiceReference( ConfigurationAdmin.class )).thenReturn( adminRef );

  ConfigurationAdmin configurationAdmin = mock(ConfigurationAdmin.class);
  when( bundleContext.getService( adminRef )).thenReturn( configurationAdmin );

  Configuration config = mock( Configuration.class );
  when(configurationAdmin.getConfiguration( "org.pentaho.requirejs", null )).thenReturn( config );

  IApplicationContext applicationContext = mock(IApplicationContext.class);
  PentahoSystem.init(applicationContext);

  when(applicationContext.getFullyQualifiedServerURL()).thenReturn("http://localhost:8080/pentaho");
  when(applicationContext.getContext()).thenReturn( mock( ServletContext.class ) );

  ArgumentCaptor<Dictionary> params = ArgumentCaptor.forClass( Dictionary.class );

  PentahoOSGIActivator activator = new PentahoOSGIActivator();
  activator.start( bundleContext );

  verify( config, times( 1 ) ).update( params.capture() );
  assertEquals("/pentaho/osgi/", params.getValue().get( "context.root" ));

  reset(config);

  when(applicationContext.getFullyQualifiedServerURL()).thenReturn("http://localhost:8080/");
  activator.start( bundleContext );
  verify( config, times( 1 ) ).update( params.capture() );
  assertEquals("/osgi/", params.getValue().get( "context.root" ));

  activator.stop( bundleContext );

}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
@Override
@SuppressWarnings( "unchecked" )
public <T, K> IProxyRegistration createAndRegisterProxy( T target, List<Class<?>> publishedClasses,
                                                         Map<String, Object> properties )
    throws ProxyException {

  publishedClasses = new ArrayList<>( publishedClasses );
  K proxyWrapper = createProxy( target );

  Class<K> proxyWrapperClass = (Class<K>) proxyWrapper.getClass();
  Class parent = proxyWrapperClass;
  while ( parent != null ) {
    publishedClasses.add( parent );
    parent = parent.getSuperclass();
  }

  for ( Class<?> aClass : proxyWrapperClass.getInterfaces() ) {
    publishedClasses.add( aClass );
  }

  IPentahoObjectReference reference =
      new SingletonPentahoObjectReference.Builder<K>( proxyWrapperClass ).object( proxyWrapper )
          .attributes( properties ).build();

  IPentahoObjectRegistration iPentahoObjectRegistration = PentahoSystem
      .registerReference( reference, publishedClasses.toArray( new Class<?>[ publishedClasses.size() ] ) );
  return new ProxyRegistration( iPentahoObjectRegistration, proxyWrapper );

}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
@Test
public void testProxyRegistration() throws ProxyException {
  ProxyFactoryImpl proxyFactory = new ProxyFactoryImpl( null );
  IProxyCreator<String> creator = mock( IProxyCreator.class );
  when( creator.supports( String.class )).thenReturn( true );

  String target = "Hello World";
  when( creator.create( target ) ).thenReturn( "Good Night" );
  proxyFactory.setCreators( Collections.<IProxyCreator<?>>singletonList( creator ) );

  IProxyRegistration proxy = proxyFactory
      .createAndRegisterProxy( target, Collections.<Class<?>>singletonList( CharSequence.class ),
          Collections.<String, Object>singletonMap( "key", "master" ) );
  assertNotNull( proxy );
  assertEquals( "Good Night", proxy.getProxyObject() );


  // Found in PentahoSystem
  CharSequence registeredString = PentahoSystem.get( CharSequence.class, null,
      Collections.singletonMap( "key", "master" ) );
  assertEquals( "Good Night", registeredString );

  // De-register then make sure removed from PentahoSystem.
  proxy.getPentahoObjectRegistration().remove();
  registeredString = PentahoSystem.get( CharSequence.class, null,
      Collections.singletonMap( "key", "master" ) );
  assertNull( registeredString );
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
public static Object get(IPentahoSession session, String key) {

        Object value = null;
        ICacheManager manager = PentahoSystem.getCacheManager(session);

        if (manager != null) {
            value = manager.getFromSessionCache(session, key);
        }

        return value;
    }
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
public static void remove(IPentahoSession session, String key) {

        ICacheManager manager = PentahoSystem.getCacheManager(session);

        if (manager != null) {
            manager.removeFromSessionCache(session, key);
        }
    }
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
protected OutputStream getOutputStream(String mimeType) throws Exception {
  if (outputHandler == null) {
    throw new Exception("No output handler");
  }
  IContentItem contentItem = outputHandler.getOutputContentItem("response", "content", instanceId, mimeType);
  if (contentItem == null) {
    throw new Exception("No content item");
  }
  OutputStream outputStream = contentItem.getOutputStream(null);
  if (outputStream == null || !PentahoSystem.getInitializedOK() ) {
    throw new Exception("No output stream"); //$NON-NLS-1$
  }
  return outputStream;
}
 

import org.pentaho.platform.engine.core.system.PentahoSystem; //导入依赖的package包/类
/**
 * Called just prior to the plugin being registered
 * with the platform.  Note: This event does *not*
 * precede the detection of the plugin by any {@link IPluginProvider}s
 * @throws PluginLifecycleException if an error occurred
 */
public void init() throws PluginLifecycleException {
  try {
    PedisLifecycleListener.instance = this;
    resourceLoader = PentahoSystem.get(IPluginResourceLoader.class, null);
    initPluginDir();
    initPermissions();
    defaultContentType = getPluginSetting(DEFAULT_CONTENT_TYPE_SETTINGS, defaultContentType);
    debugEnabled = getPluginSetting(DEBUG_ENABLED_SETTINGS, debugEnabled);
  } catch (Exception exception) {
    throw new PluginLifecycleException("An error occurred while loading the plugin.", exception);
  }
}