API à utiliser dans des stratégies personnalisées

Quand vous écrivez des stratégies personnalisées, vous pouvez utiliser plusieurs API. Les API utilisées dépendent des actifs avec lesquels vous travaillez et de ce que vous voulez en faire. Par exemple, vous utilisez des API différentes pour mettre à jour l'actif sur lequel une stratégie est exécutée et pour créer un actif.

API à utiliser avec l'actif en cours

Vous pouvez créer des stratégies en utilisant les API client Java.

Si vous mettez uniquement à jour l'actif sur lequel la stratégie est exécutée, vous pouvez employer les méthodes de contexte de la stratégie pour créer une session et obtenir l'actif. Pour créer un RAMSession et extraire le RAMAsset actuel, utilisez les API suivantes :
RAMSession ramSession = getPolicyContext().getRAMSession();
RAMAsset ramAsset = getPolicyContext().getRAMAsset();

Vous pouvez utiliser plusieurs classes d'API Java Rational Asset Manager pour mettre à jour l'actif actuel. Par exemple, vous pouvez ajouter une relation ou définir une action. Vous pouvez également utiliser les classes d'API pour travailler avec des actifs, des attributs d'actifs et des artefacts.

Vous pouvez aussi utiliser les API Java pour changer ou créer des actifs en plus de celui sur lequel est exécutée la stratégie. Vous devez inclure les fichiers JAR du client Java et utiliser RAMSession(). Pour des performances optimales lors de l'utilisation d'API ram.client, limitez les mises à jours des actifs à une seule session.

Suivez ces étapes dans votre code de stratégie personnalisée :
  1. Créez une session à l'aide de la méthode getRAMSession. Aucune licence n'est consommée pour ces sessions.
  2. Obtenez un actif avec la méthode getRAMAsset.
  3. Utilisez les API RAMSession et RAMAsset pour effectuer des opérations d'actif.
  4. Validez les modifications en tant qu'une transaction à l'aide de la méthode session.putAssets.
Par exemple :
RAMSession session = getPolicyContext().getRAMSession();  
RAMAsset currentAsset = this.getPolicyContext().getRAMAsset();  
  
// Utilisez les API client pour apporter des modifications à l'actif ...

// Vous pouvez également modifier ou créer d'autres actifs :
			RAMAsset asset = session.createAsset("1.0");
			asset.setName("Test Asset");
			asset.setCommunity(session.getCommunity("Sample Application Development"));
			asset.setAssetType(session.getAssetType("Business Solution"));
			asset.setShortDescription("Test asset");
			asset.setOwners(new RAMUser[] { session.getUser("admin") });
		 	
// Validez les modifications dans le référentiel d'actifs pour l'actif actuel :
			session.putAsset(currentAsset);  

// Vous pouvez utiliser queueAssetForPut et putAssets pour mettre en fil d'attente, puis
// valider tous les actifs que vous avez modifiés dans la session comme une seule transaction :
			session.queueAssetForPut(currentAsset);  

// Validez les modifications apportées à tous les actifs que vous avez modifiés dans la session :
			session.putAssets(new NullProgressMonitor());  	
Pour utiliser les API ram.client, vous devez télécharger ram.client et les fichiers JAR de la stratégie, puis importez les fichiers dans le code de votre stratégie :
import com.ibm.ram.common.*
import com.ibm.ram.client.* 

Pour les API du client Java, voir : package client et package de données communes.

Reportez-vous à la section Exemple de cette rubrique et à Utiliser l'API Java Rational Asset Manager pour des exemples supplémentaires.

  • Obtenir l'ID actif :
    myAssetUniqueID = getManifestAccessor().getId();
  • Extraire l'actif par identificateur global unique et par version :
    RAMAsset myAsset = session.getAsset(new AssetIdentification(myAssetUniqueID, "*"));
    
    // Obtenir des exemples d'attributs d'actifs :
    AssetAttribute myAttribute = myAsset.getAssetAttribute("Family Name");
    String[] myAttrValue = myAttribute.getValues();
    
    myAttribute = myAsset.getAssetAttribute("Work Item");
    myAttrValue = myAttribute.getValues();
    
    myAttribute = myAsset.getAssetAttribute("Requirement");
    myAttrValue = myAttribute.getValues();
  • Créer une requête pour rechercher des actifs :
    SearchQuery query = session.createAssetQuery(queryParam);
    int offset = 0;
    int maxResults = 100;
    query.setResultsStartIndex(offset);
    query.setMaxResults(maxResults);
    SearchResult result = session.getAssets(query);
  • Créer un actif :
    RAMAsset newAsset = session.createAsset("1.0");
    newAsset.setName("The new related asset");
    newAsset.setCommunity(session.getCommunity("Développement Rational Asset Manager"));
    newAsset.setAssetType(session.getAssetType("Specification"));
    newAsset.setShortDescription("The Specification asset is required.");
  • Créer un ID pour le nouvel actif :
    AssetID id = new AssetID();
    id.setGUID(newAsset.getId());
    id.setVersion(newAsset.getVersion());
  • Utilisez les API du client Java pour une recherche :
    public Result test() {
    		try {
    			// Créer des paramètres de configuration pour l'url, l'utilisateur et le mot de passe
    			String url = "http://nom-hôte:9080/ram";
    			String user = "admin";
    			String password = "admin";
    			String queryParam = null;
    
    			// Définir une requête 
    			RAMSession session = new RAMSession(url, user, password);
    			SearchQuery query = session.createAssetQuery(queryParam);
    			int offset = 0;
    			int maxResults = 100;
    			query.setResultsStartIndex(offset);
    			query.setMaxResults(maxResults);
    			SearchResult result = session.getAssets(query); 
    			 
    			if (result != null && result.getAssetSearchResults() != null) {
    				AssetSearchResult[] assets = result.getAssetSearchResults();
    	
    				for (AssetSearchResult asset : assets) {
    					AssetInformation assetInformation = asset.getAsset();
    				// Modifier un actif, par exemple
    				// créer une relation "DependsOn" des actifs de type Release et Implementation à
    un actif Specification du même nom à l'aide des API du client, comme suit :
    				// Relationship theRelationships = session.getRelationships
    				// getRelationships().add(newItem);
    				}
    			}
    		}
     
    		// Intercepter des exceptions...
    				Result result = new Result();
    		result.setMessage("Success");
    		return result;
    		 
    	}
  • Accédez à l'emplacement du dossier à l'aide de l'API Java de Rational Asset Manager pour récupérer les informations des artefacts de l'actif et télécharger les artefacts :
     		// Obtenir l'actif
    		RAMAsset ramAsset = getRAMAsset(); 
                
    		 		// Obtenir l'emplacement et le contenu des artefacts
    		RAMFolderArtifact srcFolderArtifact = (RAMFolderArtifact)ramAsset.getArtifactsRoot();
    		Artifact[] srcArtifacts = srcFolderArtifact.computeArtifactsAsFlatList(new NullProgressMonitor());
    		 
    		for (Artifact artifact : srcArtifacts) {
            RAMArtifact ramArtifact = (RAMArtifact) artifact;
    					InputStream is = ramArtifact.downloadContents();
    					f = File.createTempFile("theArtifact", null, new File(ramSession.getLocalStorageLocation()));
    					UtilitiesCommon.copyStreams(is, new FileOutputStream(f), null, true, true);
             }

Commentaires