private void PrintInformationFiles(string path, APIConnectionInformation connectionInformation)
{
string lines = $"Configuration on the file '{path}'";
CLILogs.Info(lines);
CLILogs.Info(connectionInformation.ToString());
}
private void SetConfigFile(string path, APIConnectionInformation connectionInformation)
{
PrintInformationFiles(path, connectionInformation);
using (FileStream fs = FileWrap.CreateFile(path))
{
FileWriter.Write("token", connectionInformation.Token, fs);
FileWriter.Write("uri", connectionInformation.ApiUri, fs);
FileWriter.Write("storage", connectionInformation.StorageUri, fs);
FileWriter.Write("account-email", connectionInformation.AccountEmail, fs);
if (connectionInformation.GetForcePathStyle.HasValue)
{
FileWriter.Write("force-path", connectionInformation.ForcePathStyle.ToString(), fs);
}
if (connectionInformation.GetDisableBucketPathsSanitization.HasValue)
{
FileWriter.Write("disable-path-sanitization", connectionInformation.DisableBucketPathsSanitization.ToString(), fs);
}
if (connectionInformation.GetUnsafeSsl.HasValue)
{
FileWriter.Write("unsafe-ssl", connectionInformation.UnsafeSsl.ToString(), fs);
}
if (connectionInformation.GetStorageUnsafeSsl.HasValue)
{
FileWriter.Write("storage-unsafe-ssl", connectionInformation.StorageUnsafeSsl.ToString(), fs);
}
}
}
public void ParseLinesTestSimpleValidList()
{
var fileinfo = new ConfigurationFileReader();
string[] lines = new string[]
{
"token=TOKEN",
"uri=URI",
"storage=BUCKET",
"account-email=EMAIL",
"force-path=true",
"disable-path-sanitization=true",
"unsafe-ssl=true",
"storage-unsafe-ssl=true"
};
QarnotCLI.APIConnectionInformation apiInformation = fileinfo.ParseLines(lines);
Assert.AreEqual(apiInformation.Token, "TOKEN");
Assert.AreEqual(apiInformation.ApiUri, "URI");
Assert.AreEqual(apiInformation.StorageUri, "BUCKET");
Assert.AreEqual(apiInformation.AccountEmail, "EMAIL");
Assert.AreEqual(apiInformation.ForcePathStyle, true);
Assert.AreEqual(true, apiInformation.DisableBucketPathsSanitization);
Assert.AreEqual(true, apiInformation.UnsafeSsl);
Assert.AreEqual(true, apiInformation.StorageUnsafeSsl);
}
public void RetrieveEnvironmentInformation(APIConnectionInformation api)
{
api.SetToken = GentEnvVariable("QARNOT_CLIENT_TOKEN");
api.SetAccountEmail = GentEnvVariable("QARNOT_ACCOUNT_EMAIL");
api.SetApiUri = GentEnvVariable("QARNOT_CLUSTER_URL");
api.SetStorageUri = GentEnvVariable("QARNOT_STORAGE_URL");
api.SetForcePathStyleString(GentEnvVariable("QARNOT_USE_STORAGE_PATH_STYLE"));
}
public void Update(APIConnectionInformation connectionInformation)
{
SetToken = connectionInformation.Token;
SetApiUri = connectionInformation.ApiUri;
SetStorageUri = connectionInformation.StorageUri;
SetForcePathStyle = connectionInformation.GetForcePathStyle;
SetAccountEmail = connectionInformation.AccountEmail;
SetDisableBucketPathsSanitization = connectionInformation.GetDisableBucketPathsSanitization;
}
public void ParseLinesEmptyListReturnAnEmptyObject()
{
var fileinfo = new ConfigurationFileReader();
string[] lines = null;
QarnotCLI.APIConnectionInformation apiInformation = fileinfo.ParseLines(lines);
Assert.AreEqual(apiInformation.Token, null);
Assert.AreEqual(apiInformation.ApiUri, null);
Assert.AreEqual(apiInformation.StorageUri, null);
}
public APIConnectionInformation ParseLines(string[] lines)
{
APIConnectionInformation connectionVariables = new APIConnectionInformation();
if (lines != null)
{
lines.ToList().ForEach(line => GetValue(line, connectionVariables));
}
return(connectionVariables);
}
public void ParseLinesTestMissingInformationReturnAPartialObject()
{
var fileinfo = new ConfigurationFileReader();
string[] lines = new string[]
{
"token=TOKEN",
};
QarnotCLI.APIConnectionInformation apiInformation = fileinfo.ParseLines(lines);
Assert.AreEqual(apiInformation.Token, "TOKEN");
Assert.AreEqual(apiInformation.ApiUri, null);
Assert.AreEqual(apiInformation.StorageUri, null);
}
public void ParseLinesTestNonOrededReturnANormalObject()
{
var fileinfo = new ConfigurationFileReader();
string[] lines = new string[]
{
"storage=BUCKET",
"token=TOKEN",
"uri=URI",
};
QarnotCLI.APIConnectionInformation apiInformation = fileinfo.ParseLines(lines);
Assert.AreEqual(apiInformation.Token, "TOKEN");
Assert.AreEqual(apiInformation.ApiUri, "URI");
Assert.AreEqual(apiInformation.StorageUri, "BUCKET");
}
public void SetConfigInformation(string path, IConfiguration config)
{
APIConnectionInformation info = new APIConnectionInformation();
if (FileWrap.DoesFileExist(path))
{
info = this.FileInformationGetter.ReadFile(path);
}
else
{
this.CheckDirectory(path);
}
var apiConfig = config as LocalSetUpConfiguration;
config.ApiConnection.Update(info);
this.SetConfigFile(path, config.ApiConnection);
}
public void GetValue(string line, APIConnectionInformation connectionVariables)
{
if (!line.Contains("="))
{
return;
}
var splitline = line.Split('=');
switch (splitline[0])
{
case "token":
connectionVariables.Token = splitline[1];
break;
case "uri":
connectionVariables.ApiUri = splitline[1];
break;
case "storage":
connectionVariables.StorageUri = splitline[1];
break;
case "account-email":
connectionVariables.AccountEmail = splitline[1];
break;
case "force-path":
connectionVariables.SetForcePathStyleString(splitline[1]);
break;
case "disable-path-sanitization":
connectionVariables.SetDisableBucketPathsSanitizationString(splitline[1]);
break;
case "unsafe-ssl":
connectionVariables.SetUnsafeSslString(splitline[1]);
break;
case "storage-unsafe-ssl":
connectionVariables.SetStorageUnsafeSslString(splitline[1]);
break;
}
}
public void ParseLinesTestMoreThanRequiredVariablesSendNoError()
{
var fileinfo = new ConfigurationFileReader();
string[] lines = new string[]
{
"token=TOKENTOEARLY",
"token=TOKEN",
"test=NOT1",
"token123=NOT2",
"abctoken=NOT3",
"tokenTOKEN=",
"uri=URI",
"storage=BUCKET",
};
QarnotCLI.APIConnectionInformation apiInformation = fileinfo.ParseLines(lines);
Assert.AreEqual(apiInformation.Token, "TOKEN");
Assert.AreEqual(apiInformation.ApiUri, "URI");
Assert.AreEqual(apiInformation.StorageUri, "BUCKET");
}
/// <summary>
/// Add the miss information to the APIConnectionInformation.
/// </summary>
/// <param name="apiInfo">Object contain the Api info form the env and file.</param>
/// <returns>Object contain the Api info.</returns>
public APIConnectionInformation RetrieveConfigurationInformation(APIConnectionInformation apiInfo)
{
GetEnvConnectionInformation.RetrieveEnvironmentInformation(apiInfo);
if (apiInfo.IsComplete())
{
return(apiInfo);
}
try
{
string configFilePath = this.GetConfigFilePath();
APIConnectionInformation fileInfo = this.FileInformationGetter.ReadFile(configFilePath);
apiInfo.Update(fileInfo);
}
catch (FileNotFoundException)
{
if (string.IsNullOrEmpty(apiInfo.Token))
{
throw;
}
}
return(apiInfo);
}
private void ShowConfiguration(APIConnectionInformation info)
{
string information = "connection information:" + Environment.NewLine;
CLILogs.Info(information + info.ToString());
}
