diff -r f65f740e69f9 -r 8e12a575a9b5 sysperfana/memspyext/com.nokia.s60tools.memspy/src/com/nokia/s60tools/memspy/model/ImportEngine.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysperfana/memspyext/com.nokia.s60tools.memspy/src/com/nokia/s60tools/memspy/model/ImportEngine.java Wed Apr 21 20:01:08 2010 +0300 @@ -0,0 +1,391 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + + +package com.nokia.s60tools.memspy.model; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.util.ArrayList; + +import com.nokia.s60tools.memspy.containers.SWMTLogInfo; +import com.nokia.s60tools.memspy.containers.ThreadInfo; +import com.nokia.s60tools.memspy.containers.SWMTLogInfo.SWMTLogType; +import com.nokia.s60tools.memspy.model.AnalyserXMLGenerator.XMLGeneratorAction; +import com.nokia.s60tools.memspy.ui.views.MemSpyMainView; + +/** + * Class that is used when importing MemSpy data. + * ImportEngine takes care of copying files into predefined file structure that Main View is able to read. + */ +public class ImportEngine { + + /* MemSpy's Main View */ + private MemSpyMainView view; + + /** + * Import Engine constructor. + * @param view MemSpy's main view + */ + public ImportEngine( MemSpyMainView view ){ + this.view = view; + } + + /** + * Imports Heap Dump file(s) and starts heap analyser if only one file was imported. Method also shows + * error message if some of operations was not successful. + * @param importedHeaps list of imported files + * @param symbols symbol information that is used. + * @return true, if importing was successful. + */ + public boolean importAndAnalyseHeap( ArrayList importedHeaps, AnalyserXMLGenerator xmlGenerator, boolean startHeapAnalyser ){ + return importAndAnalyseHeap( importedHeaps, xmlGenerator, startHeapAnalyser, true); + } + + /** + * Imports Heap Dump file(s) and starts heap analyser if only one file was imported. Method also shows + * error message if some of operations was not successful. + * @param importedHeaps list of imported files + * @param symbols symbol information that is used. + * @param deleteTempFiles if temp files and folder should be deleted after import + * @return true, if importing was successful. + */ + public boolean importAndAnalyseHeap( ArrayList importedHeaps, AnalyserXMLGenerator xmlGenerator, boolean startHeapAnalyser, boolean deleteTempFiles ){ + + boolean importFailed = false; + + // Set xmlGenerators action type correct. + xmlGenerator.setXMLAction( XMLGeneratorAction.ANALYSE_HEAP ); + String fileName = ""; + for ( ThreadInfo threadInfo : importedHeaps ){ + fileName = this.moveHeapToImportedFolder( threadInfo ); + if( fileName != null ){ + // save new filepath into threadInfo-variable. + threadInfo.setThreadFilePath( fileName ); + + if( !generateViewConfigurationFile( fileName, threadInfo.getThreadName(), xmlGenerator) ){ + importFailed = true; + } + + } + else{ + importFailed = true; + } + } + + // if importing was failed, show error message. + if( importFailed ){ + view.showErrorMessage( MemSpyMainView.ERROR_IMPORT_HEADER, MemSpyMainView.ERROR_HEAP_IMPORT_FAILED ); + return false; + } + + // Start heap analyser if only one heap was imported. + if( importedHeaps.size() == 1 && startHeapAnalyser ){ + + // get configuration files path + String analyserFileOutput = importedHeaps.get(0).getThreadFilePath().substring( 0, fileName.lastIndexOf("\\") + 1); + analyserFileOutput = analyserFileOutput + "configuration.xml"; + + // launch Heap Analyser + view.launchHeapAnalyser( analyserFileOutput, null, xmlGenerator.getXMLThreadName(), true ); + + } + + + // Refresh main view so that newly imported files are shown. + view.refreshContentAndViewAsync(); + + // delete temp folder + if(deleteTempFiles){ + MemSpyFileOperations.deleteTempMemSpyFiles(); + } + + return true; + } + + /** + * Move imported heap from temporary file into import directory + * @param threadInfo imported heap + * @return true if file operations were successful + */ + + private String moveHeapToImportedFolder( ThreadInfo threadInfo ){ + + // Get new file name for imported file. + String newFileName = MemSpyFileOperations.getFileNameForHeapDump( threadInfo.getThreadFilePath() ); + + if( newFileName == null ){ + return null; + } + + // Move heap dump from temp folder into Heap Dumps-folder + if( MemSpyFileOperations.moveFile(new File(threadInfo.getThreadFilePath()), new File(newFileName)) ){ + return newFileName; + } + else{ + return null; + } + } + + /** + * Starts comparing two heap dump files. + * @param firstHeap first heap dump + * @param secondHeap second heap dump + */ + public void compareHeaps( ThreadInfo firstHeap, ThreadInfo secondHeap, AnalyserXMLGenerator xmlGenerator, String output ){ + + boolean importFailed = false; + + // get file paths of heap dumps. + String firstHeapFile = firstHeap.getThreadFilePath(); + String secondHeapFile = secondHeap.getThreadFilePath(); + + if( firstHeapFile != null && secondHeapFile != null ){ + + // generate compare heaps configuration file. + xmlGenerator.setXMLAnalyseFileOutput( output ); + if( this.generateCompareConfigurationFile( new String[]{ firstHeapFile, secondHeapFile}, firstHeap.getThreadName(), xmlGenerator) ){ + + // launch Heap Analyser + view.launchHeapAnalyser( MemSpyFileOperations.getCompareConfigurationFilePath(), xmlGenerator.getXMLAnalyseFileOutput(), xmlGenerator.getXMLThreadName(), false ); + } + else{ + importFailed = true; + } + } + if( importFailed ){ + view.showErrorMessage( MemSpyMainView.ERROR_IMPORT_HEADER, MemSpyMainView.ERROR_HEAP_IMPORT_FAILED); + } + + } + + + /** + * Imports SystemWide Memory Tracking logs and starts swmt viewer. + * @param importedLogs imported swmt logs. + */ + public void importSWMTLogs( final ArrayList importedLogs ){ + importSWMTLogs( importedLogs, true); + } + + /** + * Imports SystemWide Memory Tracking logs and starts swmt viewer. + * @param importedLogs imported swmt logs. + * @param deleteTempFiles if temp files and folder should be deleted after import + */ + public void importSWMTLogs( final ArrayList importedLogs, boolean deleteTempFiles){ + + boolean isImportedFromDevice = false; + boolean importFailed = false; + + // check if files were imported from device. + if( importedLogs.size() > 0 ){ + if (importedLogs.get(0).getType() == SWMTLogType.DEVICE ){ + isImportedFromDevice = true; + } + } + + ArrayList directories = new ArrayList(); + + // If files were imported from device, move those files into imported directory. + if( isImportedFromDevice ){ + + for( SWMTLogInfo swmtLogInfo : importedLogs){ + + // Get next free directory + String directory = MemSpyFileOperations.getNextFreeDirectory(); + directory = MemSpyFileOperations.addSlashToEnd( directory ); + + // Add directory to arraylist + directories.add( directory ); + + if( !MemSpyFileOperations.copyFileToDirectory( swmtLogInfo.getPath(), directory ) ){ + + // if operations fail show error message and remove all imported files. + importFailed = true; + MemSpyFileOperations.deleteDir( new File( directory ) ); + break; + } + } + } + else{// if importing log from file system, copy files into imported directory + + for( SWMTLogInfo swmtLogInfo : importedLogs){ + + // if file + if( swmtLogInfo.getType() == SWMTLogType.FILE ){ + + // Get next free directory + String directory = MemSpyFileOperations.getNextFreeDirectory(); + directory = MemSpyFileOperations.addSlashToEnd( directory ); + + // Add directory to arraylist + directories.add( directory ); + + if( !MemSpyFileOperations.copyFileToDirectory( swmtLogInfo.getPath(), directory ) ){ + + // if operation fails show error message and remove all imported files. + importFailed = true; + MemSpyFileOperations.deleteDir( new File( directory ) ); + break; + } + } + + + } + + } + // if error occurred show error message + if( importFailed ){ + view.showErrorMessage( MemSpyMainView.ERROR_IMPORT_HEADER, MemSpyMainView.ERROR_SWMT_IMPORT_FAILED); + } + else{ + // Get ArrayList of imported files. + ArrayList files = new ArrayList(); + try{ + for( String item : directories ){ + // Get filename from Log file from each directory that is saved into directories-ArrayList. + File directory = new File(item); + String fileName = directory.list()[0]; + fileName = item + fileName; + files.add( fileName ); + } + view.launchSWMTAnalyser( files ); + + } + catch( Exception e ){ + view.showErrorMessage( MemSpyMainView.ERROR_IMPORT_HEADER, MemSpyMainView.ERROR_LAUNCH_SWMT_ANALYSER ); + } + + } + + // Refresh main view so that newly imported files are shown. + view.refreshContentAndViewAsync(); + + // delete temp folder + if(deleteTempFiles){ + MemSpyFileOperations.deleteTempMemSpyFiles(); + } + + + + + } + + + /** + * Uses AnalyserXMLGenerator to generate configuration file for viewing heap with Heap Analyser + * @param name of the source file + * @param threadName thread's name + * @param xmlGenerator XML generator that is used. + * @return true if file was generated successfully + */ + public boolean generateViewConfigurationFile( String fileName, String threadName, AnalyserXMLGenerator xmlGenerator ){ + + xmlGenerator.setXMLAction(XMLGeneratorAction.ANALYSE_HEAP); + xmlGenerator.setXMLSourceFile( new String[]{ fileName } ); + xmlGenerator.setXMLThreadName( threadName ); + + // get filenames path + String analyserFileOutput = fileName.substring( 0, fileName.lastIndexOf("\\") + 1); + analyserFileOutput = analyserFileOutput + "configuration.xml"; + + // generate xml-file + + File filename = new File( analyserFileOutput ); + BufferedWriter writer = null; + + try { + // Construct FileWriter and print xml into that stream + writer = new BufferedWriter(new FileWriter(filename)); + xmlGenerator.GenerateXML(writer); + } + catch (IOException e) { + + e.printStackTrace(); + return false; + } + finally { + try { + if (writer != null) { + writer.flush(); + writer.close(); + return true; + } + } + catch (IOException ex) { + ex.printStackTrace(); + return false; + } + + } + return false; + } + + /** + * Uses AnalyserXMLGenerator to generate configuration file for comparing two heap's with Heap Analyser + * @param fileName names of the source files. + * @param threadName thread's name + * @param xmlGenerator XML generator that is used. + * @return true if file was generated successfully + */ + public boolean generateCompareConfigurationFile( String[] fileName, String threadName, AnalyserXMLGenerator xmlGenerator ){ + xmlGenerator.setXMLAction(XMLGeneratorAction.COMPARE_HEAPS); + xmlGenerator.setXMLSourceFile( fileName ); + xmlGenerator.setXMLThreadName( threadName ); + + String analyserFileOutput = MemSpyFileOperations.getCompareConfigurationFilePath(); + + // generate xml-file + File filename = new File( analyserFileOutput ); + + + BufferedWriter writer = null; + + try { + // Construct FileWriter and print xml into that stream + writer = new BufferedWriter(new FileWriter(filename)); + xmlGenerator.GenerateXML(writer); + } + catch (IOException e) { + + e.printStackTrace(); + return false; + } + finally { + try { + if (writer != null) { + writer.flush(); + writer.close(); + return true; + } + } + catch (IOException ex) { + ex.printStackTrace(); + return false; + } + + } + return false; + + } + + +}