public CommandResult Execute(IEnumerable <string> inputParams)
{
AppioLogger.Warn(LoggingText.UnknownCommandCalled);
var outputMessages = new MessageLines();
outputMessages.Add(Constants.CommandResults.Failure, string.Empty);
return(new CommandResult(false, outputMessages));
}
public bool GenerateTypesSourceCodeFiles(string projectName, IModelData modelData)
{
// Verify if model has types
if (string.IsNullOrEmpty(modelData.Types))
{
return(true);
}
// Verify types extension
if (_fileSystem.GetExtension(modelData.Types) != Constants.FileExtension.ModelTypes)
{
AppioLogger.Warn(string.Format(LoggingText.NodesetCompilerExecutableFailsInvalidFile, modelData.Types));
_outputMessage = string.Format(OutputText.GenerateInformationModelFailureInvalidFile, projectName, modelData.Name, modelData.Types);
return(false);
}
// Verify if types file exists
var typesPath = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.Models, modelData.Types);
if (!_fileSystem.FileExists(typesPath))
{
AppioLogger.Warn(string.Format(LoggingText.NodesetCompilerExecutableFailsMissingFile, typesPath));
_outputMessage = string.Format(OutputText.GenerateInformationModelFailureMissingFile, projectName, modelData.Name, typesPath);
return(false);
}
// Create a directory for generated C code
var srcDirectory = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.SourceCode, Constants.DirectoryName.ServerApp);
CreateDirectoryForGeneratedModelsSourceCode(srcDirectory);
// Build types source file and target files directories
var modelName = _fileSystem.GetFileNameWithoutExtension(modelData.Name);
var typesSourceRelativePath = @"../../" + _fileSystem.CombinePaths(Constants.DirectoryName.Models, modelData.Types);
var typesTargetRelativePath = _fileSystem.CombinePaths(Constants.DirectoryName.InformationModels, modelName.ToLower());
// Build types generation script arguments
var generatedTypesArgs = Constants.ExecutableName.GenerateDatatypesScriptPath +
string.Format(Constants.ExecutableName.GenerateDatatypesTypeBsd, typesSourceRelativePath) +
" " +
typesTargetRelativePath +
Constants.InformationModelsName.Types;
// Execute types generation script call
var generatedTypesResult = _fileSystem.CallExecutable(Constants.ExecutableName.PythonScript, srcDirectory, generatedTypesArgs);
if (!generatedTypesResult)
{
AppioLogger.Warn(LoggingText.GeneratedTypesExecutableFails);
_outputMessage = string.Format(OutputText.GenerateInformationModelGenerateTypesFailure, projectName, modelData.Name, modelData.Types);
return(false);
}
// Add generated types header file to server's meson build
AdjustServerMesonBuildCFile(srcDirectory, modelName.ToLower() + Constants.InformationModelsName.TypesGenerated);
return(true);
}
public override void Generate(string appName, string filePrefix, uint keySize, uint days, string organization)
{
var openSSLConfigBuilder =
new StringBuilder(_fileSystem.LoadTemplateFile(Resources.Resources.OpenSSLConfigTemplateFileName));
openSSLConfigBuilder.Replace("$KEY_SIZE", keySize.ToString());
openSSLConfigBuilder.Replace("$ORG_NAME", organization);
openSSLConfigBuilder.Replace("$COMMON_NAME", appName);
var certificateFolder = _fileSystem.CombinePaths(appName, Constants.DirectoryName.Certificates);
var certificateConfigPath = _fileSystem.CombinePaths(certificateFolder, Constants.FileName.CertificateConfig);
try
{
_fileSystem.CreateDirectory(certificateFolder);
_fileSystem.CreateFile(certificateConfigPath, openSSLConfigBuilder.ToString());
}
catch (Exception)
{
AppioLogger.Warn(string.Format(LoggingText.CertificateGeneratorFailureNonexistentDirectory, appName));
return;
}
var separator = filePrefix == string.Empty ? "" : "_";
try
{
_fileSystem.CallExecutable(Constants.ExecutableName.OpenSSL, certificateFolder, string.Format(Constants.ExternalExecutableArguments.OpenSSL, filePrefix + separator, days));
_fileSystem.CallExecutable(Constants.ExecutableName.OpenSSL, certificateFolder, string.Format(Constants.ExternalExecutableArguments.OpenSSLConvertKeyFromPEM, filePrefix + separator + Constants.FileName.PrivateKeyPEM, filePrefix + separator + Constants.FileName.PrivateKeyDER));
}
catch (Exception)
{
AppioLogger.Warn(LoggingText.CertificateGeneratorFailureOpenSSLError);
}
_fileSystem.DeleteFile(_fileSystem.CombinePaths(certificateFolder, filePrefix + separator + Constants.FileName.PrivateKeyPEM));
AppioLogger.Info(string.Format(LoggingText.CertificateGeneratorSuccess, filePrefix == string.Empty ? appName : appName + "/" + filePrefix));
}
public ResolvedParameters <TIdent> ResolveParams(IEnumerable <string> parameters)
{
var resolvedStringParams = new string[_numStringParams];
var resolvedBoolParams = new bool[_numBoolParams];
Array.Fill(resolvedBoolParams, false);
var handledFlags = new List <Tuple <TIdent, string> >();
var parameterArray = parameters as string[] ?? parameters.ToArray();
for (var providedFlagNameIndex = 0; providedFlagNameIndex < parameterArray.Length; providedFlagNameIndex++)
{
var providedFlagName = parameterArray[providedFlagNameIndex];
var flagIndex = _flags.FindIndex(pair => pair.Name == providedFlagName);
if (flagIndex == -1)
{
AppioLogger.Warn(string.Format(LoggingText.UnknownParameterProvided, _commandName));
return(new ResolvedParameters <TIdent> {
ErrorMessage =
string.Format(OutputText.UnknownParameterProvided, providedFlagName, JoinFlagString())
});
}
switch (_flags[flagIndex].Type)
{
case IdentifierNames.DataType.String:
++providedFlagNameIndex;
if (providedFlagNameIndex >= parameterArray.Length ||
parameterArray[providedFlagNameIndex] == string.Empty)
{
AppioLogger.Warn(string.Format(LoggingText.ParameterValueMissing, _commandName));
return(new ResolvedParameters <TIdent> {
ErrorMessage = string.Format(OutputText.ParameterValueMissing, _flags[flagIndex].Name)
});
}
resolvedStringParams[(int)(object)_flags[flagIndex].Identifier] = parameterArray[providedFlagNameIndex];
break;
case IdentifierNames.DataType.Bool:
resolvedBoolParams[(int)(object)_flags[flagIndex].Identifier - _boolOffset] = true;
break;
}
handledFlags.Add(new Tuple <TIdent, string>(_flags[flagIndex].Identifier, providedFlagName));
}
if (ContainsDuplicateParameters(handledFlags, out var affectedFlag))
{
AppioLogger.Warn(string.Format(LoggingText.DuplicateParameterProvided, _commandName));
return(new ResolvedParameters <TIdent> {
ErrorMessage =
string.Format(OutputText.DuplicateParameterProvided, affectedFlag)
});
}
if (!FillDefaultValues(resolvedStringParams, out var missingParamString))
{
AppioLogger.Warn(string.Format(LoggingText.MissingRequiredParameter, _commandName));
return(new ResolvedParameters <TIdent> {
ErrorMessage =
string.Format(OutputText.MissingRequiredParameter, missingParamString)
});
}
return(new ResolvedParameters <TIdent>
{
StringParameters = new ParameterList <string, TIdent>(0, resolvedStringParams),
BoolParameters = new ParameterList <bool, TIdent>(_boolOffset, resolvedBoolParams)
});
}
public bool GenerateNodesetSourceCodeFiles(string projectName, IModelData modelData, List <RequiredModelsData> requiredModelsData)
{
// Verify if nodeset file name is not empty
if (string.IsNullOrEmpty(modelData.Name))
{
AppioLogger.Warn(LoggingText.GenerateInformationModelFailureEmptyModelName);
_outputMessage = string.Format(OutputText.GenerateInformationModelFailureEmptyModelName, projectName);
return(false);
}
// Verify nodeset extension
if (_fileSystem.GetExtension(modelData.Name) != Constants.FileExtension.InformationModel)
{
AppioLogger.Warn(string.Format(LoggingText.NodesetCompilerExecutableFailsInvalidModelFile, modelData.Name));
_outputMessage = string.Format(OutputText.GenerateInformationModelFailureInvalidModel, projectName, modelData.Name);
return(false);
}
// Verify if nodeset file exists
var modelPath = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.Models, modelData.Name);
if (!_fileSystem.FileExists(modelPath))
{
AppioLogger.Warn(string.Format(LoggingText.NodesetCompilerExecutableFailsMissingModelFile, modelData.Name));
_outputMessage = string.Format(OutputText.GenerateInformationModelFailureMissingModel, projectName, modelData.Name, modelPath);
return(false);
}
// Validate nodeset
if (!_modelValidator.Validate(modelPath, Resources.Resources.UANodeSetXsdFileName))
{
AppioLogger.Warn(string.Format(LoggingText.NodesetValidationFailure, modelData.Name));
_outputMessage = string.Format(OutputText.NodesetValidationFailure, modelData.Name);
return(false);
}
// Create a directory for generated C code
var srcDirectory = _fileSystem.CombinePaths(projectName, Constants.DirectoryName.SourceCode, Constants.DirectoryName.ServerApp);
CreateDirectoryForGeneratedModelsSourceCode(srcDirectory);
// Build nodeset compiler script arguments
var modelName = _fileSystem.GetFileNameWithoutExtension(modelData.Name);
var nodesetCompilerArgs = BuildNodesetCompilerArgs(modelName, modelData, requiredModelsData);
// Execute nodeset compiler call
var nodesetResult = _fileSystem.CallExecutable(Constants.ExecutableName.PythonScript, srcDirectory, nodesetCompilerArgs);
if (!nodesetResult)
{
AppioLogger.Warn(LoggingText.NodesetCompilerExecutableFails);
_outputMessage = string.Format(OutputText.GenerateInformationModelFailure, projectName, modelData.Name);
return(false);
}
// Add nodeset header file to server's meson build
AdjustServerMesonBuildCFile(srcDirectory, modelName);
// Add nodeset function call to server code
AdjustLoadInformationModelsCFile(srcDirectory, modelName);
// Add method callback functioncs to server code
AdjustMainCallbacksCFile(srcDirectory, modelPath, modelData);
return(true);
}