async Task <CommitID> TestCreateCommit(TreeID treeid, int num)
{
var db = getDataContext();
ICommitRepository cmrepo = new CommitRepository(db);
IRefRepository rfrepo = new RefRepository(db);
Tuple <Ref, Commit> parent = await cmrepo.GetCommitByRef("HEAD");
Commit cm = new Commit.Builder(
pParents: parent == null ? new List <CommitID>(0) : new List <CommitID>(1)
{
parent.Item2.ID
},
pTreeID: treeid,
pCommitter: "James Dunne <*****@*****.**>",
pDateCommitted: DateTimeOffset.Parse("2011-08-29 00:00:00 -0500"),
pMessage: "Commit #" + num.ToString() + "."
);
Console.WriteLine("CommitID {0}", cm.ID);
// Persist the commit:
await cmrepo.PersistCommit(cm);
// Once the commit is persisted, update HEAD ref:
await rfrepo.PersistRef(new Ref.Builder("HEAD", cm.ID));
return(cm.ID);
}
protected override CommonTest.TagRepositoryTestMethods getTestMethods(FileSystem system)
{
IStreamedBlobRepository blrepo = new StreamedBlobRepository(system);
ITreeRepository trrepo = new TreeRepository(system);
ICommitRepository cmrepo = new CommitRepository(system);
ITagRepository tgrepo = new TagRepository(system);
IRefRepository rfrepo = new RefRepository(system);
return(new CommonTest.TagRepositoryTestMethods(cmrepo, blrepo, trrepo, tgrepo, rfrepo));
}
protected override CommonTest.RefRepositoryTestMethods getTestMethods(DataContext db)
{
IStreamedBlobRepository blrepo = new StreamedBlobRepository(db);
ITreeRepository trrepo = new TreeRepository(db);
ICommitRepository cmrepo = new CommitRepository(db);
ITagRepository tgrepo = new TagRepository(db);
IRefRepository rfrepo = new RefRepository(db);
return(new CommonTest.RefRepositoryTestMethods(cmrepo, blrepo, trrepo, tgrepo, rfrepo));
}
async Task TestGetCommitTree()
{
var db = getDataContext();
IRefRepository rfrepo = new RefRepository(db);
ICommitRepository cmrepo = new CommitRepository(db);
var rf = await rfrepo.GetRef("HEAD");
Debug.Assert(rf != null);
var cmTree = await cmrepo.GetCommitTree(rf.CommitID, depth : 10);
// TODO: gather up another 10-deep commit tree from the last partial commit?
RecursivePrint(cmTree.Item1, cmTree.Item2);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# PWSO receive sms message process.");
var requestBody = await new StreamReader(req.Body).ReadToEndAsync();
log.LogInformation(requestBody);
var formValues = requestBody.Split('&')
.Select(value => value.Split('='))
.ToDictionary(pair => Uri.UnescapeDataString(pair[0]).Replace("+", " "),
pair => Uri.UnescapeDataString(pair[1]).Replace("+", " "));
var dto = new EventTextDto
{
Message = formValues["Body"],
From = formValues["From"],
Zip = formValues["FromZip"],
City = formValues["FromCity"]
};
//var dto = new EventTextDto{Message = "Track", From = "17035901821", Zip = "22193", City = "Dale City"} ;
string responseMessage;
try
{
var connectionString = System.Environment.GetEnvironmentVariable("SQLAZURECONNSTR_TrainingModel");
var azureConnectionString = System.Environment.GetEnvironmentVariable("AzureStorageConnectionString");
var options = new DbContextOptionsBuilder <PwsodbContext>().UseSqlServer(connectionString ?? throw new InvalidOperationException()).Options;
var context = new PwsodbContext(options);
ITrainingRepository trainingRepository = new TrainingRepository(context);
IRefRepository refRepository = new RefRepository(azureConnectionString);
var worker = new RegistrantWorker(trainingRepository, refRepository);
var notification = worker.AddNumberForEvent(dto);
responseMessage = notification.Result.Message;
}
catch (Exception e)
{
log.LogError("Fatal Error: " + e.ToString());
throw;
}
responseMessage += ". This message is from the PWSO Notification System.";
return(new OkObjectResult(responseMessage));
}
public SQLSystemContext(string dataSource)
{
// @"Data Source=.\SQLEXPRESS;Initial Catalog=IVO;Integrated Security=SSPI"
Asynq.DataContext db = new Asynq.DataContext(dataSource);
TreeRepository trrepo = new TreeRepository(db);
StreamedBlobRepository blrepo = new StreamedBlobRepository(db);
TreePathStreamedBlobRepository tpsbrepo = new TreePathStreamedBlobRepository(db, blrepo);
TagRepository tgrepo = new TagRepository(db);
RefRepository rfrepo = new RefRepository(db);
StageRepository strepo = new StageRepository(db);
CommitRepository cmrepo = new CommitRepository(db);
this.trrepo = trrepo;
this.blrepo = blrepo;
this.tpsbrepo = tpsbrepo;
this.tgrepo = tgrepo;
this.rfrepo = rfrepo;
this.strepo = strepo;
this.cmrepo = cmrepo;
this.db = db;
}
public CommitRepository(DataContext db)
{
this.db = db;
this.tgrepo = new TagRepository(db);
this.rfrepo = new RefRepository(db);
}
async Task DemonstrateHashing()
{
var db = getDataContext();
IBlobRepository blrepo = new BlobRepository(db);
ITreeRepository trrepo = new TreeRepository(db);
ICommitRepository cmrepo = new CommitRepository(db);
IRefRepository rfrepo = new RefRepository(db);
// Create a sample set of blobs:
Blob readmeBlob;
ImmutableContainer <BlobID, Blob> blobs = new ImmutableContainer <BlobID, Blob>(
bl => bl.ID,
readmeBlob = new Blob.Builder(pContents: Encoding.UTF8.GetBytes(@"Hello world"))
);
Console.Out.WriteAsync(String.Format("Blob {0} = \"{1}\"" + Environment.NewLine, readmeBlob.ID.ToString(firstLength: 7), Encoding.UTF8.GetString(readmeBlob.Contents)));
// Persist them:
var persistingBlobs = blrepo.PersistBlobs(blobs);
// Create an initial tree:
Tree trRoot;
ImmutableContainer <TreeID, Tree> trees = new ImmutableContainer <TreeID, Tree>(
tr => tr.ID,
new Tree[] {
trRoot = new Tree.Builder(
pTrees: new List <TreeTreeReference>(0),
pBlobs: new List <TreeBlobReference> {
new TreeBlobReference.Builder(pName: "README", pBlobID: readmeBlob.ID)
}
)
}
);
// Dump the tree:
RecursivePrint(trRoot.ID, trees);
// Now wait for the blob persistence to complete:
await persistingBlobs;
// Persist our tree now:
var persistTrees = trrepo.PersistTree(trRoot.ID, trees);
await persistTrees;
// Let's make a commit out of all that:
Commit cm1 = new Commit.Builder(
pParents: new List <CommitID>(0),
pTreeID: trRoot.ID,
pCommitter: @"James Dunne <*****@*****.**>",
pDateCommitted: DateTimeOffset.Now,
pMessage: "Initial commit."
);
// Persist that commit:
Console.Out.WriteAsync(String.Format("Persisting commit {0}..." + Environment.NewLine, cm1.ID.ToString(firstLength: 7)));
await cmrepo.PersistCommit(cm1);
// Let's create a ref to point to it:
await rfrepo.DestroyRefByName("demo/HEAD");
await rfrepo.PersistRef(new Ref.Builder(pName: "demo/HEAD", pCommitID: cm1.ID));
await Console.Out.WriteAsync(String.Format("Pointed demo/HEAD to commit {0}" + Environment.NewLine, cm1.ID.ToString(firstLength: 7)));
// Now let's create a new blob with some revised contents: (adding a period at the end)
Blob readmeBlob2;
blobs = new ImmutableContainer <BlobID, Blob>(
bl => bl.ID,
readmeBlob2 = new Blob.Builder(Encoding.UTF8.GetBytes(@"Hello world."))
);
var persistBlobs2 = blrepo.PersistBlobs(blobs);
// Make a new tree out of the old tree:
Tree.Builder trRoot2b = new Tree.Builder(trRoot);
// Point README to the new BlobID:
trRoot2b.Blobs[0] = new TreeBlobReference.Builder(trRoot2b.Blobs[0])
{
BlobID = readmeBlob2.ID
};
// Freeze our Tree.Builder to a Tree:
Tree trRoot2;
trees = new ImmutableContainer <TreeID, Tree>(tr => tr.ID, trRoot2 = trRoot2b);
// Wait for the blobs to persist:
await persistBlobs2;
// Now persist the new tree:
await trrepo.PersistTree(trRoot2.ID, trees);
// Load a streamed blob:
IStreamedBlob strbl = await blrepo.GetStreamedBlob(readmeBlob.ID);
await strbl.ReadStream(blsr =>
{
Console.WriteLine("blob is {0} length", blsr.Length);
byte[] dum = new byte[8040];
int count = 8040;
try
{
while ((count = blsr.Read(dum, 0, 8040)) > 0)
{
for (int i = 0; i < (count / 40) + ((count % 40) > 0 ? 1 : 0); ++i)
{
Console.WriteLine(dum.ToHexString(i * 40, Math.Min(count - (i * 40), 40)));
}
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.ToString());
}
});
}
