public async Task Should_Return_Request_Entries_Given_Date_Period()
{
var expectedRequestEntries = new[]
{
new RequestEntry("search-token", "imdbId", 100, DateTime.Now.AddDays(-1), "127.0.0.1")
{
Id = Guid.NewGuid().ToString()
},
new RequestEntry("search-token", "imdbId", 100, DateTime.Now, "127.0.0.1")
{
Id = Guid.NewGuid().ToString()
}
};
var notExpectedRequestEntry =
new RequestEntry("search-token", "imdbId", 100, DateTime.Now.AddDays(-2), "127.0.0.1");
var repositoryMock = new Mock <IRepository <RequestEntry> >();
repositoryMock
.Setup(x => x.FindManyAsync(
It.IsAny <Expression <Func <RequestEntry, bool> > >(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedRequestEntries);
var sut = new GetRequestEntriesByDateQueryHandler(repositoryMock.Object);
var actualResult = await sut.Handle(
new GetRequestEntriesByDateQuery(DateTime.Now.AddDays(-1), DateTime.Now), CancellationToken.None);
actualResult.Should()
.BeOfType <GetRequestEntriesSuccessResult>()
.Which.RequestEntries
.Should().Contain(expectedRequestEntries).And.NotContain(notExpectedRequestEntry);
}
private View CreateView(ViewEntry v)
{
String type = v.ItemKey.Contains("||") ? "DataSet" : "Request";
View result = new View()
{
Date = v.Date,
ItemKey = v.ItemKey,
RequestedUrl = v.RequestedUrl,
EntityType = type,
};
if (type == "DataSet")
{
EntitySet e = null;
if (_entities.TryGetValue(v.ItemKey, out e))
{
result.Name = e.EntitySetName;
result.Description = e.Description;
result.DatasetCategoryValue = e.CategoryValue;
result.DatasetContainerAlias = e.ContainerAlias;
}
}
else
{
RequestEntry r = null;
if (_requestsList.TryGetValue(v.ItemKey, out r))
{
result.Name = r.Subject;
}
}
return(result);
}
static public void AddRequest(Request item)
{
RequestDataSource reqDS = new RequestDataSource();
RequestEntry request = new RequestEntry();
Convert.CopyFields(item, request);
reqDS.AddRequest(request);
}
static public void UpdateRequest(Request item)
{
RequestDataSource reqDS = new RequestDataSource();
RequestEntry request = reqDS.GetById(item.RequestID);
Convert.CopyFields(item, request);
reqDS.UpdateRequest(request);
}
public Task Handle(MovieSearched notification, CancellationToken cancellationToken)
{
var movieRequest = new RequestEntry(
notification.SearchToken,
notification.ImdbId,
notification.ProcessingTime,
notification.Timestamp,
notification.IpAddress);
_repository.InsertOneAsync(movieRequest, cancellationToken);
return(Task.CompletedTask);
}
public void SaveRequestEntry_ValidRequestEntry_ShouldUpdateTheQueue ()
{
var sut = new TitanicMemoryIO ();
var request = new NetMQMessage ();
var id = Guid.NewGuid ();
var entry = new RequestEntry { RequestId = id, Request = request };
sut.SaveRequestEntry (entry);
sut.NumberOfRequests.Should ().Be (1, "because we just added one");
var result = sut.GetRequestEntry (id);
result.RequestId.Should ().Be (id);
}
public static Request FromTableEntry(RequestEntry req)
{
return(new Request()
{
Comments = req.Comments,
DatasetLink = req.DatasetLink,
Description = req.Description,
Links = req.Links,
PostedDate = req.PostedDate,
ReleaseDate = req.ReleaseDate,
Status = req.Status,
Subject = req.Subject,
RequestID = req.RowKey
});
}
public void SaveRequestEntry_ValidRequestEntry_ShouldUpdateTheQueue()
{
var sut = new TitanicMemoryIO();
var request = new NetMQMessage();
var id = Guid.NewGuid();
var entry = new RequestEntry {
RequestId = id, Request = request
};
sut.SaveRequestEntry(entry);
sut.NumberOfRequests.Should().Be(1, "because we just added one");
var result = sut.GetRequestEntry(id);
result.RequestId.Should().Be(id);
}
public void TitanicReply_RequestReplyUnknown_ShouldSentCorrectReply()
{
var io = new TitanicMemoryIO();
using (var reqWorker = new FakeRequestMDPWorker())
using (var repWorker = new FakeReplyMDPWorker())
using (var closeWorker = new FakeCloseMDPWorker())
using (var dispatchClient = new FakeDispatchMDPClient())
using (var sut = new TitanicBroker(io))
{
// fill queue with requests pending/processed/closed
for (var i = 0; i < 10; i++)
{
var entry = new RequestEntry
{
RequestId = Guid.NewGuid(),
Request = new NetMQMessage(),
State = i % 2 == 0 ? RequestEntry.Is_Pending : RequestEntry.Is_Processed
};
if (i % 3 == 0)
{
entry.State = RequestEntry.Is_Closed;
}
}
// setup the queue with a request
var guid = Guid.NewGuid();
// setup the fake replyWorker's request
repWorker.Request = new NetMQMessage();
repWorker.Request.Push(guid.ToString());
// start the process chain - worker & client should only run until they hit an AutoResetEvent
Task.Factory.StartNew(() => sut.Run(reqWorker, repWorker, closeWorker, dispatchClient));
// signal worker to go ahead
repWorker.waitHandle.Set();
// give everything some time to process
Thread.Sleep(_sleep_for);
// TEST COMMUNICATION
repWorker.Reply.FrameCount.Should().Be(1, "because a 1 frame message is expected. ({0})", repWorker.Reply);
repWorker.Reply.First.ConvertToString().Should().Be("Unknown");
// TEST QUEUE
io.ExistsMessage(TitanicOperation.Request, guid).Should().BeFalse();
io.ExistsMessage(TitanicOperation.Reply, guid).Should().BeFalse();
io.ExistsMessage(TitanicOperation.Close, guid).Should().BeFalse();
}
}
public void SaveNewRequest_GuidAndRequest_ShouldUpdateQueue ()
{
var sut = new TitanicMemoryIO ();
var request = new NetMQMessage ();
request.Push ("A Request");
var id = Guid.NewGuid ();
var entry = new RequestEntry { RequestId = id, Request = request };
sut.SaveRequestEntry (entry);
var result = sut.GetRequestEntry (id);
sut.NumberOfRequests.Should ().Be (1, "because we just added one");
result.RequestId.Should ().Be (id);
result.Request.ShouldBeEquivalentTo (request);
result.Position.Should ().Be (-1);
result.State.Should ().Be (RequestEntry.Is_Pending);
}
public void SaveNewRequest_GuidOnly_ShouldUpdateQueue()
{
var sut = new TitanicMemoryIO();
var request = new NetMQMessage();
var id = Guid.NewGuid();
var entry = new RequestEntry {
RequestId = id, Request = request
};
sut.SaveRequestEntry(entry);
var result = sut.GetRequestEntry(id);
result.RequestId.Should().Be(id);
result.Request.ShouldBeEquivalentTo(request);
result.Position.Should().Be(-1);
result.State.Should().Be(RequestEntry.Is_Pending);
}
public void SaveProcessedRequest_ExistingRequestNoRequestData_ShouldUpdateEntryAppropriate()
{
var sut = new TitanicMemoryIO();
var request = new NetMQMessage();
var id = Guid.NewGuid();
var entry = new RequestEntry {
RequestId = id, Request = request
};
sut.SaveRequestEntry(entry);
sut.SaveProcessedRequestEntry(entry);
var result = sut.GetRequestEntry(id);
result.RequestId.Should().Be(id);
result.Request.ShouldBeEquivalentTo(request);
result.Position.Should().Be(-1);
result.State.Should().Be(RequestEntry.Is_Processed);
}
public async Task Should_Return_Single_Request_Entry_Success_Result_When_Request_Entry_Is_Found()
{
var expectedRequestEntry = new RequestEntry("search-token", "imdbId", 100, DateTime.Now, "127.0.0.1")
{
Id = Guid.NewGuid().ToString()
};
_repositoryMock
.Setup(x => x.FindOneAsync(
It.IsAny <Expression <Func <RequestEntry, bool> > >(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedRequestEntry);
var actualResult = await _sut.Handle(new GetSingleRequestEntryQuery(Guid.NewGuid().ToString()), CancellationToken.None);
actualResult.Should()
.BeOfType <GetSingleRequestEntrySuccessResult>()
.Which.RequestEntry
.Should().BeEquivalentTo(expectedRequestEntry);
}
public async Task Should_Return_Single_Request_Entry()
{
var expectedRequestEntry = new RequestEntry("search-token", "imdbId", 100, DateTime.Now, "127.0.0.1")
{
Id = Guid.NewGuid().ToString()
};
var mediatorMock = new Mock <IMediator>();
mediatorMock
.Setup(x => x.Send(It.IsAny <GetSingleRequestEntryQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetSingleRequestEntrySuccessResult(expectedRequestEntry));
var sut = new RequestEntryController(mediatorMock.Object);
var actualResult = await sut.GetSingleRequestEntryAsync(Guid.NewGuid().ToString());
actualResult.Should()
.BeOfType <OkObjectResult>()
.Which.Value.Should()
.BeOfType <SingleRequestEntryResponse>();
}
public static RequestEntry CopyFields(Request source, RequestEntry target)
{
target.Comments = source.Comments;
target.DatasetLink = source.DatasetLink;
target.Description = source.Description;
target.Links = source.Links;
target.PostedDate = source.PostedDate;
target.ReleaseDate = source.ReleaseDate;
target.Status = source.Status;
target.Subject = source.Subject;
target.Email = source.Email;
target.Name = source.Name;
if (!String.IsNullOrEmpty(source.RequestID))
{
target.RowKey = source.RequestID;
}
return(target);
}
public void SaveNewRequest_GuidAndRequest_ShouldUpdateQueue()
{
var sut = new TitanicMemoryIO();
var request = new NetMQMessage();
request.Push("A Request");
var id = Guid.NewGuid();
var entry = new RequestEntry {
RequestId = id, Request = request
};
sut.SaveRequestEntry(entry);
var result = sut.GetRequestEntry(id);
sut.NumberOfRequests.Should().Be(1, "because we just added one");
result.RequestId.Should().Be(id);
result.Request.ShouldBeEquivalentTo(request);
result.Position.Should().Be(-1);
result.State.Should().Be(RequestEntry.Is_Pending);
}
static public Request GetRequest(string requestId)
{
RequestDataSource reqDS = new RequestDataSource();
DatasetInfoDataSource viewDs = new DatasetInfoDataSource();
RequestEntry req = reqDS.GetById(requestId);
AnalyticInfo dsInfo = viewDs.GetAnalyticSummary(Helper.GenerateRequestKey(requestId));
return(new Request()
{
DatasetLink = req.DatasetLink,
Description = req.Description,
Links = req.Links,
NegativeVotes = dsInfo.NegativeVotes,
PositiveVotes = dsInfo.PositiveVotes,
PostedDate = req.PostedDate,
ReleaseDate = req.ReleaseDate,
Status = req.Status,
Subject = req.Subject,
Views = dsInfo.views_total,
RequestID = req.RowKey
});
}
private void Report()
{
RequestEntry rp1 = new RequestEntry();
ReportDocument td = rp1;
string rptTitle = vBillNo.Trim();
td.SetParameterValue("id", rptTitle);
//if not works then
//ParameterDiscreteValue val = new ParameterDiscreteValue();
//val.Value = rptTitle;
//ParameterValues paramVals = new ParameterValues();
//paramVals.Add(val);
//td.ParameterFields["id"].CurrentValues = paramVals;
//td.DataDefinition.ParameterFields[0].ApplyCurrentValues(paramVals);
MemoryStream memoryStream = new MemoryStream();
Stream oStream = Stream.Null;
oStream = td.ExportToStream(ExportFormatType.PortableDocFormat);
CopyStream(oStream, memoryStream);
Response.Clear();
Response.Buffer = true;
Response.ContentType = "application/pdf";
try
{
Response.BinaryWrite(memoryStream.ToArray());
}
catch (Exception ex)
{
Response.Write(ex.Message);
}
Response.Flush();
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
/// <summary>
/// save a new request under a GUID and saves the request data as well
/// </summary>
/// <param name="id">the id of the request</param>
/// <param name="request">the request data to save</param>
public void SaveNewRequestEntry (Guid id, NetMQMessage request)
{
// save the request data to file first and then
SaveMessage (TitanicOperation.Request, id, request);
// create the appropriate entry and
var entry = new RequestEntry () { RequestId = id, Position = -1, State = RequestEntry.Is_Pending };
// save the request to queue
SaveRequestEntry (entry);
}
/// <summary>
/// save a new request under a GUID
/// </summary>
/// <param name="id">the id of the request</param>
public void SaveNewRequestEntry (Guid id)
{
var entry = new RequestEntry () { RequestId = id, Position = -1, State = RequestEntry.Is_Pending };
SaveRequestEntry (entry);
}
/// <summary>
/// saves a request entry to the infrastructure
/// </summary>
/// <param name="entry">the request entry to save</param>
public void SaveRequestEntry (RequestEntry entry)
{
lock (m_syncRoot)
{
using (var file = File.OpenWrite (m_titanicQueue))
{
var source = CreateFileEntry (entry.RequestId, entry.State);
var position = entry.Position == -1 ? file.Seek (0, SeekOrigin.End) : entry.Position;
WriteRequest (file, source, file.Seek (position, SeekOrigin.Begin));
}
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
// app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.Use(async(ctx, next) => {
var host = Environment.MachineName;
var addressPath = ctx.Request.Path.ToString();
var ipAddress = ctx.Connection.LocalIpAddress.MapToIPv4().ToString();
var timestamp = DateTimeOffset.Now;
var logEntry = new RequestEntry()
{
Host = host,
Ip = ipAddress,
Path = addressPath,
RequestedAt = timestamp.ToString()
};
await RecordEntry();
async Task RecordEntry()
{
var dbContext = ctx.RequestServices.GetService <LearnDockerDbContext>();
await dbContext.Requests.AddAsync(logEntry);
await dbContext.SaveChangesAsync();
}
await next();
});
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
endpoints.MapGet("/hello", async ctx => {
var dbContext = ctx.RequestServices.GetService <LearnDockerDbContext>();
var allEntries = await dbContext.Requests
.AsNoTracking()
.OrderByDescending(x => x.Id)
.ToListAsync();
var jsonContent = System.Text.Json.JsonSerializer.Serialize(allEntries);
await ctx.Response.WriteAsync(jsonContent, Encoding.UTF8);
});
});
}
public void TitanicReply_RequestReplyUnknown_ShouldSentCorrectReply ()
{
var io = new TitanicMemoryIO ();
using (var reqWorker = new FakeRequestMDPWorker ())
using (var repWorker = new FakeReplyMDPWorker ())
using (var closeWorker = new FakeCloseMDPWorker ())
using (var dispatchClient = new FakeDispatchMDPClient ())
using (var sut = new TitanicBroker (io))
{
// fill queue with requests pending/processed/closed
for (var i = 0; i < 10; i++)
{
var entry = new RequestEntry
{
RequestId = Guid.NewGuid (),
Request = new NetMQMessage (),
State = i % 2 == 0 ? RequestEntry.Is_Pending : RequestEntry.Is_Processed
};
if (i % 3 == 0)
entry.State = RequestEntry.Is_Closed;
}
// setup the queue with a request
var guid = Guid.NewGuid ();
// setup the fake replyWorker's request
repWorker.Request = new NetMQMessage ();
repWorker.Request.Push (guid.ToString ());
// start the process chain - worker & client should only run until they hit an AutoResetEvent
Task.Factory.StartNew (() => sut.Run (reqWorker, repWorker, closeWorker, dispatchClient));
// signal worker to go ahead
repWorker.waitHandle.Set ();
// give everything some time to process
Thread.Sleep (_sleep_for);
// TEST COMMUNICATION
repWorker.Reply.FrameCount.Should ().Be (1, "because a 1 frame message is expected. ({0})", repWorker.Reply);
repWorker.Reply.First.ConvertToString ().Should ().Be ("Unknown");
// TEST QUEUE
io.ExistsMessage (TitanicOperation.Request, guid).Should ().BeFalse ();
io.ExistsMessage (TitanicOperation.Reply, guid).Should ().BeFalse ();
io.ExistsMessage (TitanicOperation.Close, guid).Should ().BeFalse ();
}
}
// .......................................................................
/// <summary> Add an association of:<br>
/// ID -> <tt>RspCollector</tt>
/// </summary>
private void addEntry(long id, RequestEntry entry,ArrayList dests)
{
System.Int64 id_obj = (long) id;
req_lock.AcquireWriterLock(Timeout.Infinite);
try
{
//we check whether all the destination are still alive or not
//if view has changed and one or more destination members has left
//then we should declare them suspect.
if (dests != null)
{
foreach (Address dest in dests)
{
if (!members.Contains(dest) && entry.coll != null)
entry.coll.suspect(dest);
}
}
if (!requests.ContainsKey(id_obj))
requests[id_obj] = entry;
}
finally
{
req_lock.ReleaseWriterLock();
}
}
public void SaveNewRequest_GuidOnly_ShouldUpdateQueue ()
{
var sut = new TitanicMemoryIO ();
var request = new NetMQMessage ();
var id = Guid.NewGuid ();
var entry = new RequestEntry { RequestId = id, Request = request };
sut.SaveRequestEntry (entry);
var result = sut.GetRequestEntry (id);
result.RequestId.Should ().Be (id);
result.Request.ShouldBeEquivalentTo (request);
result.Position.Should ().Be (-1);
result.State.Should ().Be (RequestEntry.Is_Pending);
}
public GetSingleRequestEntrySuccessResult(RequestEntry requestEntry)
{
RequestEntry = requestEntry;
}
/// <summary>
/// save a NetMQ message under a GUID
/// </summary>
/// <param name="op">defines whether it is a REQUEST or REPLY message</param>
/// <param name="id">the guid of the message to save</param>
/// <param name="message">the message to save</param>
/// <exception cref="OverflowException">max. number of elements exceeded, <see cref="F:System.Int32.MaxValue" />.</exception>
public bool SaveMessage(TitanicOperation op, Guid id, NetMQMessage message)
{
var entry = new RequestEntry
{
RequestId = id,
Request = message,
State = GetStateFromOperation (op)
};
m_titanicQueue.AddOrUpdate (id, entry, (i, oldValue) => entry);
return true;
}
/// <summary>
/// save a processed request entry and mark it as such
/// </summary>
/// <param name="entry">the entry to save</param>
/// <exception cref="OverflowException">max. number of elements exceeded, <see cref="F:System.Int32.MaxValue" />.</exception>
public void SaveProcessedRequestEntry(RequestEntry entry)
{
entry.State = RequestEntry.Is_Processed;
SaveRequestEntry (entry);
}
/// <summary>
/// save a new request under a GUID and the request data itself as well
/// </summary>
/// <param name="id">the id of the request</param>
/// <param name="request">the request to save</param>
/// <exception cref="OverflowException">max. number of elements exceeded, <see cref="F:System.Int32.MaxValue" />.</exception>
public void SaveNewRequestEntry(Guid id, NetMQMessage request)
{
var entry = new RequestEntry { RequestId = id, Position = -1, State = RequestEntry.Is_Pending, Request = request };
SaveRequestEntry (entry);
}
public void SaveProcessedRequest_ExistingRequestWithRequestData_ShouldUpdateEntryAppropriate ()
{
var sut = new TitanicMemoryIO ();
var request = new NetMQMessage ();
request.Push ("Processed Request Data");
var id = Guid.NewGuid ();
var entry = new RequestEntry { RequestId = id, Request = request };
sut.SaveRequestEntry (entry);
sut.SaveProcessedRequestEntry (entry);
var result = sut.GetRequestEntry (id);
result.RequestId.Should ().Be (id);
result.Request.ShouldBeEquivalentTo (request);
result.Position.Should ().Be (-1);
result.State.Should ().Be (RequestEntry.Is_Processed);
}
/// <summary>
/// saves a request entry to the infrastructure
/// </summary>
/// <param name="entry">the request entry to save</param>
/// <exception cref="OverflowException">max. number of elements exceeded, <see cref="F:System.Int32.MaxValue" />.</exception>
/// <exception cref="ArgumentNullException"><paramref name="entry.RequestId" /> is a 'null' reference.</exception>
public void SaveRequestEntry(RequestEntry entry)
{
if (ReferenceEquals (entry, null))
throw new ArgumentNullException ("entry", "The RequestEntry to save must not be null!");
m_titanicQueue.AddOrUpdate (entry.RequestId, entry, (id, e) => entry);
}
public Task AppendAsync(RequestEntry entry)
{
Console.WriteLine(JsonConvert.SerializeObject(entry, Formatting.Indented));
return(Task.FromResult(0));
}
