private void sendControlRequest(LightstreamerRequest request, RequestListener reqListener, RequestTutor tutor) { ongoingRequest = new PendingRequest(request, reqListener, tutor); wsTransport.sendRequest(protocol, request, new ListenerWrapperAnonymousInnerClass(this, reqListener) , null, null, 0, 0); }
public IActionResult RequestAccess(int id) { var user = _userManager.GetUserAsync(User).Result; var wishList = WishListRepository.Find(id); if (wishList.CreatorName == user.Email) { return(BadRequest("not possible to request access to own wishlist")); } if (wishList.Subscribers.Any(sub => sub.UserId == user?.Id)) { return(BadRequest("already subscribed to wishlist")); } if (wishList.PendingRequests.Any(pi => pi.UserId == user?.Id)) { return(BadRequest("access already requested")); } var request = new PendingRequest { User = user, WishList = wishList }; wishList.AddRequest(request); WishListRepository.Update(wishList); return(Ok()); }
internal static void TransferToImage(Image image, Uri uri) { SetUriSource(image, null); PendingRequest pr = new PendingRequest(image, uri); PriorityQueue.AddWorkItem(() => { PendingRequest ppr = pr; ProcessTransfer(ppr); }); // The original implementation that I created would simply flip the // image.Source = new BitmapImage(uri) bit. I've decided not to do // that in this newer version where I manage my own set of bytes[]. if (!_recentQuick.ContainsKey(uri)) { if (_recent.Count == RecentLimit) { Uri byebyebye = _recent.Dequeue(); _recentQuick.Remove(byebyebye); } _recentQuick.Add(uri, true); _recent.Enqueue(uri); } }
public async Task <Response> CommitRequest(FlatBufferBuilder fbb, RequestData requestDataType, int requestDataOffset) { PendingRequest request = new PendingRequest(); request.requestId = nextRequestId++; request.responseTask = new TaskCompletionSource <Response>(); pendingRequests.TryAdd(request.requestId, request); int requestOffset = Request.CreateRequest(fbb, request.requestId, requestDataType, requestDataOffset); fbb.Finish(requestOffset); // Update the placeholder size. int bufferOffset = fbb.DataBuffer.Position; int bufferLength = fbb.DataBuffer.Length - fbb.DataBuffer.Position; fbb.DataBuffer.PutInt(bufferOffset - 4, bufferLength); // Send request. await socket.SendTaskAsync(fbb.DataBuffer.Data, bufferOffset - 4, bufferLength + 4, SocketFlags.None); // Await response. var response = await request.responseTask.Task; return(response); }
public IActionResult PostAddFriend([FromBody] Friend f) { if (!ModelState.IsValid) { return(BadRequest("Model is not valid.")); } if (vinylContext.Friends.SingleOrDefault(e => (e.User1Ref == f.User1Ref) && (e.User2Ref == f.User2Ref)) != null) { return(Conflict("Alredy exists.")); } vinylContext.Friends.Add(f); Friend reverse = new Friend { User1Ref = f.User2Ref, User2Ref = f.User1Ref }; PendingRequest pr = new PendingRequest { UserSentRef = f.User1Ref, UserReceavedRef = f.User2Ref }; vinylContext.PendingRequests.Remove(pr); vinylContext.Friends.Add(reverse); vinylContext.SaveChanges(); return(Ok()); }
public Promise <MultiPlayerMessage> SendRequest(MultiPlayerMessage message, TimeSpan?timeout = null) { try { message.Sender = ClientId; message.RequestId = Guid.NewGuid().ToString(); var pendingRequest = new PendingRequest() { Id = message.RequestId, ResponseDeferred = Deferred <MultiPlayerMessage> .Create(), }; if (timeout.HasValue) { pendingRequest.Timeout = timeout.Value; } lock (pendingRequests) { pendingRequests.Add(message.RequestId, pendingRequest); } SendMessage(message); return(pendingRequest.ResponseDeferred.Promise); } catch (Exception ex) { var d = Deferred <MultiPlayerMessage> .Create(); d.Reject(ex); return(d.Promise); } }
void IMessagingEvents.GetEvents(string msg, object trigger, Queue <Event> buffer) { var match = regex.Match(msg); if (match.Success) { MessageDirection dir = match.Groups["dir"].Value == "Incoming" ? MessageDirection.Incoming : MessageDirection.Outgoing; MessageType type = match.Groups["type"].Value == "request" ? MessageType.Request : MessageType.Response; string requestId = match.Groups["id"].Value; string requestName = match.Groups["name"].Value; string rest = match.Groups["rest"].Value; string remoteSideId = DetectRemoteId(requestName, rest); if (type == MessageType.Request) { requests[requestId] = new PendingRequest() { RemoteSideId = remoteSideId }; } else if (requests.TryGetValue(requestId, out var pendingRequest)) { if (remoteSideId == null) { remoteSideId = pendingRequest.RemoteSideId; } requests.Remove(requestId); } string displayName = MakeDisplayName(requestName, rest); buffer.Enqueue(new NetworkMessageEvent( trigger, displayName, dir, type, "", requestId, null, remoteSideId, GetStatus(rest)) .SetTags(GetTags(requestName))); } }
/// <summary> /// Resolve a whole bunch of IDs. /// </summary> /// <param name="AgentIds"></param> /// <returns></returns> public async Task <IEnumerable <MappedIdentity> > MapAgents(IEnumerable <UUID> AgentIds) { var newRequests = new List <Task <MappedIdentity> >(); lock (agentCacheLock) { foreach (var i in AgentIds) { MappedIdentity found; if (AgentsByUuid.TryGetValue(i, out found)) { newRequests.Add(Task.FromResult(found)); } else { var req = new PendingRequest(i); agentRequests.Add(req); newRequests.Add(req.TaskSource.Task); } } } client.Avatars.RequestAvatarNames(AgentIds.ToList()); return(await Task.WhenAll(newRequests)); }
public Task <MappedIdentity> MapAgent(UUID AgentId, string SlName = null) { MappedIdentity identity; lock (agentCacheLock) { if (AgentsByUuid.TryGetValue(AgentId, out identity)) { return(Task.FromResult(identity)); } } if (SlName != null) { return(Task.FromResult(MakeAgentIdentity(AgentId, SlName))); } PendingRequest request; lock (agentRequests) { request = new PendingRequest(AgentId); agentRequests.Add(request); } client.Avatars.RequestAvatarName(AgentId); return(request.TaskSource.Task); }
public IActionResult GetPendingRequests(string user) { try { PendingRequest pending = _repo.GetPendingRequests(user); if (pending.friend_requests == null) { return(BadRequest(new AppErrorResponse { status = "failure", reason = "User does not exist" })); } else if (pending.friend_requests.Count() == 0) { return(NotFound(new AppErrorResponse { status = "failure", reason = "User does not have any requests" })); } else { return(Ok(pending)); } } catch (Exception ex) { _logger.LogError(ex, ex.Message, ex.InnerException); return(BadRequest(new AppErrorResponse())); } }
public PendingRequest GetPendingRequests(string user) { PendingRequest pending = new PendingRequest(); pending.friend_requests = new List <string>(); using (var factory = new FriendSuggestorContextFactory()) { // Get a context using (var context = factory.CreateContext()) { User u = context.Users.Where(x => x.UserName == user).FirstOrDefault(); if (u != null) { pending.friend_requests = (from l in context.FriendsLists join r in context.Users on l.UserF equals r.UserId where l.UserSF == u.UserId && l.IsFriend == false select r.UserName).ToList(); } else { pending.friend_requests = null; } } } return(pending); }
public Task <MultiPlayerMessage> SendRequest(MultiPlayerMessage message, TimeSpan?timeout = null) { try { message.Sender = ClientId; message.RequestId = Guid.NewGuid().ToString(); var pendingRequest = new PendingRequest() { Id = message.RequestId, ResponseDeferred = new TaskCompletionSource <MultiPlayerMessage>(), }; if (timeout.HasValue) { pendingRequest.Timeout = timeout.Value; } lock (pendingRequests) { pendingRequests.Add(message.RequestId, pendingRequest); } SendMessage(message); return(pendingRequest.ResponseDeferred.Task); } catch (Exception ex) { var d = new TaskCompletionSource <MultiPlayerMessage>(); d.SetException(ex); return(d.Task); } }
private NetStatus OnRequestTimeout(Dispatcher.CallbackArgs args) { DateTime now = ((TimeoutArgument !)args).now; int i = 0; while (i != pendingRequests.Count) { PendingRequest request = (PendingRequest !)pendingRequests[i]; if (request.expiry < now) { DebugPrint("Expiring request"); request.callback(request.address, EthernetAddress.Zero, request.cookie); pendingRequests.RemoveAt(i); continue; } i++; } if (pendingRequests.Count > 0) { DateTime nextPoll = now + PollPeriod; Core.Instance().TheDispatcher.AddCallback( new Dispatcher.Callback(OnRequestTimeout), new TimeoutArgument(nextPoll), (ulong)nextPoll.Ticks ); } return(NetStatus.Code.RT_OK); }
private void ProcessPendingRequests() { PendingRequest rq = null; while (m_pendingqueue.DequeueUnblocking(out rq)) { HandleAnswer(rq); } }
public IHttpActionResult InsertRequest(PendingRequest pendingRequest) { pendingRequest.Date = DateTime.Now; pendingRequest.Pending = true; pendingRequestRepository.Create(pendingRequest); return(Ok()); }
public PendingRequestResource(PendingRequest pendingRequest) { this.BookId = pendingRequest.BookId; this.Date = pendingRequest.Date; this.User = pendingRequest.User; this.Id = pendingRequest.Id; this.Date = DateTime.Now; }
private static string GetFillRequestMessage(PendingRequest p) { var fillsRequest = new CBPRO.FillsRequest { order_id = p.EntityId }; return(JsonConvert.SerializeObject(fillsRequest).ToString()); }
private static async Task <string> MakeFetchRequest(string url) { Debug.WriteLine("making fetch request, url: [" + url + "]"); var token = NewToken; var req = _pendingRequests[token] = new PendingRequest(token, url); TriggerServerEvent("__sthv__internal:fetchRequest", token, url); return(await req.Task); }
void ISocketEventListener.OnClose(BaseSocket sock) { m_sock = null; m_current = null; lock (m_lock) { Monitor.Pulse(m_lock); } }
private static void Enrich(PendingRequest request) { if (request == null) { return; } request.Resource = DefaultResourceSetRepository.Resources.FirstOrDefault(r => r.Id == request.ResourceId); }
private IObservable <IView> PresentLater(object input, Options options) { // Complete any pending request without fulling it (we only allow a single pending request) _pendingRequest?.Subject.OnCompleted(); // Prepare new pending request _pendingRequest = new PendingRequest(input, options); return(_pendingRequest.Subject); }
private Task <NvimResponse> SendAndReceive(NvimRequest request) { request.MessageId = _messageIdCounter++; var pendingRequest = new PendingRequest(); _pendingRequests[request.MessageId] = pendingRequest; _messageQueue.Add(request); return(pendingRequest.GetResponse()); }
void Server_OnReceiveLine(System.Net.Sockets.Socket socket, string line) { TCPServer.ClientUser client = Server.Clients[socket.Handle]; string[] splitChar = { " " }; string[] args = line.Split(splitChar, StringSplitOptions.RemoveEmptyEntries); if (client.LinesReceived == 0) { string method = args[0].ToLower(); if (args.Length < 2 || (method != "get" && method != "post")) { //FIXME- add event Server.SendLine(socket, (int)HTTPErrorCode.MethodNotAllowed + " method not allowed"); Server.KillUser(socket.Handle); } else { PendingRequest request = new PendingRequest(); request.Status = ClientStatus.Requesting; request.Method = args[0]; char[] splitPath = { '?' }; string[] path = args[1].Split(splitPath); request.Path = path[0]; if (path.Length > 0) { char[] splitVars = { '&' }; char[] splitVal = { '=' }; string[] vars = path[1].Split(splitVars); foreach (string v in vars) { string[] keyval = v.Split(splitVal); if (keyval.Length > 0) request.GetVars.Add(keyval[0], keyval[1]); else request.GetVars.Add(keyval[0], ""); } } PendingRequests.Add(socket.Handle, request); } } else if (PendingRequests.ContainsKey(socket.Handle)) { PendingRequest request = PendingRequests[socket.Handle]; if (args.Length == 0) { request.Status = ClientStatus.Complete; OnHTTPRequest(request.Method, request.Path, request.Host, request.UserAgent, request.ContentType, request.ContentLength, request.GetVars); } else if (args.Length > 1) { string param = args[0].ToLower(); if (param == "host:") request.Host = args[1]; else if (param == "user-agent:") request.UserAgent = args[1]; else if (param == "content-type:") request.ContentType = args[1]; else if (param == "content-length:") int.TryParse(args[1], out request.ContentLength); } PendingRequests[socket.Handle] = request; } }
/// <summary> /// Close the socket after all pending requests are completed. /// </summary> public void EnqueueClose() { PendingRequest req = new PendingRequest(null, null, null, 0, 0, null); lock (m_queue) { m_queue.AddLast(req); Monitor.Pulse(m_queue); } }
private void HandleAnswer(PendingRequest rq) { byte[] ln = m_connection.ReadLine(); if (ln == null) { SetState(State.Terminated, "server closed connection"); return; } else if (Protocol.IsCommand("OK", ln)) { m_answerCallback(new Answer { msgtype = Answer.MsgType.Result, id = rq.id, number = rq.number, obj = null }); } else if (Protocol.IsCommand("ERR", ln)) { m_answerCallback(new Answer { msgtype = Answer.MsgType.Failure, id = rq.id, number = rq.number, obj = Protocol.CommandArg("ERR", ln) }); } else if (Protocol.IsCommand("BAD", ln)) { SetState(State.Terminated, "protocol error"); m_answerCallback(new Answer { msgtype = Answer.MsgType.Error, id = rq.id, number = rq.number, obj = "protocol error" }); return; } else if (Protocol.IsCommand("ANSWER", ln)) { byte[] msg = m_connection.ReadContent(); if (msg == null) { SetState(State.Terminated, "server closed connection"); m_answerCallback(new Answer { msgtype = Answer.MsgType.Error, id = rq.id, number = rq.number, obj = "server closed connection" }); return; } ln = m_connection.ReadLine(); if (msg == null) { SetState(State.Terminated, "server closed connection"); m_answerCallback(new Answer { msgtype = Answer.MsgType.Error, id = rq.id, number = rq.number, obj = "server closed connection" }); return; } else if (Protocol.IsCommand("OK", ln)) { object answerobj = m_serializer.getResult(msg, rq.answertype); m_answerCallback(new Answer { msgtype = Answer.MsgType.Result, id = rq.id, number = rq.number, obj = answerobj }); } else if (Protocol.IsCommand("ERR", ln)) { m_answerCallback(new Answer { msgtype = Answer.MsgType.Failure, id = rq.id, number = rq.number, obj = Protocol.CommandArg("ERR", ln) }); } else if (Protocol.IsCommand("BAD", ln)) { SetState(State.Terminated, "protocol error"); m_answerCallback(new Answer { msgtype = Answer.MsgType.Error, id = rq.id, number = rq.number, obj = "protocol error" }); return; } } }
public async Task <string> DownloadString(string url) { var args = new Dictionary <string, object> { { "url", url } }; var argsJson = JsonConvert.SerializeObject(args); var id = API.PerformHttpRequestInternal(argsJson, argsJson.Length); var req = _pendingRequests[id] = new PendingRequest(id); return(await req.Task); }
private static void ProcessTransfer(PendingRequest pendingRequest) { if (pendingRequest == null || pendingRequest.Uri == null) { return; } try { if (pendingRequest.Uri.IsAbsoluteUri) { _iso.GetItem(pendingRequest.Uri, (img, exc, stat) => { if (stat == IsoStoreCache.ItemCacheStatus.Hit) { var ms = new MemoryStream(img); var pc = new PendingCompletion(pendingRequest.Image, pendingRequest.Uri, ms); PriorityQueue.AddUiWorkItem(() => { HandleCompletion(pc); }); } else { // Download from network var webRequest = HttpWebRequest.CreateHttp(pendingRequest.Uri); webRequest.AllowReadStreamBuffering = true; // Don't want to block this thread or the UI thread on network access webRequest.BeginGetResponse(HandleGetResponseResult, new ResponseState(webRequest, pendingRequest.Image, pendingRequest.Uri)); } }); } else { // Load from application (must have "Build Action"="Content") var originalUriString = pendingRequest.Uri.OriginalString; // Trim leading '/' to avoid problems var resourceStreamUri = originalUriString.StartsWith("/", StringComparison.Ordinal) ? new Uri(originalUriString.TrimStart('/'), UriKind.Relative) : pendingRequest.Uri; // Enqueue resource stream for completion var streamResourceInfo = Application.GetResourceStream(resourceStreamUri); if (null != streamResourceInfo) { var pc = new PendingCompletion(pendingRequest.Image, pendingRequest.Uri, streamResourceInfo.Stream); PriorityQueue.AddUiWorkItem(() => { HandleCompletion(pc); }); } } } catch (NullReferenceException) { // Trying to address user-found bugs here. } }
public Task Start(Action <NanoListenerTransaction> transactionCallback, Action <NanoResult> errorCallback) { return(Task.Run( async() => { while (true) { try { await Task.Delay(this.Interval); PendingRequest pendingRequest = new PendingRequest(); pendingRequest.Account = this.Account; pendingRequest.Count = this.Count.ToString(); NanoResult <PendingResponse> pendingResult = await this.Nano.SendAsync <PendingResponse>(pendingRequest); if (pendingResult.IsError()) { errorCallback?.Invoke(pendingResult); } BlocksInfoRequest blocksInfoRequest = new BlocksInfoRequest(); blocksInfoRequest.Hashes = pendingResult.Response.Blocks; NanoResult <BlocksInfoResponse> blocksInfoResult = await this.Nano.SendAsync <BlocksInfoResponse>(blocksInfoRequest); if (blocksInfoResult.IsError()) { errorCallback?.Invoke(blocksInfoResult); } if (blocksInfoResult.Response.Blocks != null) { foreach ((string key, BlockInfo block) in blocksInfoResult.Response.Blocks) { lock (this.knownHashes) { if (this.knownHashes.Contains(key)) { continue; } if (block.Confirmed == "true") { this.knownHashes.Add(key); transactionCallback?.Invoke(new NanoListenerTransaction(key, block)); } } } } } catch { // Do Nothing (For Now) } } })); }
public async Task AddPendingRequest(string id) { var model = new PendingRequest() { CustomerId = id, IssusOpend = true }; this.AuroraLineDbContext.PendingRequests.Add(model); await this.AuroraLineDbContext.SaveChangesAsync(); }
public async Task <UserResponse> AcceptRequest(string username, string friendUsername) { var user = await context.RegisteredUsers .Include(i => i.MyFriends) .Include(i => i.MyPendingRequests) .FirstOrDefaultAsync(i => i.Username.ToLower().Equals(username.ToLower())); if (user == null) { return(new UserResponse("User with username: "******" does not exist.")); } var friend = await context.RegisteredUsers .Include(i => i.MyFriends) .FirstOrDefaultAsync(i => i.Username.ToLower().Equals(friendUsername.ToLower())); if (friend == null) { return(new UserResponse("User with username: "******" hasn't sent friend request.")); } PendingRequest temp = null; foreach (var a in user.MyPendingRequests) { if (a.RequestSenderUsername.ToLower() == friendUsername.ToLower()) { var friend1 = new Friend(); var friend2 = new Friend(); friend1.FriendLastName = user.LastName; friend1.FriendName = user.Name; friend1.FriendUsername = user.Username; friend2.FriendUsername = friend.Username; friend2.FriendName = friend.Name; friend2.FriendLastName = friend.LastName; user.MyFriends.Add(friend2); friend.MyFriends.Add(friend1); temp = a; break; } } if (temp != null) { user.MyPendingRequests.Remove(temp); return(new UserResponse(user)); } else { return(new UserResponse("No friend request found.")); } }
public Task <bool> Update(PendingRequest pendingRequest) { var record = _pendingRequestLst.FirstOrDefault(p => p.Id == pendingRequest.Id); if (record == null) { return(Task.FromResult(false)); } record.IsConfirmed = pendingRequest.IsConfirmed; return(Task.FromResult(true)); }
public ResponseMessage QueueAndWait(RequestMessage request) { var pending = new PendingRequest(request, log); lock (sync) { queue.Add(pending); inProgress.Add(request.Id, pending); hasItems.Set(); } pending.WaitUntilComplete(); lock (sync) { inProgress.Remove(request.Id); } return pending.Response; }
public Task<MappedIdentity> MapAgent(string IrcNick) { MappedIdentity identity; lock (agentCacheLock) { if (AgentsByIrcNick.TryGetValue(IrcNick, out identity)) { return Task.FromResult(identity); } } string slName = IrcNick.Replace('.', ' '); PendingRequest request; lock (agentRequests) { request = new PendingRequest(slName); agentRequests.Add(request); } client.Avatars.RequestAvatarNameSearch(slName, UUID.Random()); return request.TaskSource.Task; }
/// <summary> /// Creates a new pending request for the current session. /// </summary> /// <param name="landingUrl">The landing page of the SignResponse</param> /// <param name="language">The language of the e-contract.be pages, <c>null</c> for the default language</param> /// <param name="properties">Additional properties (location, role, visibility info, ...) for the signature request</param> /// <param name="authorization">The optional authorization that the signer must match too to be authorized</param> /// <returns>The base64 encoded PendingRequest, to be used as value for the "PendingRequest"-input</returns> public string GeneratePendingRequest(Uri landingUrl, string language, SignatureRequestProperties properties, Authorization authorization) { if (landingUrl == null) throw new ArgumentNullException("landingUrl"); //Prepare browser post message (to return) var pendingRequest = new PendingRequest(); pendingRequest.OptionalInputs = new OptionalInputs(); pendingRequest.OptionalInputs.AdditionalProfile = "urn:oasis:names:tc:dss:1.0:profiles:asynchronousprocessing"; pendingRequest.OptionalInputs.ResponseID = this.ServerId; pendingRequest.OptionalInputs.MessageID = new AttributedURIType(); pendingRequest.OptionalInputs.MessageID.Value = this.ClientId; pendingRequest.OptionalInputs.Timestamp = new TimestampType(); pendingRequest.OptionalInputs.Timestamp.Created = new AttributedDateTime(); pendingRequest.OptionalInputs.Timestamp.Created.Value = DateTime.UtcNow; pendingRequest.OptionalInputs.Timestamp.Expires = new AttributedDateTime(); pendingRequest.OptionalInputs.Timestamp.Expires.Value = DateTime.UtcNow.AddMinutes(10); pendingRequest.OptionalInputs.ReplyTo = new EndpointReferenceType(); pendingRequest.OptionalInputs.ReplyTo.Address = new AttributedURIType(); pendingRequest.OptionalInputs.ReplyTo.Address.Value = landingUrl.AbsoluteUri; pendingRequest.OptionalInputs.ReturnSignerIdentity = new ReturnSignerIdentity(); pendingRequest.OptionalInputs.Language = string.IsNullOrEmpty(language) ? null : language; if (properties != null && (!string.IsNullOrEmpty(properties.SignerRole) || !string.IsNullOrEmpty(properties.SignatureProductionPlace) || properties.VisibleSignature != null)) { var items = new List<VisibleSignatureItemType>(); PixelVisibleSignaturePositionType pixelVisibleSignaturePosition = null; if (!string.IsNullOrEmpty(properties.SignerRole)) { var stringItem = new ItemValueStringType(); stringItem.ItemValue = properties.SignerRole; var item = new VisibleSignatureItemType(); item.ItemName = ItemNameEnum.SignatureReason; item.ItemValue = stringItem; items.Add(item); } if (!string.IsNullOrEmpty(properties.SignatureProductionPlace)) { var stringItem = new ItemValueStringType(); stringItem.ItemValue = properties.SignatureProductionPlace; var item = new VisibleSignatureItemType(); item.ItemName = ItemNameEnum.SignatureProductionPlace; item.ItemValue = stringItem; items.Add(item); } if (properties.VisibleSignature != null) { var photoProp = properties.VisibleSignature as ImageVisibleSignature; if (photoProp != null) { var uriItem = new ItemValueURIType(); uriItem.ItemValue = photoProp.ValueUri; var item = new VisibleSignatureItemType(); item.ItemName = ItemNameEnum.SignerImage; item.ItemValue = uriItem; items.Add(item); var customText = photoProp.CustomText; if (!string.IsNullOrEmpty(customText)) { var customTextItem = new VisibleSignatureItemType(); customTextItem.ItemName = ItemNameEnum.CustomText; var customTextItemValue = new ItemValueStringType(); customTextItemValue.ItemValue = customText; customTextItem.ItemValue = customTextItemValue; items.Add(customTextItem); } } else { throw new ArgumentException("The type of VisibleSignatureProperties (field of SignatureRequestProperties) is unsupported", "properties"); } pixelVisibleSignaturePosition = new PixelVisibleSignaturePositionType(); pixelVisibleSignaturePosition.PageNumber = properties.VisibleSignature.Page; pixelVisibleSignaturePosition.x = properties.VisibleSignature.X; pixelVisibleSignaturePosition.y = properties.VisibleSignature.Y; } pendingRequest.OptionalInputs.VisibleSignatureConfiguration = new VisibleSignatureConfigurationType(); pendingRequest.OptionalInputs.VisibleSignatureConfiguration.VisibleSignaturePolicy = VisibleSignaturePolicyType.DocumentSubmissionPolicy; pendingRequest.OptionalInputs.VisibleSignatureConfiguration.VisibleSignatureItemsConfiguration = new VisibleSignatureItemsConfigurationType(); pendingRequest.OptionalInputs.VisibleSignatureConfiguration.VisibleSignatureItemsConfiguration.VisibleSignatureItem = items.ToArray<VisibleSignatureItemType>(); pendingRequest.OptionalInputs.VisibleSignatureConfiguration.VisibleSignaturePosition = pixelVisibleSignaturePosition; } if (authorization != null) { pendingRequest.OptionalInputs.Policy = authorization.getPolicy(); } //Prepare Sign var pendingRequestXml = new XmlDocument(); pendingRequestXml.PreserveWhitespace = true; if (null == requestSerializer) { requestSerializer = new XmlSerializer(typeof(PendingRequest), "urn:oasis:names:tc:dss:1.0:profiles:asynchronousprocessing:1.0"); } using (var pendingRequestWriter = pendingRequestXml.CreateNavigator().AppendChild()) { requestSerializer.Serialize(pendingRequestWriter, pendingRequest); } var signedXml = new SignedXml(pendingRequestXml); signedXml.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigExcC14NTransformUrl; signedXml.SignedInfo.SignatureMethod = SignedXml.XmlDsigHMACSHA1Url; var docRef = new Reference(""); docRef.DigestMethod = "http://www.w3.org/2000/09/xmldsig#sha1"; docRef.AddTransform(new XmlDsigEnvelopedSignatureTransform()); docRef.AddTransform(new XmlDsigExcC14NTransform()); signedXml.AddReference(docRef); //Add Key Info var keyRefXml = new XmlDocument(); keyRefXml.PreserveWhitespace = true; if (null == tRefSerializer) { tRefSerializer = new XmlSerializer(typeof(SecurityTokenReferenceType), null, new Type[0], new XmlRootAttribute("SecurityTokenReference"), "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"); } using (var keyRefXmlWriter = keyRefXml.CreateNavigator().AppendChild()) { tRefSerializer.Serialize(keyRefXmlWriter, this.KeyReference); } signedXml.KeyInfo = new KeyInfo(); signedXml.KeyInfo.AddClause(new KeyInfoNode(keyRefXml.DocumentElement)); //Compute signature signedXml.ComputeSignature(new HMACSHA1(this.KeyValue)); //Append signature to document var nsmgr = new XmlNamespaceManager(pendingRequestXml.NameTable); nsmgr.AddNamespace("async", "urn:oasis:names:tc:dss:1.0:profiles:asynchronousprocessing:1.0"); nsmgr.AddNamespace("dss", "urn:oasis:names:tc:dss:1.0:core:schema"); pendingRequestXml.SelectSingleNode("/async:PendingRequest/dss:OptionalInputs", nsmgr).AppendChild(signedXml.GetXml()); //Serialize and encode var stream = new MemoryStream(); pendingRequestXml.Save(stream); return Convert.ToBase64String(stream.ToArray()); }
public async Task<Response> CommitRequest(FlatBufferBuilder fbb, RequestData requestDataType, int requestDataOffset) { PendingRequest request = new PendingRequest(); request.requestId = nextRequestId++; request.responseTask = new TaskCompletionSource<Response>(); pendingRequests.TryAdd(request.requestId, request); int requestOffset = Request.CreateRequest(fbb, request.requestId, requestDataType, requestDataOffset); fbb.Finish(requestOffset); // Update the placeholder size. int bufferOffset = fbb.DataBuffer.Position; int bufferLength = fbb.DataBuffer.Length - fbb.DataBuffer.Position; fbb.DataBuffer.PutInt(bufferOffset - 4, bufferLength); // Send request. await socket.SendTaskAsync(fbb.DataBuffer.Data, bufferOffset - 4, bufferLength + 4, SocketFlags.None); // Await response. var response = await request.responseTask.Task; return response; }
private void Done() { m_state = ParseState.START; m_current = null; Debug.WriteLine("HTTP Socket " + m_name + " done"); }
/// <summary> /// Execute an HTTP request. /// </summary> /// <param name="method">The HTTP method verb. E.g. "GET", "POST", etc.</param> /// <param name="URL">The URL to request. MUST be for the same host as the first request.</param> /// <param name="body">Any data to post with the request</param> /// <param name="offset">The offset into body from which to start</param> /// <param name="len">The number of bytes to read from body, starting at offset</param> /// <param name="contentType">The MIME type of the supplied body</param> public void Execute(string method, Uri URL, byte[] body, int offset, int len, string contentType) { Debug.Assert(!this.IsPending); PendingRequest req = new PendingRequest(method, URL, body, offset, len, contentType); if (m_host == null) m_host = req.URI.Host; else if (m_host != req.URI.Host) throw new InvalidOperationException("All requests must got to same host: " + m_host); // connect if not yet connected if (req.Method != null) { lock (m_lock) { if (!Connected) { Connect(req.URI); Monitor.Wait(m_lock, (int)(m_connectRetrySec * 1000)); if (!m_keepRunning) return; Debug.Assert(Connected); Debug.Assert(!IsPending); } } } Send(req); }
/// <summary> /// Resolve a whole bunch of IDs. /// </summary> /// <param name="AgentIds"></param> /// <returns></returns> public async Task<IEnumerable<MappedIdentity>> MapAgents(IEnumerable<UUID> AgentIds) { var newRequests = new List<Task<MappedIdentity>>(); lock (agentCacheLock) { foreach (var i in AgentIds) { MappedIdentity found; if (AgentsByUuid.TryGetValue(i, out found)) { newRequests.Add(Task.FromResult(found)); } else { var req = new PendingRequest(i); agentRequests.Add(req); newRequests.Add(req.TaskSource.Task); } } } client.Avatars.RequestAvatarNames(AgentIds.ToList()); return await Task.WhenAll(newRequests); }
void ISocketEventListener.OnConnect(BaseSocket sock) { m_errorCount = 0; m_listener.OnConnect(null); lock (m_queue) { // push back. if (m_current != null) { m_queue.AddFirst(m_current); m_current = null; } Monitor.Pulse(m_queue); } }
/// <summary> /// Submits a request on the channel /// </summary> /// <param name="request"> /// The request message to submit /// </param> /// <param name="timeout"> /// The timeout for the submit operation /// </param> /// <param name="callback"> /// Asynchronous completion delegate /// </param> /// <param name="state"> /// Asynchronous completion delegate parameter /// </param> /// <returns> /// The asynchronous completion token /// </returns> public override IAsyncResult BeginRequest( Message request, TimeSpan timeout, AsyncCallback callback, Object state) { Boolean isOneWay = (request.Headers.ReplyTo == null); // prepare the request message for submission this.RemoteAddress.ApplyTo(request); if (request.Headers.MessageId == null) request.Headers.MessageId = new System.Xml.UniqueId(); // abort any pending timed-out requests FlushTimeouts(); // register the two-way request in the pending request map AsyncResult async = null; if (!isOneWay) { DateTime now = DateTime.UtcNow; PendingRequest context = new PendingRequest() { Result = async = new AsyncResult(callback, state, timeout), Expiration = (timeout < DateTime.MaxValue - now) ? DateTime.UtcNow + timeout : DateTime.MaxValue }; lock (base.ThisLock) this.requestMap.Add(request.Headers.MessageId, context); } // submit the request start an async receive try { try { // send the request message on the socket using (ManagedBuffer requestBuffer = this.Codec.Encode(request)) this.socket.Send(requestBuffer); // start a receiver if none is running if (!isOneWay) if (Interlocked.Increment(ref this.pending) == 1) BeginReceive(); // if no response is expected, complete the request sync return (isOneWay) ? new SyncResult(callback, state) : (IAsyncResult)async; } catch (ObjectDisposedException) { // if the socket was disposed, then the other side of the // channel closed, so close this side // we must throw here to force the WCF dispatcher to shut down // the channel; otherwise, it will continue to call us if (base.State == CommunicationState.Opened) base.Close(); throw new CommunicationObjectFaultedException(); } } catch { // if an error occurred, remove the pending request context if (!isOneWay) lock (base.ThisLock) this.requestMap.Remove(request.Headers.MessageId); throw; } }
/// <summary> /// Execute an HTTP request. /// </summary> /// <param name="method">The HTTP method verb. E.g. "GET", "POST", etc.</param> /// <param name="URL">The URL to request. MUST be for the same host as the first request.</param> /// <param name="body">Any data to post with the request</param> /// <param name="offset">The offset into body from which to start</param> /// <param name="len">The number of bytes to read from body, starting at offset</param> /// <param name="contentType">The MIME type of the supplied body</param> public void Execute(string method, Uri URL, byte[] body, int offset, int len, string contentType) { lock (m_queue) { PendingRequest req = new PendingRequest(method, URL, body, offset, len, contentType); if (m_host == null) m_host = req.URI.Host; else if (m_host != req.URI.Host) throw new InvalidOperationException("All requests must got to same host: " + m_host); m_queue.AddLast(req); Monitor.Pulse(m_queue); } }
public Task<MappedIdentity> MapAgent(UUID AgentId, string SlName = null) { MappedIdentity identity; lock (agentCacheLock) { if (AgentsByUuid.TryGetValue(AgentId, out identity)) { return Task.FromResult(identity); } } if(SlName != null) { return Task.FromResult(MakeAgentIdentity(AgentId, SlName)); } PendingRequest request; lock(agentRequests) { request = new PendingRequest(AgentId); agentRequests.Add(request); } client.Avatars.RequestAvatarName(AgentId); return request.TaskSource.Task; }
private void Send(PendingRequest req) { m_current = req; // Try to get it big enough that we don't have to allocate, without going overboard. MemoryStream ms = new MemoryStream(req.Length + 256); WriteString(ms, req.Method); WriteString(ms, " "); if (m_proxyURI == null) WriteString(ms, req.URI.PathAndQuery); else WriteString(ms, req.URI.ToString()); ms.Write(SP_HTTP11_CRLF, 0, SP_HTTP11_CRLF.Length); WebHeaderCollection coll = new WebHeaderCollection {{HttpRequestHeader.Host, req.URI.Host}}; if (req.ContentType != null) coll.Add(HttpRequestHeader.ContentType, req.ContentType); if (m_proxyCredentials != null) { byte[] creds = Encoding.ASCII.GetBytes(m_proxyCredentials.UserName + ":" + m_proxyCredentials.Password); coll.Add("Proxy-Authorization", "Basic " + Convert.ToBase64String(creds)); } coll.Add("X-JN-Name", m_name); coll.Add(HttpRequestHeader.Date, string.Format("{0:r}", DateTime.Now)); coll.Add(HttpRequestHeader.ContentLength, req.Length.ToString()); byte[] headers = coll.ToByteArray(); ms.Write(headers, 0, headers.Length); ms.Write(req.Body, req.Offset, req.Length); byte[] buf = ms.ToArray(); m_sock.Write(buf); m_sock.RequestRead(); }
bool ISocketEventListener.OnRead(BaseSocket sock, byte[] buf, int offset, int length) { Debug.WriteLine("IN HTTP: " + ENC.GetString(buf, offset, length)); int i = offset; string header = null; int last = offset + length; while (i < last) { // HTTP/1.1 200 OK // Header: value // Header: value // // Content switch (m_state) { case ParseState.START: if (!ParseAt(buf, ref i, last, HTTP11_SP, 0)) goto ERROR; m_state = ParseState.RESPONSE; break; case ParseState.RESPONSE: string code = ParseTo(buf, ref i, last, SPACE); if (code == null) goto ERROR; if (code != "200") { Debug.WriteLine("Non-OK response from server (" + code + "). STOP!"); goto ERROR; } try { // I know this can never fail. it's here for when we // implement redirects and the like. m_current.Code = int.Parse(code); } catch (Exception) { Debug.WriteLine("invalid response code"); goto ERROR; } m_state = ParseState.RESPONSE_TEXT; break; case ParseState.RESPONSE_TEXT: m_current.ResponseText = ParseTo(buf, ref i, last, CRLF); if (m_current.ResponseText == null) goto ERROR; m_state = ParseState.HEADER_NAME; break; case ParseState.HEADER_NAME: if (ParseAt(buf, ref i, last, CRLF, 0)) { m_state = ParseState.BODY_START; break; } header = ParseTo(buf, ref i, last, COL_SP); if (header == null) goto ERROR; m_state = ParseState.HEADER_VALUE; break; case ParseState.HEADER_VALUE: string val = ParseTo(buf, ref i, last, CRLF); if (val == null) goto ERROR; m_current.Headers.Add(header, val); m_state = ParseState.HEADER_NAME; break; case ParseState.BODY_START: // if we have the whole response, which is typical in XEP-124, then return it all at // once, without creating a MemoryStream. int len = m_current.ContentLength; if (len == -1) goto ERROR; if (i + len <= last) { m_current = null; m_state = ParseState.START; if (!m_listener.OnRead(null, buf, i, len)) { Close(); return false; } lock (m_queue) { Monitor.Pulse(m_queue); } return false; } // We got a partial response. We're going to have to wait until OnRead is called // again before we can pass a full response upstream. Hold on to the pieces in a // MemoryStream. m_current.Response = new MemoryStream(len); m_current.Response.Write(buf, i, last - i); m_state = ParseState.BODY_CONTINUE; return true; case ParseState.BODY_CONTINUE: m_current.Response.Write(buf, i, last - i); if (m_current.Response.Length == m_current.Response.Capacity) { PendingRequest req = m_current; m_current = null; m_state = ParseState.START; byte[] resp = req.Response.ToArray(); if (!m_listener.OnRead(null, resp, 0, resp.Length)) { Close(); return false; } lock (m_queue) { Monitor.Pulse(m_queue); } return false; } return true; default: break; } } return true; ERROR: m_listener.OnError(null, new ProtocolViolationException("Error parsing HTTP response")); Close(); return false; }