processing commands in input data

ameasure2/src/provisioner/MeasurementProvisioner.cpp

@@ -3,13 +3,8 @@
  */
 #include "MeasurementProvisioner.hpp"
-#include "exception/AlibException.h"
+#include "exception/CommonException.h"
 #include "sax/SaxParseInterface.h"
-#include <unistd.h>
-#include <err.h>
-#include <wordexp.h>
-#include <glob.h>
-#include <sys/wait.h>
 #include <iostream>
 #include "MeasurementProvisionerUtils.hpp"
@@ -22,67 +17,29 @@ namespace provisioner {
 MeasurementProvisionerResults MeasurementProvisioner::runConfiguration ( const MeasurementProvisionerConfiguration & cfg ) {
 	MeasurementProvisionerResults results;
-	MPInputData mpiData ( cfg );
-	cout << mpiData.getSubstitutionMaps() << endl;
-	int b;
-	cin >> b;
+	prepareEnvironment ( cfg );
+	MPInputData mpiData ( cfg );
+	for ( const MPSubstitutionMap & substitutionMap : mpiData.getSubstitutionMaps ( ) )
+		for ( const MPPipeline & pipeline : mpiData.getSubstitutionPipelines ( ) )
+			for ( const MPPipelineCommand & command : pipeline )
+				cout << command.substitute ( substitutionMap ) << endl;
 	return results;
 }
+void MeasurementProvisioner::prepareEnvironment ( const MeasurementProvisionerConfiguration & cfg ) {
+	list < string > binariesDirectoryExpansion = MPUtils::shellExpand ( cfg.binariesDirectory );
+
+	if ( binariesDirectoryExpansion.size ( ) != 1 )
+		throw::exception::CommonException ( "MeasurementProvisioner: binaries directory: \"" + cfg.binariesDirectory + "\"expansion failed" );
+
+	if ( chdir ( binariesDirectoryExpansion.begin ( )->c_str ( ) ) != 0 )
+		throw::exception::CommonException ( "MeasurementProvisioner: chdir to binaries directory: \"" + cfg.binariesDirectory + "\" failed" );
+}
+
 /*
- * void MeasurementProvisioner::prepareEnvironment ( const MeasurementProvisionerConfiguration & cfg ) {
- *  list < string > binariesDirectoryExpansion = shellExpand ( cfg.binariesDirectory );
- *
- *  if ( binariesDirectoryExpansion.size ( ) != 1 )
- *      throw ::exception::AlibException ( "BinariesDirectory expansion failed" );
- *
- *  if ( chdir ( binariesDirectoryExpansion.begin ( )->c_str ( ) ) != 0 )
- *      throw ::exception::AlibException ( "chdir to BinariesDirectory failed" );
- * }
- *
- *
- * map < int, vector < string > > MeasurementProvisioner::prepareInputData ( const MeasurementProvision & mp ) {
- *  map < int, vector < string > > inputData;
- *
- *  for ( auto mid : mp.inputData ) {
- *
- *  }
- *
- *  return inputData;
- * }
- *
- * MeasurementProvisionResults MeasurementProvisioner::runProvision ( const MeasurementProvision & mp ) {
- *
- *  MeasurementProvisionResults results;
- *
- *  map < int, vector < string > > preparedInputData = prepareInputData ( mp );
- *
- *
- *   // * list < string > expandedInputDataFiles;
- *   // *
- *   // * for ( const string & inputDataFile : mp.inputDataFiles )
- *   // *  expandedInputDataFiles.splice ( expandedInputDataFiles.end ( ), shellExpand ( inputDataFile ) );
- *   // *
- *   // * for ( string & expandedInputDataFile : expandedInputDataFiles ) {
- *   // *  clog << "input: " << expandedInputDataFile << endl;
- *   // *
- *   // *  vector < PipelineResults > pipelinesResults;
- *   // *
- *   // *  for ( const vector < string > & pipeline : mp.pipelines ) {
- *   // *      clog << "$ " << flush;
- *   // *      pipelinesResults.emplace_back ( runPipeline ( expandedInputDataFile, pipeline ) );
- *   // *  }
- *   // *
- *   // *  results.emplace_back ( move ( expandedInputDataFile ), move ( pipelinesResults ) );
- *   // * }
- *
- *  return results;
- * }
- *
- *
  * PipelineResults MeasurementProvisioner::runPipeline ( const string & inputDataFile, const vector < string > & pipeline ) {
  *
  *  PipelineResults pipelineResults;

ameasure2/src/provisioner/MeasurementProvisioner.hpp

@@ -13,11 +13,12 @@
 namespace provisioner {
-
 class MeasurementProvisioner {
+	static void prepareEnvironment ( const MeasurementProvisionerConfiguration & );
+
 	/*
-	 * static void prepareEnvironment ( const MeasurementProvisionerConfiguration & );
+	 *
 	 * static std::map < int, std::vector < std::string > > prepareInputData ( const MeasurementProvision & );
 	 *
 	 * static MeasurementProvisionResults runProvision ( const MeasurementProvision & );

ameasure2/src/provisioner/MeasurementProvisionerInputData.cpp

@@ -103,6 +103,15 @@ bool MPSubstitution::containsSubstitution ( const string & str ) {
 /*---------------------------------------------------------------------------------------------------------------*/
+MPPipelineCommand::MPPipelineCommand ( std::string str ) : MPSubstitution ( str ), rawCommand ( std::move ( str ) ) {
+}
+
+const string & MPPipelineCommand::getRawCommand ( ) const {
+	return rawCommand;
+}
+
+/*---------------------------------------------------------------------------------------------------------------*/
+
 MPInputData::MPInputData ( const MeasurementProvisionerConfiguration & mpc ) {
 	processMPCInputData ( mpc );
 }
@@ -118,19 +127,30 @@ const list < MPSubstitutionMap > & MPInputData::getSubstitutionMaps ( ) const {
 	return this->substitutionMaps;
 }
+const list < MPPipeline > & MPInputData::getSubstitutionPipelines ( ) const {
+	return this->substitutionPipelines;
+}
+
 void MPInputData::processMPCInputData ( const MeasurementProvisionerConfiguration & mpc ) {
 	 // get requried substitution pattern and ensure every command has the same pattern
-	for ( const MPCPipeline & pipeline : mpc.pipelines )
+	for ( const MPCPipeline & pipeline : mpc.pipelines ) {
+		MPPipeline mpp;
+
 		for ( const string & command : pipeline ) {
-			set < int > substitutionPattern = MPSubstitution::requiredSubstitutionPattern ( command );
+			MPPipelineCommand mppc ( command );
 			if ( this->requiredSubstitutionPattern.size ( ) == 0 )
-				this->requiredSubstitutionPattern = std::move ( substitutionPattern );
-			else if ( substitutionPattern.size ( ) && ( this->requiredSubstitutionPattern != substitutionPattern ) )
+				this->requiredSubstitutionPattern = mppc.getSubstitutionPattern ( );
+			else if ( mppc.getSubstitutionPattern ( ).size ( ) && ( this->requiredSubstitutionPattern != mppc.getSubstitutionPattern ( ) ) )
 				throw::exception::CommonException ( "MPInputData: Substitution pattern is not consistent across commands" );
+
+			mpp.push_back ( std::move ( mppc ) );
 		}
+		substitutionPipelines.push_back ( std::move ( mpp ) );
+	}
+
 	// process input batches and generated substitution maps, throw if there is any discrepancy in substitution patterns or errors during data generation
 	for ( const MPCInputBatch & inputBatch : mpc.inputBatches ) {

ameasure2/src/provisioner/MeasurementProvisionerInputData.hpp

@@ -54,16 +54,29 @@ public:
 	static const char SUBSTITUTION_DELIM = '$';
 };
+class MPPipelineCommand : public MPSubstitution {
+	std::string rawCommand;
+
+public:
+	MPPipelineCommand ( std::string );
+	const std::string & getRawCommand ( ) const;
+};
+
+using MPPipeline = std::list < MPPipelineCommand >;
+
 class MPInputData {
 	std::map < std::string, MPInputDatum > mpidHandles;
 	std::list < MPSubstitutionMap > substitutionMaps;
 	std::set < int > requiredSubstitutionPattern;
+	std::list < MPPipeline > substitutionPipelines;
+
 	void insertMPInputDatum ( MPInputDatum::Type, std::string, std::string );
 public:
 	const MPInputDatum & getMPIDHandle ( const std::string & ) const;
 	const std::list < MPSubstitutionMap > & getSubstitutionMaps ( ) const;
+	const std::list < MPPipeline > & getSubstitutionPipelines ( ) const;
 	MPInputData ( const MeasurementProvisionerConfiguration & );
 private: