Java RepositoryElementInterface类代码示例

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
private void testTwoRevisions_DateAndCommentAreSaved( RepositoryElementInterface transOrJob ) throws Exception {
  final String elementName = "twoRevisions_" + transOrJob.getRepositoryElementType();

  final String comment1 = "first";
  final Calendar date1 = Calendar.getInstance();
  date1.setTimeInMillis( 0 );

  final String comment2 = "second";
  final Calendar date2 = Calendar.getInstance();
  date2.setTimeInMillis( 100 );

  transOrJob.setName( elementName );
  transOrJob.setRepositoryDirectory( purRepository.getDefaultSaveDirectory( transOrJob ) );

  purRepository.save( transOrJob, comment1, date1, null, false );
  assertCommentAndDate( transOrJob.getObjectRevision(), date1, comment1 );

  purRepository.save( transOrJob, comment2, date2, null, false );
  assertCommentAndDate( transOrJob.getObjectRevision(), date2, comment2 );

  List<VersionSummary> versions = assertExistsAndGetRevisions( transOrJob );
  assertEquals( 2, versions.size() );
  assertCommentAndDate( versions.get( 0 ), date1, comment1 );
  assertCommentAndDate( versions.get( 1 ), date2, comment2 );
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
@Test
public void loadAllShared() throws Exception {
  ClusterSchema cluster = cluster();
  DatabaseMeta database = database();
  SlaveServer slaveServer = slaveServer();
  PartitionSchema partition = partition();

  purRepository.save( cluster, null, null );
  purRepository.save( database, null, null );
  purRepository.save( slaveServer, null, null );
  purRepository.save( partition, null, null );

  Map<RepositoryObjectType, List<? extends SharedObjectInterface>> map = map();
  purRepository.readSharedObjects( map, RepositoryObjectType.CLUSTER_SCHEMA, RepositoryObjectType.DATABASE,
      RepositoryObjectType.SLAVE_SERVER, RepositoryObjectType.PARTITION_SCHEMA );

  RepositoryElementInterface[] saved = new RepositoryElementInterface[] { cluster, database, slaveServer, partition };
  assertEquals( saved.length, map.size() );
  for ( RepositoryElementInterface sharedObject : saved ) {
    List<? extends SharedObjectInterface> list = map.get( sharedObject.getRepositoryElementType() );
    assertEquals( 1, list.size() );
    assertEquals( sharedObject, list.get( 0 ) );
  }
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
@Test
public void doesNotChangeFileWhenFailsToRename_partitions() throws Exception {
  final PartitionSchema schema1 = new PartitionSchema();
  final PartitionSchema schema2 = new PartitionSchema();
  try {
    testDoesNotChangeFileWhenFailsToRename( schema1, schema2, new Callable<RepositoryElementInterface>() {
      @Override
      public RepositoryElementInterface call() throws Exception {
        return repository.loadPartitionSchema( schema2.getObjectId(), null );
      }
    } );
  } finally {
    repository.deletePartitionSchema( schema1.getObjectId() );
    repository.deletePartitionSchema( schema2.getObjectId() );
  }
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
private void testOnlyRevision_DateAndCommentAreSaved( RepositoryElementInterface transOrJob ) throws Exception {
  final String elementName = "onlyRevision_" + transOrJob.getRepositoryElementType();
  final String comment = "onlyRevision";
  final Calendar date = Calendar.getInstance();
  date.setTimeInMillis( 0 );

  transOrJob.setName( elementName );
  transOrJob.setRepositoryDirectory( purRepository.getDefaultSaveDirectory( transOrJob ) );
  purRepository.save( transOrJob, comment, date, null, false );

  assertCommentAndDate( transOrJob.getObjectRevision(), date, comment );

  List<VersionSummary> versions = assertExistsAndGetRevisions( transOrJob );
  assertEquals( 1, versions.size() );
  assertCommentAndDate( versions.get( 0 ), date, comment );
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
private void testOnlyRevision_DateAndCommentAreNull( RepositoryElementInterface transOrJob ) throws Exception {
  final String elementName = "revisionWithOutComment_" + transOrJob.getRepositoryElementType();

  transOrJob.setName( elementName );
  transOrJob.setRepositoryDirectory( purRepository.getDefaultSaveDirectory( transOrJob ) );

  final long before = System.currentTimeMillis();
  purRepository.save( transOrJob, null, null, null, false );
  final long after = System.currentTimeMillis();

  assertNull( transOrJob.getObjectRevision().getComment() );

  final long revisionDate = transOrJob.getObjectRevision().getCreationDate().getTime();
  assertTrue( "Revision date should be inside 'before' and 'after' measurements", before <= revisionDate
      && revisionDate <= after );

  List<VersionSummary> versions = assertExistsAndGetRevisions( transOrJob );
  assertEquals( 1, versions.size() );
  assertNull( versions.get( 0 ).getMessage() );

  final long versionSummaryDate = versions.get( 0 ).getDate().getTime();
  assertTrue( "Revision date should be inside 'before' and 'after' measurements", before <= versionSummaryDate
      && versionSummaryDate <= after );
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public void dataNodeToElement( final DataNode rootNode, final RepositoryElementInterface element )
  throws KettleException {
  DatabaseMeta databaseMeta = (DatabaseMeta) element;
  databaseMeta.setDatabaseType( getString( rootNode, PROP_TYPE ) );
  databaseMeta.setAccessType( DatabaseMeta.getAccessType( getString( rootNode, PROP_CONTYPE ) ) );
  databaseMeta.setHostname( getString( rootNode, PROP_HOST_NAME ) );
  databaseMeta.setDBName( getString( rootNode, PROP_DATABASE_NAME ) );
  databaseMeta.setDBPort( getString( rootNode, PROP_PORT ) );
  databaseMeta.setUsername( getString( rootNode, PROP_USERNAME ) );
  databaseMeta.setPassword( Encr.decryptPasswordOptionallyEncrypted( getString( rootNode, PROP_PASSWORD ) ) );
  databaseMeta.setServername( getString( rootNode, PROP_SERVERNAME ) );
  databaseMeta.setDataTablespace( getString( rootNode, PROP_DATA_TBS ) );
  databaseMeta.setIndexTablespace( getString( rootNode, PROP_INDEX_TBS ) );

  // Also, load all the properties we can find...

  DataNode attrNode = rootNode.getNode( NODE_ATTRIBUTES );
  for ( DataProperty property : attrNode.getProperties() ) {
    String code = property.getName();
    String attribute = property.getString();

    // We need to unescape the code as it was escaped to handle characters that JCR does not handle
    String unescapeCode = RepositoryFilenameUtils.unescape( code );
    databaseMeta.getAttributes().put( unescapeCode, Const.NVL( attribute, "" ) ); //$NON-NLS-1$
  }
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public void dataNodeToElement( DataNode rootNode, RepositoryElementInterface element ) throws KettleException {
  ClusterSchema clusterSchema = (ClusterSchema) element;
  // The metadata...
  clusterSchema.setBasePort( getString( rootNode, PROP_BASE_PORT ) );
  clusterSchema.setSocketsBufferSize( getString( rootNode, PROP_SOCKETS_BUFFER_SIZE ) );
  clusterSchema.setSocketsFlushInterval( getString( rootNode, PROP_SOCKETS_FLUSH_INTERVAL ) );
  clusterSchema.setSocketsCompressed( rootNode.getProperty( PROP_SOCKETS_COMPRESSED ).getBoolean() );
  clusterSchema.setDynamic( rootNode.getProperty( PROP_DYNAMIC ).getBoolean() );
  DataNode attrNode = rootNode.getNode( NODE_ATTRIBUTES );
  // The slaves...
  long nrSlaves = attrNode.getProperty( PROP_NB_SLAVE_SERVERS ).getLong();
  for ( int i = 0; i < nrSlaves; i++ ) {
    if ( attrNode.hasProperty( String.valueOf( i ) ) ) {
      DataNodeRef slaveNodeRef = attrNode.getProperty( String.valueOf( i ) ).getRef();
      clusterSchema.getSlaveServers().add( findSlaveServer( new StringObjectId( slaveNodeRef.toString() ) ) );
    }
  }
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public DataNode elementToDataNode( RepositoryElementInterface element ) throws KettleException {
  ClusterSchema clusterSchema = (ClusterSchema) element;
  DataNode rootNode = new DataNode( NODE_ROOT );
  // save the properties...
  rootNode.setProperty( PROP_BASE_PORT, clusterSchema.getBasePort() );
  rootNode.setProperty( PROP_SOCKETS_BUFFER_SIZE, clusterSchema.getSocketsBufferSize() );
  rootNode.setProperty( PROP_SOCKETS_FLUSH_INTERVAL, clusterSchema.getSocketsFlushInterval() );
  rootNode.setProperty( PROP_SOCKETS_COMPRESSED, clusterSchema.isSocketsCompressed() );
  rootNode.setProperty( PROP_DYNAMIC, clusterSchema.isDynamic() );

  DataNode attrNode = rootNode.addNode( NODE_ATTRIBUTES );

  // Also save the used slave server references.

  attrNode.setProperty( PROP_NB_SLAVE_SERVERS, clusterSchema.getSlaveServers().size() );
  for ( int i = 0; i < clusterSchema.getSlaveServers().size(); i++ ) {
    SlaveServer slaveServer = clusterSchema.getSlaveServers().get( i );
    DataNodeRef slaveNodeRef = new DataNodeRef( slaveServer.getObjectId().getId() );
    // Save the slave server by reference, this way it becomes impossible to delete the slave by accident when still
    // in use.
    attrNode.setProperty( String.valueOf( i ), slaveNodeRef );
  }
  return rootNode;
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
@SuppressWarnings( "unchecked" )
public SharedObjects loadSharedObjects( final RepositoryElementInterface element,
    final Map<RepositoryObjectType, List<? extends SharedObjectInterface>> sharedObjectsByType )
  throws KettleException {
  TransMeta transMeta = (TransMeta) element;
  transMeta.setSharedObjects( transMeta.readSharedObjects() );

  // Repository objects take priority so let's overwrite them...
  //
  readDatabases( transMeta, true, (List<DatabaseMeta>) sharedObjectsByType.get( RepositoryObjectType.DATABASE ) );
  readPartitionSchemas( transMeta, true, (List<PartitionSchema>) sharedObjectsByType
      .get( RepositoryObjectType.PARTITION_SCHEMA ) );
  readSlaves( transMeta, true, (List<SlaveServer>) sharedObjectsByType.get( RepositoryObjectType.SLAVE_SERVER ) );
  readClusters( transMeta, true, (List<ClusterSchema>) sharedObjectsByType.get( RepositoryObjectType.CLUSTER_SCHEMA ) );

  return transMeta.getSharedObjects();
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
@Test
public void doesNotChangeFileWhenFailsToRename_slaves() throws Exception {
  final SlaveServer server1 = new SlaveServer();
  final SlaveServer server2 = new SlaveServer();
  try {
    testDoesNotChangeFileWhenFailsToRename( server1, server2, new Callable<RepositoryElementInterface>() {
      @Override
      public RepositoryElementInterface call() throws Exception {
        return repository.loadSlaveServer( server2.getObjectId(), null );
      }
    } );
  } finally {
    repository.deleteSlave( server1.getObjectId() );
    repository.deleteSlave( server2.getObjectId() );
  }
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public DataNode elementToDataNode( RepositoryElementInterface element ) throws KettleException {
  PartitionSchema partitionSchema = (PartitionSchema) element;
  DataNode rootNode = new DataNode( NODE_ROOT );

  // Check for naming collision
  ObjectId partitionId = repo.getPartitionSchemaID( partitionSchema.getName() );
  if ( partitionId != null && !partitionSchema.getObjectId().equals( partitionId ) ) {
    // We have a naming collision, abort the save
    throw new KettleException( "Failed to save object to repository. Object [" + partitionSchema.getName()
        + "] already exists." );
  }
  rootNode.setProperty( PROP_DYNAMIC_DEFINITION, partitionSchema.isDynamicallyDefined() );
  rootNode.setProperty( PROP_PARTITIONS_PER_SLAVE, partitionSchema.getNumberOfPartitionsPerSlave() );

  // Save the cluster-partition relationships
  DataNode attrNode = rootNode.addNode( NODE_ATTRIBUTES );
  attrNode.setProperty( PROP_NB_PARTITION_SCHEMA, partitionSchema.getPartitionIDs().size() );
  for ( int i = 0; i < partitionSchema.getPartitionIDs().size(); i++ ) {
    attrNode.setProperty( String.valueOf( i ), partitionSchema.getPartitionIDs().get( i ) );
  }
  return rootNode;
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public PurRepositoryRevisionBrowserDialog( Shell parent, int style, Repository repository,
    RepositoryElementInterface element ) {
  this.display = parent.getDisplay();
  this.props = PropsUI.getInstance();
  this.repository = repository;
  this.element = element;

  try {
    if ( repository.hasService( IRevisionService.class ) ) {
      revisionService = (IRevisionService) repository.getService( IRevisionService.class );
    } else {
      throw new IllegalStateException();
    }
  } catch ( KettleException e ) {
    throw new IllegalStateException( e );
  }
  String name = element.getRepositoryElementType().toString() + " " + element.getRepositoryDirectory().getPath();
  if ( !name.endsWith( "/" ) )
    name += "/";
  name += element.getName();

  this.elementDescription = name;

  shell = new Shell( display, style | SWT.DIALOG_TRIM | SWT.RESIZE | SWT.MAX | SWT.MIN );
  shell.setText( BaseMessages.getString( PKG, "PurRepositoryRevisionBrowserDialog.Dialog.Main.Title" ) ); //$NON-NLS-1$
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public String calcObjectId(RepositoryElementInterface element) {
	RepositoryDirectoryInterface directory = element.getRepositoryDirectory();
	String name = element.getName();
	String extension = element.getRepositoryElementType().getExtension();
	
	return calcObjectId(directory, name, extension);
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public void save(RepositoryElementInterface repositoryElement, String versionComment, ProgressMonitorListener monitor, ObjectId parentId, boolean used) throws KettleException {
	try {
		if (!(repositoryElement instanceof XMLInterface) && !(repositoryElement instanceof SharedObjectInterface)) {
			throw new KettleException("Class ["+repositoryElement.getClass().getName()+"] needs to implement the XML Interface in order to save it to disk");
		}
		
		if (!Const.isEmpty(versionComment)) {
			insertLogEntry(versionComment);
		}
		
		ObjectId objectId = new StringObjectId(calcObjectId(repositoryElement));
		
		FileObject fileObject = getFileObject(repositoryElement);
		
		String xml = ((XMLInterface)repositoryElement).getXML();
		
		OutputStream os = KettleVFS.getOutputStream(fileObject, false);
		os.write(xml.getBytes(Const.XML_ENCODING));
		os.close();
		
		if (repositoryElement instanceof ChangedFlagInterface) {
		  ((ChangedFlagInterface)repositoryElement).clearChanged();
		}
		
		// See if the element was already saved in the repository.
		// If the object ID is different, then we created an extra copy.
		// If so, we need to now remove the old file to prevent us from having multiple copies.
		//
		if (repositoryElement.getObjectId()!=null && !repositoryElement.getObjectId().equals(objectId)) {
			delObject(repositoryElement.getObjectId());
		}

		repositoryElement.setObjectId(objectId);
	} catch(Exception e) {
		throw new KettleException("Unable to save repository element ["+repositoryElement+"] to XML file : "+calcFilename(repositoryElement), e);
	}
}
 

import org.pentaho.di.repository.RepositoryElementInterface; //导入依赖的package包/类
public static final RepositoryRevisionBrowserDialogInterface getVersionBrowserDialog(Shell shell, Repository repository, final RepositoryElementInterface element) throws Exception {
	
	String className = repository.getRepositoryMeta().getRevisionBrowserDialogClassName();
	PluginRegistry registry = PluginRegistry.getInstance();
	PluginInterface plugin = registry.getPlugin(RepositoryPluginType.class, repository.getRepositoryMeta().getId());
	Class<? extends RepositoryRevisionBrowserDialogInterface> dialogClass = registry.getClass(plugin, className);
	Constructor<?> constructor = dialogClass.getConstructor(Shell.class, Integer.TYPE, Repository.class, RepositoryElementInterface.class);
	return (RepositoryRevisionBrowserDialogInterface) constructor.newInstance(new Object[] { shell, Integer.valueOf(SWT.NONE), repository, element, });
}