protected void getRequestStreamCallback(IAsyncResult asynchronousResult) { RequestToCancel requestToCancel = (RequestToCancel)asynchronousResult.AsyncState; if (log.isDebugEnabled()) { log.debug("getRequestStreamCallback(" + requestToCancel); } try { HttpWebRequest conn = requestToCancel.getConnection(); Stream postStream = conn.EndGetRequestStream(asynchronousResult); if (requestToCancel.buf != null) { if (log.isDebugEnabled()) { log.debug("bufferToStream"); } bufferToStream(requestToCancel.buf, postStream); } else if (requestToCancel.stream != null) { if (log.isDebugEnabled()) { log.debug("copy stream"); } requestToCancel.stream.CopyTo(postStream); postStream.Close(); } conn.BeginGetResponse(new AsyncCallback(this.getResponseCallback), requestToCancel); } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("Exception:", e); } BException bex = null; if (_cancelAllRequests) { bex = new BException(BExceptionC.CANCELLED, ""); } else { bex = new BException(BExceptionC.IOERROR, e.Message, e); } removeRequest(requestToCancel, null, bex); } finally { if (requestToCancel.stream != null) { requestToCancel.stream.Close(); } } if (log.isDebugEnabled()) { log.debug(")getRequestStreamCallback"); } }
public void setException(Exception ex) { if (ex.GetType() == typeof(BException)) { header.error = ((BException)ex).Code; } else { header.error = BExceptionC.REMOTE_ERROR; BSerializer ser = registry.getSerializer(ex, false); if (ser == null) { ex = new BException(BExceptionC.REMOTE_ERROR, "", ex); } } store(ex); // Alle Streams schließen. Sie werden nicht gesendet. if (streams != null) { foreach (BContentStream bstream in streams) { try { bstream.Close(); } catch (Exception) { } } streams = null; } }
protected override Stream openStream() { try { String url = wire.url + "?serverId=" + TargetId.getServerId() + "&messageid=" + TargetId.getMessageId() + "&streamid=" + TargetId.getStreamId(); HttpWebRequest conn = (HttpWebRequest)HttpWebRequest.Create(url); request = wire.createRequestForGetStream(TargetId, this); request.setConnection(conn); conn.Method = "GET"; wire.applySession(conn); response = (HttpWebResponse)conn.GetResponse(); ContentType = response.ContentType; ContentLength = response.ContentLength; ContentDisposition = response.Headers["Content-Disposition"]; responseStream = response.GetResponseStream(); } catch (Exception ex) { BException bex = new BException(BExceptionC.IOERROR, "", ex); setAsyncResult(null, bex); wire.removeRequest(request, null, bex); } throwExceptionIf(); return(responseStream); }
public override Object read(Object obj, BInput bin1, long version) { BInputBin bin = ((BInputBin)bin1); int code = bin.bbuf.getInt(); String msg = bin.bbuf.getString(); String details = bin.bbuf.getString(); BException e = new BException(code, msg, details); return e; }
public override void write(Object obj, BOutput bout1, long version) { BOutputBin bout = ((BOutputBin)bout1); BException e = (BException)obj; bout.bbuf.putInt(e.Code); bout.bbuf.putString(e.Message); bout.bbuf.putString(e.Details); }
public override Object read(Object obj, BInput bin1, long version) { BInputBin bin = ((BInputBin)bin1); int code = bin.bbuf.getInt(); String msg = bin.bbuf.getString(); String details = bin.bbuf.getString(); BException e = new BException(code, msg, details); return(e); }
public virtual async void ReadAllText(String path, BAsyncResult<String> asyncResult) { String __byps__ret = default(String); Exception __byps__ex = null; bool __byps__callAsync = false; try { __byps__ret = ReadAllText(path); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { __byps__ret = await ReadAllTextAsync(path); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void IncrementInt(int a, BAsyncResult<int> asyncResult) { int __byps__ret = default(int); Exception __byps__ex = null; bool __byps__callAsync = false; try { __byps__ret = IncrementInt(a); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { __byps__ret = await IncrementIntAsync(a); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void GetStreams(int ctrl, BAsyncResult<IList<System.IO.Stream>> asyncResult) { IList<System.IO.Stream> __byps__ret = default(IList<System.IO.Stream>); Exception __byps__ex = null; bool __byps__callAsync = false; try { __byps__ret = GetStreams(ctrl); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { __byps__ret = await GetStreamsAsync(ctrl); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void FindFiles(String path, FindOptions findOptions, BAsyncResult<IList<FileInfo>> asyncResult) { IList<FileInfo> __byps__ret = default(IList<FileInfo>); Exception __byps__ex = null; bool __byps__callAsync = false; try { __byps__ret = FindFiles(path, findOptions); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { __byps__ret = await FindFilesAsync(path, findOptions); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void PutStreams(IList<System.IO.Stream> strm, int ctrl, BAsyncResult<Object> asyncResult) { Object __byps__ret = default(Object); Exception __byps__ex = null; bool __byps__callAsync = false; try { PutStreams(strm, ctrl); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { await PutStreamsAsync(strm, ctrl); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void Notify(NotifyInfo notifyInfo, BAsyncResult<Object> asyncResult) { Object __byps__ret = default(Object); Exception __byps__ex = null; bool __byps__callAsync = false; try { Notify(notifyInfo); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { await NotifyAsync(notifyInfo); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public bool isReloginException(Exception ex, int typeId) { if (log.isDebugEnabled()) { log.debug("isReloginException(ex=" + ex + ", typeId=" + typeId); } bool ret = false; // Check exception if (ex is BException) { BException bex = (BException)ex; ret = (bex.Code == BExceptionC.UNAUTHORIZED); } if (log.isDebugEnabled()) { log.debug(")isReloginException=" + ret); } return(ret); }
public virtual void recv(BTargetId clientTargetId, Object methodObj, BAsyncResultIF<Object> methodResult) { try { BMethodRequest method = (BMethodRequest)methodObj; BRemote remote = null; int remoteId = method.getRemoteId(); BTargetId serverTargetId = this.transport.getTargetId(); // Die Target-ID aus dem Header ist gleich der Target-ID des BServer-Objekts // für einen normalen Client-Server-Request if (clientTargetId.Equals(serverTargetId)) { remotes.TryGetValue(remoteId, out remote); } else { // Es wird eine andere Target-ID angesteuert. // Ermittle hier die BRemote-Schnittstelle dieser Target-ID. // Sie kommt möglicherweise von einem anderen Client. remote = this.transport.getRemoteRegistry().getRemote(serverTargetId, clientTargetId, remoteId); } if (remote != null) { method.execute(remote, methodResult); } else { BException ex = new BException(BExceptionC.SERVICE_NOT_IMPLEMENTED, "Service not implemented: remoteId=" + remoteId); methodResult.setAsyncResult(null, ex); } } catch (Exception e) { methodResult.setAsyncResult(null, e); } }
public void setAsyncResult(BMessage obj, Exception e) { try { if (e == null) { // Methode ausführen pthis.transport.recv(pthis.server, obj, asyncResult); } else { BException ex = (BException)e; switch (ex.Code) { case BExceptionC.SESSION_CLOSED: // Session was invalidated. case BExceptionC.UNAUTHORIZED: // Re-login required case BExceptionC.CANCELLED: // no retry break; case BExceptionC.RESEND_LONG_POLL /* USE THIS FILE ACCORDING TO THE COPYRIGHT RULES IN LICENSE.TXT WHICH IS PART OF THE SOURCE CODE PACKAGE */ : // HWireClientR has released the expried long-poll. // Ignore the error and send a new long-poll. pthis.sendLongPoll(null); break; default: // retry after pause if (pthis.waitBeforeRetry()) { // e.g. Socket error pthis.sendLongPoll(null); } break; } } } catch (Exception e2) { asyncResult.setAsyncResult(null, e2); } }
public virtual void recv(BTargetId clientTargetId, Object methodObj, BAsyncResultIF <Object> methodResult) { try { BMethodRequest method = (BMethodRequest)methodObj; BRemote remote = null; int remoteId = method.getRemoteId(); BTargetId serverTargetId = this.transport.getTargetId(); // Die Target-ID aus dem Header ist gleich der Target-ID des BServer-Objekts // für einen normalen Client-Server-Request if (clientTargetId.Equals(serverTargetId)) { remotes.TryGetValue(remoteId, out remote); } else { // Es wird eine andere Target-ID angesteuert. // Ermittle hier die BRemote-Schnittstelle dieser Target-ID. // Sie kommt möglicherweise von einem anderen Client. remote = this.transport.getRemoteRegistry().getRemote(serverTargetId, clientTargetId, remoteId); } if (remote != null) { method.execute(remote, methodResult); } else { BException ex = new BException(BExceptionC.SERVICE_NOT_IMPLEMENTED, "Service not implemented: remoteId=" + remoteId); methodResult.setAsyncResult(null, ex); } } catch (Exception e) { methodResult.setAsyncResult(null, e); } }
public virtual async void WriteAllText(String path, String text, BAsyncResult<Object> asyncResult) { Object __byps__ret = default(Object); Exception __byps__ex = null; bool __byps__callAsync = false; try { WriteAllText(path, text); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { await WriteAllTextAsync(path, text); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public void negotiateProtocolClient(BAsyncResultIF <Boolean> asyncResult) { if (log.isDebugEnabled()) { log.debug("negotiateProtocolClient("); } if (log.isDebugEnabled()) { log.debug("negotiateActive=" + negotiateActive); } // Check that we do not run into recursive authentication requests. lock (asyncResultsWaitingForAuthentication) { // Already have an active negotiation request? if (negotiateActive) { // Are there threads waiting? if (asyncResultsWaitingForAuthentication.Count != 0) { // Most likely slow or recursive authentication BException ex = new BException(BExceptionC.FORBIDDEN, "Authentication procedure failed. Server returned 401 for every request. " + "A common reason for this error is slow authentication handling."); // ... or calling a function that requires authentication in BAuthentication.authenticate() - see. TestRemoteWithAuthentication.testAuthenticateBlocksRecursion asyncResult.setAsyncResult(false, ex); return; } else { // Correction: if no threads are waiting then there cannot be an aktive negotiation request. negotiateActive = true; } } else { // Now, this is the active negotiation request. negotiateActive = true; } } ByteBuffer buf = ByteBuffer.allocate(BNegotiate.NEGOTIATE_MAX_SIZE); BNegotiate nego = new BNegotiate(apiDesc); nego.write(buf); buf.flip(); BAsyncResultIF <BMessage> outerResult = new MyNegoAsyncResult(this, asyncResult); if (log.isDebugEnabled()) { log.debug("wire.send"); } BMessageHeader header = new BMessageHeader(); header.messageId = wire.makeMessageId(); BMessage msg = new BMessage(header, buf, null); wire.send(msg, outerResult); if (log.isDebugEnabled()) { log.debug(")negotiateProtocolClient"); } }
public virtual async void ExecuteNotifyExit(String[] args, ExecuteOptions opts, BAsyncResult<Object> asyncResult) { Object __byps__ret = default(Object); Exception __byps__ex = null; bool __byps__callAsync = false; try { ExecuteNotifyExit(args, opts); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { await ExecuteNotifyExitAsync(args, opts); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
protected void getResponseCallback(IAsyncResult asynchronousResult) { RequestToCancel requestToCancel = (RequestToCancel)asynchronousResult.AsyncState; if (log.isDebugEnabled()) { log.debug("getResponseCallback(" + requestToCancel); } HttpWebResponse response = null; ByteBuffer returnBuffer = null; Exception returnException = null; HttpWebRequest conn = requestToCancel.getConnection(); try { response = (HttpWebResponse)conn.EndGetResponse(asynchronousResult); if (log.isDebugEnabled()) { log.debug("status=" + response.StatusCode); } if (response.StatusCode != HttpStatusCode.OK) { requestToCancel.setAsyncResult(null, new BException(BExceptionC.IOERROR, "HTTP Status " + response.StatusCode)); } else { saveSession(conn); if (log.isDebugEnabled()) { log.debug("bufferFromStream"); } Stream responseStream = response.GetResponseStream(); returnBuffer = bufferFromStream(responseStream, false); } } catch (WebException e) { BException bex = null; if (_cancelAllRequests) { bex = new BException(BExceptionC.CANCELLED, ""); } else { if (e.Response != null) { int code = Convert.ToInt32(((HttpWebResponse)e.Response).StatusCode); bex = new BException(code, "HTTP Status " + code); } else { int code = Convert.ToInt32(HttpStatusCode.BadRequest); bex = new BException(code, e.ToString()); } } returnException = bex; } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("Exception", e); } returnException = new BException(BExceptionC.IOERROR, e.Message, e); } finally { if (response != null) { response.Close(); } removeRequest(requestToCancel, returnBuffer, returnException); } if (log.isDebugEnabled()) { log.debug(")getResponseCallback"); } }
public virtual async void BeginWatchFolder(String dir, bool recursive, String extraInfo, BAsyncResult<int> asyncResult) { int __byps__ret = default(int); Exception __byps__ex = null; bool __byps__callAsync = false; try { __byps__ret = BeginWatchFolder(dir, recursive, extraInfo); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { __byps__ret = await BeginWatchFolderAsync(dir, recursive, extraInfo); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void SendChat(ChatStructure cs, BAsyncResult<ChatStructure> asyncResult) { ChatStructure __byps__ret = default(ChatStructure); Exception __byps__ex = null; bool __byps__callAsync = false; try { __byps__ret = SendChat(cs); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { __byps__ret = await SendChatAsync(cs); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void EndWatchFolder(int handle, BAsyncResult<Object> asyncResult) { Object __byps__ret = default(Object); Exception __byps__ex = null; bool __byps__callAsync = false; try { EndWatchFolder(handle); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { await EndWatchFolderAsync(handle); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void UploadFilesMultipartFormdata(FormItem[] items, String url, String method, BAsyncResult<Object> asyncResult) { Object __byps__ret = default(Object); Exception __byps__ex = null; bool __byps__callAsync = false; try { UploadFilesMultipartFormdata(items, url, method); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { await UploadFilesMultipartFormdataAsync(items, url, method); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }
public virtual async void UploadFile(String path, String url, BAsyncResult<Object> asyncResult) { Object __byps__ret = default(Object); Exception __byps__ex = null; bool __byps__callAsync = false; try { UploadFile(path, url); } catch (NotImplementedException) { __byps__callAsync = true; } catch (Exception e) { __byps__ex = e; } if (__byps__callAsync) try { await UploadFileAsync(path, url); } catch (NotImplementedException) { __byps__ex = new BException(BExceptionC.UNSUPPORTED_METHOD, ""); } catch (Exception e) { __byps__ex = e; } asyncResult(__byps__ret, __byps__ex); }