public async Task TestCommitFlightFailure()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var json = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\flight.json");
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).Returns(Task.Factory.StartNew(() => new Tuple <JObject, HttpStatusCode>(JObject.Parse(json), HttpStatusCode.Created)));
var updatedJson = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\flightupdate.json");
A.CallTo(() => client.UpdateSubmission("myapp", "myflight", "submissionid", JObject.Parse(updatedJson).ToString())).Returns(Task.Factory.StartNew(() => true));
A.CallTo(() => client.Commit("myapp", "myflight", "submissionid")).Returns(Task.Factory.StartNew(() => false));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\package.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config",
Flight = "myflight"
};
var result = await command.CreateSubmission(options);
result.Should().BeNegative("committing the submission failed");
logger.Message.Last().Should().Be(stringprovider.GetString(Strings.SubmitCommitError), "committing the submission failed");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).MustHaveHappened();
A.CallTo(() => client.UpdateSubmission("myapp", "myflight", "submissionid", JObject.Parse(updatedJson).ToString())).MustHaveHappened();
A.CallTo(() => client.Commit("myapp", "myflight", "submissionid")).MustHaveHappened();
}
public async Task TestSubmitNewFlightSubmissionFailure()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var json = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\submission.json");
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).Returns(Task.Factory.StartNew(() => new Tuple <JObject, HttpStatusCode>(JObject.Parse(json), HttpStatusCode.NotFound)));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\package.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config",
Flight = "myflight"
};
var result = await command.CreateSubmission(options);
result.Should().BeNegative("the creation of submission failed");
logger.Message.Last().Should().Be(stringprovider.GetString(Strings.VerifyParameters), "there's something wrong with the parameters");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
A.CallTo(() => client.CreateSubmission("myapp", "myflight")).MustHaveHappened();
}
public async Task TestSubmitSuccess()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var json = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\submission.json");
A.CallTo(() => client.CreateSubmission("myapp")).Returns(Task.Factory.StartNew(() => new Tuple <JObject, HttpStatusCode>(JObject.Parse(json), HttpStatusCode.Created)));
var updatedJson = File.ReadAllText($"{this.GetExecutingPath()}\\Files\\submissionupdate.json");
A.CallTo(() => client.UpdateSubmission("myapp", "submissionid", JObject.Parse(updatedJson).ToString())).Returns(Task.Factory.StartNew(() => true));
A.CallTo(() => client.Commit("myapp", "submissionid")).Returns(Task.Factory.StartNew(() => true));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\package.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config"
};
var result = await command.CreateSubmission(options);
result.Should().BeGreaterOrEqualTo(0, "the zip file contains app packages and everything worked out ok");
logger.Message.Last().Should().Be(stringprovider.GetString(Strings.SubmitCommitSuccess), "everything went according to plan");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
A.CallTo(() => client.CreateSubmission("myapp")).MustHaveHappened();
A.CallTo(() => client.UpdateSubmission("myapp", "submissionid", JObject.Parse(updatedJson).ToString())).MustHaveHappened();
A.CallTo(() => client.Commit("myapp", "submissionid")).MustHaveHappened();
}
private async Task <bool> UpdateSubmission(SubmitOptions submitOptions, string submissionId, JObject body)
{
bool updateResult;
Logger.InfoWithProgress(StringProvider.GetString(Strings.SubmitUpdating));
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
updateResult = await Client.UpdateSubmission(submitOptions.Application, submissionId, body.ToString());
}
else
{
updateResult = await Client.UpdateSubmission(submitOptions.Application, submitOptions.Flight, submissionId, body.ToString());
}
Logger.StopProgress();
return(updateResult);
}
private JObject UpdatePackages(SubmitOptions submitOptions, JObject submission, IEnumerable <string> zipPackages)
{
var packagesReference = string.IsNullOrWhiteSpace(submitOptions.Flight) ? "applicationPackages" : "flightPackages";
var packages = (JArray)submission[packagesReference];
var newPackages = new JArray();
foreach (var package in packages)
{
package["fileStatus"] = "PendingDelete";
newPackages.Add(package);
}
// Add the new packages as PendingUpload
foreach (var package in zipPackages.Select(fileName => new JObject {
{ "fileName", fileName }, { "fileStatus", "PendingUpload" }
}))
{
newPackages.Add(package);
}
packages.Replace(newPackages);
return(submission);
}
public async Task TestSubmitZipfileNoPackages()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new SubmitCommand(client, logger, stringprovider);
var packageFileLocation = $"{this.GetExecutingPath()}\\Files\\nopackage.zip";
var options = new SubmitOptions
{
PackagesFile = packageFileLocation,
Application = "myapp",
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config"
};
var result = await command.CreateSubmission(options);
result.Should().BeNegative("the zip file does not contain app packages");
logger.Message.Last().Should().Be(Format(stringprovider.GetString(Strings.ValidatePackageNoPackages), packageFileLocation), "The provided zip file does not contain any packages");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
}
private async Task <JObject> NewSubmission(SubmitOptions submitOptions)
{
Tuple <JObject, HttpStatusCode> deployResult;
Logger.InfoWithProgress(StringProvider.GetString(Strings.SubmitCreating));
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
deployResult = await Client.CreateSubmission(submitOptions.Application);
}
else
{
deployResult = await Client.CreateSubmission(submitOptions.Application, submitOptions.Flight);
}
Logger.StopProgress();
if (deployResult.Item2.Equals(HttpStatusCode.Created))
{
return(deployResult.Item1);
}
Logger.Error(StringProvider.GetString(Strings.SubmitCreateError));
Logger.Info(StringProvider.GetString(Strings.VerifyParameters));
return(null);
}
private async Task <JObject> NewSubmission(SubmitOptions submitOptions)
{
Tuple <JObject, HttpStatusCode> deployResult;
Logger.InfoWithProgress("Creating new submission");
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
deployResult = await Client.CreateSubmission(submitOptions.Application);
}
else
{
deployResult = await Client.CreateSubmission(submitOptions.Application, submitOptions.Flight);
}
Logger.StopProgress();
if (deployResult.Item2.Equals(HttpStatusCode.Created))
{
return(deployResult.Item1);
}
Logger.Error("I was unable to create a new submission.");
Logger.Info("Would you mind to verify the provided parameters and order again?");
return(null);
}
private async Task <bool> CommitSubmission(SubmitOptions submitOptions, string submissionId)
{
bool commitResult;
Logger.InfoWithProgress(StringProvider.GetString(Strings.SubmitCommitting));
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
commitResult = await Client.Commit(submitOptions.Application, submissionId);
}
else
{
commitResult = await Client.Commit(submitOptions.Application, submitOptions.Flight, submissionId);
}
Logger.StopProgress();
if (commitResult)
{
Logger.Info(StringProvider.GetString(Strings.SubmitCommitSuccess));
}
else
{
Logger.Error(StringProvider.GetString(Strings.SubmitCommitError));
}
return(commitResult);
}
private async Task <bool> CommitSubmission(SubmitOptions submitOptions, string submissionId)
{
bool commitResult;
Logger.InfoWithProgress("Committing submission");
if (string.IsNullOrWhiteSpace(submitOptions.Flight))
{
commitResult = await Client.Commit(submitOptions.Application, submissionId);
}
else
{
commitResult = await Client.Commit(submitOptions.Application, submitOptions.Flight, submissionId);
}
Logger.StopProgress();
if (commitResult)
{
Logger.Info("The submission has been successfully comitted, sir.");
}
else
{
Logger.Error("the submission could not be comitted.");
}
return(commitResult);
}
public async Task <int> CreateSubmission(SubmitOptions options)
{
_submitOptions = options;
return(await HandleCommand(options.ConfigFile, options.Verbose));
}
public void send_submitTopologyWithOpts(string name, string uploadedJarLocation, string jsonConf, StormTopology topology, SubmitOptions options)
#endif
{
oprot_.WriteMessageBegin(new TMessage("submitTopologyWithOpts", TMessageType.Call, seqid_));
submitTopologyWithOpts_args args = new submitTopologyWithOpts_args();
args.Name = name;
args.UploadedJarLocation = uploadedJarLocation;
args.JsonConf = jsonConf;
args.Topology = topology;
args.Options = options;
args.Write(oprot_);
oprot_.WriteMessageEnd();
#if SILVERLIGHT
return oprot_.Transport.BeginFlush(callback, state);
#else
oprot_.Transport.Flush();
#endif
}
public IAsyncResult send_submitTopologyWithOpts(AsyncCallback callback, object state, string name, string uploadedJarLocation, string jsonConf, StormTopology topology, SubmitOptions options)
public void submitTopologyWithOpts(string name, string uploadedJarLocation, string jsonConf, StormTopology topology, SubmitOptions options)
{
#if !SILVERLIGHT
send_submitTopologyWithOpts(name, uploadedJarLocation, jsonConf, topology, options);
recv_submitTopologyWithOpts();
#else
var asyncResult = Begin_submitTopologyWithOpts(null, null, name, uploadedJarLocation, jsonConf, topology, options);
End_submitTopologyWithOpts(asyncResult);
#endif
}
public IAsyncResult Begin_submitTopologyWithOpts(AsyncCallback callback, object state, string name, string uploadedJarLocation, string jsonConf, StormTopology topology, SubmitOptions options)
{
return send_submitTopologyWithOpts(callback, state, name, uploadedJarLocation, jsonConf, topology, options);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Name = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
UploadedJarLocation = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
JsonConf = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct) {
Topology = new StormTopology();
Topology.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct) {
Options = new SubmitOptions();
Options.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
