public async Task <IActionResult> PutStartRecord([FromRoute] int id, [FromBody] StartRecord startRecord)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != startRecord.ID)
{
return(BadRequest());
}
_context.Entry(startRecord).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StartRecordExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static void Initialize(StartSvcContext context)
{
context.Database.EnsureCreated();
// Look for any existing records.
if (context.StartRecord.Any())
{
return; // DB has been seeded
}
var startRecords = new StartRecord[]
{
new StartRecord {
Value = 1001
},
new StartRecord {
Value = 1002
},
new StartRecord {
Value = 1003
},
new StartRecord {
Value = 1004
},
new StartRecord {
Value = 1005
}
};
foreach (StartRecord s in startRecords)
{
context.StartRecord.Add(s);
}
context.SaveChanges();
}
public void CanWriteMultipleStartRecordsToLog()
{
_logRecord = new StartRecord(_logManager, _bufferManager, 1);
var lsn = _logRecord.WriteToLog();
var lsn2 = new StartRecord(_logManager, _bufferManager, 2).WriteToLog();
_logManager.Flush(lsn2);
var page = _fileManager.ResolvePage();
_ = page.Read(new Block(_logFileName, 0));
_ = page.GetInt(0, out var nextResPosition);
_ = page.GetInt(sizeof(int), out var recordType1);
_ = page.GetInt(sizeof(int) * 2, out var transactionId1);
_ = page.GetInt(12 + 0, out var recordLength2);
_ = page.GetInt(12 + sizeof(int), out var recordType2);
_ = page.GetInt(12 + sizeof(int) * 2, out var transactionId2);
Assert.AreEqual(0, lsn);
Assert.AreEqual(1, lsn2);
Assert.AreEqual((sizeof(int) + sizeof(LogRecordType) + sizeof(int)) * 2, nextResPosition);
Assert.AreEqual((int)LogRecordType.Start, recordType1);
Assert.AreEqual(1, transactionId1);
Assert.AreEqual(0, recordLength2);
Assert.AreEqual((int)LogRecordType.Start, recordType2);
Assert.AreEqual(2, transactionId2);
}
public void CanReadMultipleEntriesResetAndReadAgain()
{
var rec1 = new StartRecord(_logManager, _bufferManager, 5);
var lsn1 = rec1.WriteToLog();
var rec2 = new StartRecord(_logManager, _bufferManager, 5);
var lsn2 = rec2.WriteToLog();
var rec3 = new StartRecord(_logManager, _bufferManager, 5);
var lsn3 = rec3.WriteToLog();
_logManager.Flush(lsn3);
_enumerator = new LogRecordEnumerator(_logManager, _bufferManager);
var canRead1 = _enumerator.MoveNext();
var canRead2 = _enumerator.MoveNext();
var canRead3 = _enumerator.MoveNext();
_enumerator.Reset();
var canRead4 = _enumerator.MoveNext();
var canRead5 = _enumerator.MoveNext();
var canRead6 = _enumerator.MoveNext();
Assert.IsTrue(canRead1);
Assert.IsTrue(canRead2);
Assert.IsFalse(canRead3);
Assert.IsTrue(canRead4);
Assert.IsTrue(canRead5);
Assert.IsFalse(canRead6);
}
public void CanGetLegacyEnumerator()
{
var rec = new StartRecord(_logManager, _bufferManager, 5);
var lsn = rec.WriteToLog();
_logManager.Flush(lsn);
_enumerator = new LogRecordEnumerator(_logManager, _bufferManager);
var record = ((IEnumerator)_enumerator).Current;
Assert.IsNotNull(record);
}
public void CanReadStartRecord()
{
var rec = new StartRecord(_logManager, _bufferManager, 5);
var lsn = rec.WriteToLog();
_logManager.Flush(lsn);
_enumerator = new LogRecordEnumerator(_logManager, _bufferManager);
var record = _enumerator.Current as StartRecord;
Assert.AreEqual(LogRecordType.Start, record.Type);
Assert.AreEqual(5, record.TransactionNumber);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
StartRecord = await _context.StartRecord.FirstOrDefaultAsync(m => m.ID == id);
if (StartRecord == null)
{
return(NotFound());
}
return(Page());
}
public void CanReadBackwardsFromLog()
{
_logRecord = new StartRecord(_logManager, _bufferManager, 1);
var lsn = _logRecord.WriteToLog();
_logManager.Flush(lsn);
var enumerator = _logManager.GetEnumerator();
var basicLogRecord = enumerator.Current;
var logRecord = new StartRecord(_logManager, _bufferManager, basicLogRecord);
Assert.AreEqual(LogRecordType.Start, logRecord.Type);
Assert.AreEqual(1, logRecord.TransactionNumber);
}
internal Timing(LoggingTimer timer, long timingId)
{
_parentTimer = timer;
_id = timingId;
_startDateTime = DateTime.Now;
_stopDateTime = null;
var startRecord = new StartRecord()
{
StartDateTime = _startDateTime,
Timer = _parentTimer,
TimingId = _id
};
_parentTimer._startWriter.Write(ref startRecord);
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
StartRecord = await _context.StartRecord.FindAsync(id);
if (StartRecord != null)
{
_context.StartRecord.Remove(StartRecord);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public void CanRecoverFromUncommitedAndCommitedTransactions()
{
var page = _fileManager.ResolvePage();
var block = new Block(RandomFilename, 0);
page.Read(block);
page.SetInt(0, 222);
page.Write(block);
var startRecord = new StartRecord(_logManager, _bufferManager, 1);
var lsn = startRecord.WriteToLog();
_logManager.Flush(lsn);
var startRecord2 = new StartRecord(_logManager, _bufferManager, 2);
var lsn2 = startRecord2.WriteToLog();
_logManager.Flush(lsn2);
_recoveryManager = new RecoveryManager(_bufferManager, _logManager, 1);
var buffer = _bufferManager.Pin(block);
_recoveryManager.SetInt(buffer, 0, 123);
_recoveryManager.SetByte(buffer, 0, 1);
_recoveryManager.Commit();
var recoveryManager2 = new RecoveryManager(_bufferManager, _logManager, 2);
recoveryManager2.SetByte(buffer, 1, 0);
Assert.DoesNotThrow(() =>
{
recoveryManager2.Recover();
_bufferManager.Unpin(buffer);
});
page.Read(block);
_ = page.GetInt(0, out var resultValue);
Assert.AreEqual(222, resultValue);
}
public IEnumerable <StartRecord> PostStartRecord([FromHeader] int reqNum)
{
if (!ModelState.IsValid)
{
return(null);
}
StartRecord[] stRecArray = new StartRecord[3];
for (int i = 0; i < 3; i++)
{
stRecArray[i] = new StartRecord {
Value = 40000 + i
};
_context.StartRecord.Add(stRecArray[i]);
}
_context.SaveChangesAsync();
return(stRecArray);
}
public RecordModel()
{
StartRecord = State.Select(s => s == ModelState.Ready).ToReactiveCommand();
EndRecord = State.Select(s => s == ModelState.Recording).ToReactiveCommand();
State.OnNext(ModelState.Ready);
StartRecord
.ObserveOn(TaskPoolScheduler.Default)
.SelectMany(_ => DoRecord())
.CatchIgnore((Exception _) => Status.OnNext("録画に失敗しました。"))
.Repeat()
.Subscribe();
OpenSaveFolder
.Select(_ => SaveFolder.Value)
.StartProcess()
.Select(r => r ? "フォルダを開きました。" : "フォルダを開けませんでした。")
.Subscribe(Status);
}
public void CanRecoverSimpleTransaction()
{
var startRecord = new StartRecord(_logManager, _bufferManager, 6);
var lsn = startRecord.WriteToLog();
_logManager.Flush(lsn);
_recoveryManager = new RecoveryManager(_bufferManager, _logManager, 6);
var block = new Block(RandomFilename, 0);
var buffer = _bufferManager.Pin(block);
_recoveryManager.SetInt(buffer, 0, 123);
Assert.DoesNotThrow(() =>
{
_recoveryManager.Recover();
_bufferManager.Unpin(buffer);
});
}
