public void GivenImages_ShouldReportEach()
{
var images = new[]
{
new CompressionResult
{
Title = "path/to/image.png",
SizeBefore = 100.3678,
SizeAfter = 95.78743
},
new CompressionResult
{
Title = "path/to/image2.png",
SizeBefore = 500.3234,
SizeAfter = 360.1321987
},
};
var message = CommitMessage.Create(images);
var expectedMessage = KnownGitHubs.CommitMessageTitle + Environment.NewLine +
Environment.NewLine +
"*Total -- 600.69kb -> 455.92kb (24.1%)" + Environment.NewLine +
Environment.NewLine +
"path/to/image2.png -- 500.32kb -> 360.13kb (28.02%)" + Environment.NewLine +
"path/to/image.png -- 100.37kb -> 95.79kb (4.56%)" + Environment.NewLine +
Environment.NewLine +
"Signed-off-by: ImgBotApp <*****@*****.**>" + Environment.NewLine;
Assert.AreEqual(expectedMessage, message);
}
public ValueMessage HandleCommit(int sender, CommitMessage message)
{
if (message.EncryptedRows.Length != Players)
{
throw new ArgumentException();
}
if (_keyGenStates[sender].Commitment != null)
{
throw new ArgumentException($"Double commit from sender {sender}");
}
_keyGenStates[sender].Commitment = message.Commitment;
var myRowCommitted = message.Commitment.Evaluate(_myIdx + 1);
var myRow = DecryptRow(message.EncryptedRows[_myIdx], _keyPair.PrivateKey).ToArray();
if (!myRow.Select(x => G1.Generator * x).SequenceEqual(myRowCommitted))
{
throw new ArgumentException("Commitment does not match");
}
return(new ValueMessage
{
Proposer = sender,
EncryptedValues = Enumerable.Range(0, Players).Select(i => Crypto.Secp256K1Encrypt(
_publicKeys[i].EncodeCompressed(),
MclBls12381.EvaluatePolynomial(myRow, Fr.FromInt(i + 1)).ToBytes()
)).ToArray()
});
}
private IEnumerable <CommitMessage> GetCommitMessages(string body)
{
dynamic root = JObject.Parse(body);
var commitMessages = new List <CommitMessage>();
foreach (var commit in root.commits)
{
var commitMessage = new CommitMessage(
new Author()
{
Email = commit.author.email.ToString(),
Name = commit.author.name.ToString(),
Url = GetUserUrl(commit.author.username.ToString())
},
DateTimeOffset.Parse(commit.timestamp.ToString()),
commit.message.ToString(),
new Repo()
{
Name = root.repository.name.ToString(),
Url = root.repository.url.ToString()
},
"GitHub",
new CommitId()
{
Name = commit.id.ToString(),
Url = commit.url.ToString()
},
null
);
commitMessages.Add(commitMessage);
}
return(commitMessages);
}
public void GivenUnderscorePrefix_ShouldRenderUnderscore()
{
var images = new[]
{
new CompressionResult
{
Title = "path\\to\\_image.png",
SizeBefore = 200.9678,
SizeAfter = 195.12365354
},
new CompressionResult
{
Title = "path\\to\\image2.png",
SizeBefore = 300.9234,
SizeAfter = 260.555
},
};
var message = CommitMessage.Create(images);
var expectedMessage = $@"{KnownGitHubs.CommitMessageTitle}
*Total -- 501.89kb -> 455.68kb (9.21%)
path/to/image2.png -- 300.92kb -> 260.56kb (13.41%)
path/to/_image.png -- 200.97kb -> 195.12kb (2.91%)
";
Assert.AreEqual(expectedMessage, message);
}
public void GivenImages_ShouldReportEach()
{
var images = new[]
{
new CompressionResult
{
Title = "path/to/image.png",
SizeBefore = 100.3678,
SizeAfter = 95.78743
},
new CompressionResult
{
Title = "path/to/image2.png",
SizeBefore = 500.3234,
SizeAfter = 360.1321987
},
};
var message = CommitMessage.Create(images);
var expectedMessage = $@"{KnownGitHubs.CommitMessageTitle}
*Total -- 600.69kb -> 455.92kb (24.1%)
path/to/image2.png -- 500.32kb -> 360.13kb (28.02%)
path/to/image.png -- 100.37kb -> 95.79kb (4.56%)
";
Assert.AreEqual(expectedMessage, message);
}
public void GivenBackslashes_ShouldRenderForwardSlashes()
{
var images = new[]
{
new CompressionResult
{
Title = "path\\to\\image.png",
SizeBefore = 200.9678,
SizeAfter = 195.12365354
},
new CompressionResult
{
Title = "path\\to\\image2.png",
SizeBefore = 300.9234,
SizeAfter = 260.555
},
};
var message = CommitMessage.Create(images);
var expectedMessage = KnownGitHubs.CommitMessageTitle + Environment.NewLine +
Environment.NewLine +
"*Total -- 501.89kb -> 455.68kb (9.21%)" + Environment.NewLine +
Environment.NewLine +
"path/to/image2.png -- 300.92kb -> 260.56kb (13.41%)" + Environment.NewLine +
"path/to/image.png -- 200.97kb -> 195.12kb (2.91%)" + Environment.NewLine +
Environment.NewLine +
"Signed-off-by: ImgBotApp <*****@*****.**>" + Environment.NewLine;
Assert.AreEqual(expectedMessage, message);
}
public void CanCreateCommitMessage()
{
var msg = new CommitMessage("asdf", "The subject");
Assert.AreEqual("asdf", msg.Hash);
Assert.AreEqual("The subject", msg.Subject);
}
protected override async Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
// Object Container: Use objectContainer.Get<T>() to retrieve objects from the scope
var objectContainer = context.GetFromContext <IObjectContainer>(BitbucketAPIScope.ParentContainerPropertyTag);
var client = objectContainer.Get <FluentClient>();
// Inputs
var repositoryLocation = RepositoryLocation.Get(context);
var fileToUpload = FileToUpload.Get(context);
var commitMessage = CommitMessage.Get(context);
var repositoryUUIDOrSlug = RepositoryUUIDOrSlug.Get(context);
var workspaceUUIDOrSlug = WorkspaceUUIDOrSlug.Get(context);
var branchName = BranchName.Get(context);
// Validate whether Workspace UUID or Name provided (assume name will never be a GUID format)
if (Validation.IsUUID(workspaceUUIDOrSlug))
{
HttpUtility.UrlEncode(workspaceUUIDOrSlug);
}
// Validate whether Repository UUID or Slug provided (assume slug will never be a GUID format)
if (Validation.IsUUID(repositoryUUIDOrSlug))
{
HttpUtility.UrlEncode(repositoryUUIDOrSlug);
}
// Create standard request URI
var uri = "repositories/" + workspaceUUIDOrSlug + "/" + repositoryUUIDOrSlug + "/src";
// Initialise and populate multipart content
var multipartContent = new MultipartFormDataContent();
multipartContent.Add(new ByteArrayContent(File.ReadAllBytes(fileToUpload)), repositoryLocation, Path.GetFileName(fileToUpload));
multipartContent.Add(new StringContent(commitMessage), "message");
// Check if optional branch name parameter provided. Add to request if not null.
if (branchName != null)
{
multipartContent.Add(new StringContent(branchName), "branch");
}
// Execution Logic
var response = new JObject();
var exceptionHandler = new ApiExceptionHandler();
try
{
response = await AsyncRequests.PostRequest_WithBody(client, uri, cancellationToken, multipartContent);
}
catch (ApiException ex) // Catches any API exception and returns the message
{
await exceptionHandler.ParseExceptionAsync(ex);
}
// Outputs - API response as JObject
return((ctx) =>
{
JsonResult.Set(ctx, response);
});
}
private IEnumerable<CommitMessage> GetCommitMessages(string body)
{
dynamic root = JObject.Parse(body);
var commitMessages = new List<CommitMessage>();
foreach (var commit in root.commits)
{
var commitMessage = new CommitMessage(
new Author()
{
Email = commit.author.email.ToString(),
Name = commit.author.name.ToString(),
Url = GetUserUrl(commit.author.username.ToString())
},
DateTimeOffset.Parse(commit.timestamp.ToString()),
commit.message.ToString(),
new Repo()
{
Name = root.repository.name.ToString(),
Url = root.repository.url.ToString()
},
"GitHub",
new CommitId()
{
Name = commit.id.ToString(),
Url = commit.url.ToString()
},
null
);
commitMessages.Add(commitMessage);
}
return commitMessages;
}
public void GivenNullOrEmptyCompressionResults_ShouldCreateEmptyString()
{
var message = CommitMessage.Create(null);
Assert.AreEqual(string.Empty, message);
var message2 = CommitMessage.Create(new CompressionResult[0]);
Assert.AreEqual(string.Empty, message);
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
/// <filterpriority>2</filterpriority>
public override int GetHashCode()
{
unchecked
{
int result = Timestamp.GetHashCode();
result = (result * 397) ^ (AuthorName != null ? AuthorName.GetHashCode() : 0);
result = (result * 397) ^ (AuthorEmailAddress != null ? AuthorEmailAddress.GetHashCode() : 0);
result = (result * 397) ^ (CommitMessage != null ? CommitMessage.GetHashCode() : 0);
result = (result * 397) ^ (Branch != null ? Branch.GetHashCode() : 0);
result = (result * 397) ^ (Hash != null ? Hash.GetHashCode() : 0);
result = (result * 397) ^ (LeftParentHash != null ? LeftParentHash.GetHashCode() : 0);
result = (result * 397) ^ (RightParentHash != null ? RightParentHash.GetHashCode() : 0);
return(result);
}
}
public override void Add(MessageModel msg)
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
/*
* if (MaxCapacity > 0 && Index.Count >= MaxCapacity) {
* RemoveAt(0);
* }
*/
var msgFileName = String.Format("{0}.v1.json", MessageNumber++);
var msgFilePath = Path.Combine(RepositoryPath, msgFileName);
using (var writer = File.OpenWrite(msgFilePath))
using (var textWriter = new StreamWriter(writer, Encoding.UTF8)) {
JsonSerializer.SerializeToWriter(msg, textWriter);
}
DateTime start, stop;
lock (Repository) {
start = DateTime.UtcNow;
var index = Repository.Index;
//index.Stage(msgFilePath);
// OPT: Stage() writes the index to disk on each call
index.AddToIndex(msgFileName);
stop = DateTime.UtcNow;
}
#if LOG4NET && MSGBUF_DEBUG
f_Logger.DebugFormat("Add(): Index.AddToIndex() took: {0:0.00} ms",
(stop - start).TotalMilliseconds);
#endif
// FIXME: delete file when index was written to disk
File.Delete(msgFilePath);
lock (CommitMessage) {
CommitMessage.Append(
String.Format("{0}: {1}\n", msgFileName, msg.ToString())
);
}
// TODO: create tree, commit tree, repack repo reguraly (see rugged docs)
}
private void SendCommit(int viewNumber, int commitNumber)
{
if (!this.replicaState.IAmTheLeader())
{
return;
}
Uri[] replicasUrls;
lock (this.replicaState) {
replicasUrls = this.replicaState.ReplicasUrl.ToArray();
}
CommitMessage commitMessage = new CommitMessage(this.replicaState.ServerId, viewNumber, commitNumber);
// Don't wait for response
Task.Factory.StartNew(() =>
this.messageServiceClient.RequestMulticast(commitMessage, replicasUrls, replicasUrls.Length, -1, false));
}
public IResponse VisitCommitMessage(CommitMessage commitMessage)
{
Task.Factory.StartNew(() => {
if (commitMessage.CommitNumber < this.replicaState.CommitNumber &&
commitMessage.ViewNumber != this.replicaState.ViewNumber &&
commitMessage.ServerId != this.replicaState.Leader)
{
return;
}
// It must confirm that it received the prepare message.
while (commitMessage.CommitNumber > this.replicaState.OpNumber)
{
this.replicaState.HandlersCommits.WaitOne();
}
this.replicaState.ExecuteFromUntil(this.replicaState.CommitNumber, commitMessage.CommitNumber);
});
return(null);
}
public void GivenOneImage_ShouldReportSingleImageNoTotal()
{
var images = new[]
{
new CompressionResult
{
Title = "path/to/image.png",
SizeBefore = 100.3,
SizeAfter = 95.7
},
};
var message = CommitMessage.Create(images);
var expectedMessage = KnownGitHubs.CommitMessageTitle + Environment.NewLine +
Environment.NewLine +
"path/to/image.png -- 100.30kb -> 95.70kb (4.59%)" + Environment.NewLine;
Assert.AreEqual(expectedMessage, message);
}
public Translation.Result Execute(InboundMessage message)
{
try
{
XDocument document = DecodeContentAndCreateDocument(message);
CommitMessage commit = ParseXmlDocument(document);
return(Translation.SuccessWithContent(
new List <CommitMessage> {
commit
},
new StringContent(GetResponseBody(), Encoding.UTF8, GetMediaType())
));
}
catch
{
return(Translation.FailureWithContent(
"It was not possible to translate the message.",
new StringContent(GetResponseBody(), Encoding.UTF8, GetMediaType())
));
}
}
public override void Flush()
{
Trace.Call();
var repo = Repository;
if (repo == null)
{
return;
}
lock (repo)
lock (CommitMessage) {
if (CommitMessage.Length == 0)
{
// nothing to commit
return;
}
DateTime start, stop;
start = DateTime.UtcNow;
repo.Index.UpdatePhysicalIndex();
stop = DateTime.UtcNow;
#if LOG4NET && MSGBUF_DEBUG
f_Logger.DebugFormat("Commit(): Repository.Index.UpdatePhysicalIndex() took: {0:0.00} ms",
(stop - start).TotalMilliseconds);
#endif
start = DateTime.UtcNow;
repo.Commit(CommitMessage.ToString(), false);
stop = DateTime.UtcNow;
#if LOG4NET && MSGBUF_DEBUG
f_Logger.DebugFormat("Commit(): Repository.Commit() took: {0:0.00} ms",
(stop - start).TotalMilliseconds);
#endif
CommitMessage.Clear();
}
}
public void GivenACommitMessage_ShouldCorrectlyParse()
{
var commitMessage = KnownGitHubs.CommitMessageTitle + Environment.NewLine +
Environment.NewLine +
"*Total -- 501.89kb -> 455.68kb (9.21%)" + Environment.NewLine
+ Environment.NewLine +
"path/to/image.png -- 200.97kb -> 195.12kb (2.91%)" + Environment.NewLine +
"path/to/image2.png -- 300.92kb -> 260.56kb (13.41%)" + Environment.NewLine +
Environment.NewLine +
"Signed-off-by: ImgBotApp <*****@*****.**>" + Environment.NewLine;
var expected = new[]
{
new CompressionResult
{
Title = "path/to/image.png",
SizeBefore = 200.97,
SizeAfter = 195.12
},
new CompressionResult
{
Title = "path/to/image2.png",
SizeBefore = 300.92,
SizeAfter = 260.56
},
};
var parsed = CommitMessage.Parse(commitMessage);
Assert.AreEqual(parsed.Length, expected.Length);
for (int i = 0; i < parsed.Length; ++i)
{
Assert.AreEqual(parsed[i].Title, expected[i].Title);
Assert.AreEqual(parsed[i].SizeBefore, expected[i].SizeBefore);
Assert.AreEqual(parsed[i].SizeAfter, expected[i].SizeAfter);
}
}
public static ChangeLogEntry FromCommitMessage(GitCommit commit, CommitMessage commitMessage)
{
var breakingChangeDescriptions = commitMessage.Footers
.Where(x => x.Name.IsBreakingChange)
.Select(x => x.Value)
.ToArray();
var footers = commitMessage.Footers
.Where(x => !x.Name.IsBreakingChange)
.Select(ChangeLogEntryFooter.FromCommitMessageFooter);
return(new ChangeLogEntry(
date: commit.Date,
type: commitMessage.Header.Type,
scope: commitMessage.Header.Scope,
isBreakingChange: commitMessage.Header.IsBreakingChange,
summary: commitMessage.Header.Description,
body: commitMessage.Body,
footers: footers,
breakingChangeDescriptions: breakingChangeDescriptions,
commit: commit.Id
));
}
public static void Handle(
CommitMessage message,
Replica replica,
uint secretHash,
int[] block,
ICollection <int[]> blockchain,
byte[] encryptedReplicaSecret,
out string nextSecretShare,
out Dictionary <int, uint> nextChildSecretHashes,
Dictionary <int, CancellationTokenSource> secretShareMessageTokenSources)
{
if (Crypto.GetHash(message.Secret + replica.Tee.LatestCounter + replica.Tee.ViewNumber) != secretHash)
{
Log(replica, "Send RequestViewChangeMessage to all active replicas.");
throw new InvalidOperationException("Invalid secret hash.");
}
// add the same block as a primary replica
Thread.Sleep(rnd.Next(MinTimeToAddBlockIntoBlockchain, MaxTimeToAddBlockIntoBlockchain));
blockchain.Add(block);
var commitResult = blockchain.Count;
if (message.CommitResult != commitResult)
{
Log(replica, "Send RequestViewChangeMessage to all active replicas.");
throw new InvalidOperationException("Inconsitent commit result.");
}
uint nextSecretHash;
replica.Tee.VerifyCounter(
replica.PrimaryReplica.PublicKey,
message.CommitResultHashCounterViewNumber,
encryptedReplicaSecret,
out nextSecretShare,
out nextChildSecretHashes,
out nextSecretHash);
if (replica.ChildReplicas.Any())
{
foreach (var childReplica in replica.ChildReplicas)
{
var tokenSource = new CancellationTokenSource();
Task.Delay(5000, tokenSource.Token)
.ContinueWith(t =>
{
if (!t.IsCanceled)
{
// we send message about a suspected replica to the primary replica
Network.EmulateLatency();
replica.PrimaryReplica.SendMessage(
new SuspectMessage
{
ReplicaId = childReplica.Id
});
}
});
secretShareMessageTokenSources.Add(childReplica.Id, tokenSource);
}
}
else
{
// we send a message with a secret share to the parent replica
Network.EmulateLatency();
replica.ParentReplica.SendMessage(
new SecretShareMessage
{
ReplicaId = replica.Id,
ReplicaSecretShares = new Dictionary <int, string>()
{
{ replica.Id, nextSecretShare }
}
});
Log(replica, "Send a secret share to the parent replica (ParentReplicaId: {0})", replica.ParentReplica.Id);
}
}
public IResponse VisitCommitMessage(CommitMessage commitMessage)
{
return(this.WaitNormalState(commitMessage));
}
internal XunitSerializableCommitMessage(CommitMessage value) => Value = value
