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)); }