public Task SendReceiveAsync() { var receiveTask = ServerTransport.ReceiveAsync(CancellationToken); var sendTask = ClientTransport.SendAsync(Message, CancellationToken); return(Task.WhenAll(receiveTask, sendTask)); }
/// <summary> /// Use new ThreadPool thread for each new client connection. /// </summary> public override async Task ServeAsync(CancellationToken cancellationToken) { ServerCancellationToken = cancellationToken; try { try { ServerTransport.Listen(); } catch (TTransportException ttx) { LogError("Error, could not listen on ServerTransport: " + ttx); return; } //Fire the preServe server event when server is up but before any client connections if (ServerEventHandler != null) { await ServerEventHandler.PreServeAsync(cancellationToken); } while (!(stop || ServerCancellationToken.IsCancellationRequested)) { try { TTransport client = await ServerTransport.AcceptAsync(cancellationToken); _ = Task.Run(async() => await ExecuteAsync(client), cancellationToken); // intentionally ignoring retval } catch (TaskCanceledException) { stop = true; } catch (TTransportException ttx) { if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted) { LogError(ttx.ToString()); } } } if (stop) { try { ServerTransport.Close(); } catch (TTransportException ttx) { LogError("TServerTransport failed on close: " + ttx.Message); } stop = false; } } finally { ServerCancellationToken = default; } }
public async Task ReceiveAsync_CommandEnvelope_ClientShouldReceive() { // Arrange var presence = Dummy.CreatePresence(); var command = Dummy.CreateCommand(presence); var target = await GetTargetAndEstablish(); await ServerTransport.SendAsync(command, CancellationToken); // Act var receivedEnvelope = await target.ReceiveAsync(CancellationToken); // Assert var actual = receivedEnvelope.ShouldBeOfType <Command>(); actual.Id.ShouldBe(command.Id); actual.From.ShouldBe(command.From); actual.To.ShouldBe(command.To); var actualResource = actual.Resource.ShouldBeOfType <Presence>(); actualResource.Status.ShouldBe(presence.Status); actualResource.Message.ShouldBe(presence.Message); actualResource.RoutingRule.ShouldBe(presence.RoutingRule); actualResource.Priority.ShouldBe(presence.Priority); }
protected override async ValueTask <TTransport> AcceptImplementationAsync(CancellationToken cancellationToken) { try { EnsurePipeInstance(); await _stream.WaitForConnectionAsync(cancellationToken); var trans = new ServerTransport(_stream, Configuration); _stream = null; // pass ownership to ServerTransport //_isPending = false; return(trans); } catch (TTransportException) { Close(); throw; } catch (Exception e) { Close(); throw new TTransportException(TTransportException.ExceptionType.NotOpen, e.Message); } }
private async void GetAndConvertObject(string objectId, string commitId) { try { Tracker.TrackPageview(Tracker.RECEIVE); var transport = new ServerTransport(Client.Account, StreamId); var @base = await Operations.Receive( objectId, remoteTransport : transport, onErrorAction : OnErrorAction, onProgressAction : OnProgressAction, onTotalChildrenCountKnown : OnTotalChildrenCountKnown, disposeTransports : true ); Dispatcher.Instance().Enqueue(() => { var rc = GetComponent <RecursiveConverter>(); var go = rc.ConvertRecursivelyToNative(@base, commitId); //remove previously received object if (DeleteOld && ReceivedData != null) { Destroy(ReceivedData); } ReceivedData = go; OnDataReceivedAction?.Invoke(go); }); } catch (Exception e) { throw new SpeckleException(e.Message, e, true, SentryLevel.Error); } }
/// <summary> /// Helper method to Send to a Speckle Server. /// </summary> /// <param name="stream">Stream URL or Id to send to. If the URL contains branchName, commitId or objectId those will be used, otherwise the latest commit from main will be received.</param> /// <param name="data">Data to send</param> /// <param name="account">Account to use. If not provided the default account will be used.</param> /// <param name="useDefaultCache">Toggle for the default cache. If set to false, it will only send to the provided transports.</param> /// <param name="onProgressAction">Action invoked on progress iterations.</param> /// <param name="onErrorAction">Action invoked on internal errors.</param> /// <returns></returns> public static async Task <string> Send(string stream, Base data, string message = "No message", string sourceApplication = ".net", int totalChildrenCount = 0, Account account = null, bool useDefaultCache = true, Action <ConcurrentDictionary <string, int> > onProgressAction = null, Action <string, Exception> onErrorAction = null) { var sw = new StreamWrapper(stream); var client = new Client(account ?? await sw.GetAccount()); var transport = new ServerTransport(client.Account, sw.StreamId); var branchName = string.IsNullOrEmpty(sw.BranchName) ? "main" : sw.BranchName; var objectId = await Operations.Send( data, new List <ITransport> { transport }, useDefaultCache, onProgressAction, onErrorAction, disposeTransports : true); Tracker.TrackPageview(Tracker.SEND); return(await client.CommitCreate( new CommitCreateInput { streamId = sw.StreamId, branchName = branchName, objectId = objectId, message = message, sourceApplication = sourceApplication, totalChildrenCount = totalChildrenCount, })); }
private async Task Receive() { EditorUtility.DisplayProgressBar("Receving data...", "", 0); try { Tracker.TrackPageview(Tracker.RECEIVE); var transport = new ServerTransport(SelectedAccount, SelectedStream.id); var @base = await Operations.Receive( Branches[SelectedBranchIndex].commits.items[SelectedCommitIndex].referencedObject, remoteTransport : transport, onProgressAction : dict => { EditorUtility.DisplayProgressBar("Receving data...", "", Convert.ToSingle(dict.Values.Average() / _totalChildrenCount)); }, onTotalChildrenCountKnown : count => { _totalChildrenCount = count; } ); var go = _streamManager.ConvertRecursivelyToNative(@base, Branches[SelectedBranchIndex].commits.items[SelectedCommitIndex].id); } catch (Exception e) { throw new SpeckleException(e.Message, e, true, SentryLevel.Error); } EditorUtility.ClearProgressBar(); }
/// <summary> /// Speckle 1.0 had some inherited limitations on object size from MongoDB. Since we've moved to postgres, let's flex. /// </summary> /// <param name="numVertices"></param> /// <returns></returns> public static async Task SendReceiveLargeSingleObjects(int numVertices = 100_000) { Console.Clear(); Console.WriteLine($"Big mesh time! ({numVertices} vertices, and some {numVertices * 1.5} faces"); var myMesh = new Mesh(); for (int i = 1; i <= numVertices; i++) { myMesh.Points.Add(new Point(i / 0.3f, 2 * i + 3.2301000111, 0.22229 * i)); myMesh.Faces.AddRange(new int[] { i, i + i, i + 3, 23 + i, 100 % i }); } var myClient = new Client(AccountManager.GetDefaultAccount()); var streamId = await myClient.StreamCreate(new StreamCreateInput { name = "test", description = "this is a test" }); var server = new ServerTransport(AccountManager.GetDefaultAccount(), streamId); var res = await Operations.Send( myMesh, transports : new List <ITransport>() { server });; Console.WriteLine($"Big mesh id is {res}"); var cp = res; var pullMyMesh = await Operations.Receive(res); Console.WriteLine("Pulled back big mesh."); }
public void Setup() { firstUserAccount = Fixtures.SeedUser(); secondUserAccount = Fixtures.SeedUser(); myClient = new Client(firstUserAccount); myServerTransport = new ServerTransport(firstUserAccount, null); }
/// <summary> /// Use new ThreadPool thread for each new client connection. /// </summary> public override async Task ServeAsync(CancellationToken cancellationToken) { ServerCancellationToken = cancellationToken; try { try { ServerTransport.Listen(); } catch (TTransportException ttx) { LogError("Error, could not listen on ServerTransport: " + ttx); return; } //Fire the preServe server event when server is up but before any client connections if (ServerEventHandler != null) { await ServerEventHandler.PreServeAsync(cancellationToken); } while (!stop) { int failureCount = 0; try { TTransport client = await ServerTransport.AcceptAsync(cancellationToken); ThreadPool.QueueUserWorkItem(this.Execute, client); } catch (TTransportException ttx) { if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted) { ++failureCount; LogError(ttx.ToString()); } } } if (stop) { try { ServerTransport.Close(); } catch (TTransportException ttx) { LogError("TServerTransport failed on close: " + ttx.Message); } stop = false; } } finally { ServerCancellationToken = default(CancellationToken); } }
public void Setup() { testServer = new ServerInfo { url = "http://127.0.0.1:3000", name = "TestServer" }; testUserAccount = Fixtures.SeedUser(testServer); client = new Client(testUserAccount); myServerTransport = new ServerTransport(testUserAccount, null); }
public void Setup() { testServer = new ServerInfo { url = "https://testing.speckle.dev", name = "TestServer" }; testUserAccount = Fixtures.SeedUser(testServer); client = new Client(testUserAccount); myServerTransport = new ServerTransport(testUserAccount, null); }
public ServerController(IGameController controller) { _controller = controller; var serverProtocol = new ServerProtocol (this); _transport = new ServerTransport (serverProtocol); _transport.StartListening (); }
private async Task CleanupAsync() { try { await TransportListener.StopAsync(CancellationToken); await Task.WhenAll( ServerTransport.CloseAsync(CancellationToken), ClientTransport.CloseAsync(CancellationToken)); } catch {} }
/// <summary> /// Helper method to Receive from a Speckle Server. /// </summary> /// <param name="stream">Stream URL or Id to receive from. If the URL contains branchName, commitId or objectId those will be used, otherwise the latest commit from main will be received.</param> /// <param name="account">Account to use. If not provided the default account will be used.</param> /// <param name="onProgressAction">Action invoked on progress iterations.</param> /// <param name="onErrorAction">Action invoked on internal errors.</param> /// <param name="onTotalChildrenCountKnown">Action invoked once the total count of objects is known.</param> /// <returns></returns> public static async Task <Base> Receive(string stream, Account account = null, Action <ConcurrentDictionary <string, int> > onProgressAction = null, Action <string, Exception> onErrorAction = null, Action <int> onTotalChildrenCountKnown = null) { var sw = new StreamWrapper(stream); var client = new Client(account ?? await sw.GetAccount()); var transport = new ServerTransport(client.Account, sw.StreamId); string objectId = ""; //OBJECT URL if (!string.IsNullOrEmpty(sw.ObjectId)) { objectId = sw.ObjectId; } //COMMIT URL else if (!string.IsNullOrEmpty(sw.CommitId)) { var commit = await client.CommitGet(sw.StreamId, sw.CommitId); objectId = commit.referencedObject; } //BRANCH URL OR STREAM URL else { var branchName = string.IsNullOrEmpty(sw.BranchName) ? "main" : sw.BranchName; var branch = await client.BranchGet(sw.StreamId, branchName, 1); if (!branch.commits.items.Any()) { throw new SpeckleException($"The selected branch has no commits.", level: SentryLevel.Info); } objectId = branch.commits.items[0].referencedObject; } Tracker.TrackPageview(Tracker.RECEIVE); return(await Operations.Receive( objectId, remoteTransport : transport, onErrorAction : onErrorAction, onProgressAction : onProgressAction, onTotalChildrenCountKnown : onTotalChildrenCountKnown )); }
protected override TTransport AcceptImpl() { try { EnsurePipeInstance(); stream.WaitForConnection(); var trans = new ServerTransport(stream); stream = null; // pass ownership to ServerTransport return trans; } catch (Exception e) { Close(); throw new TTransportException(TTransportException.ExceptionType.NotOpen, e.Message); } }
protected override TTransport AcceptImpl() { try { EnsurePipeInstance(); stream.WaitForConnection(); var trans = new ServerTransport(stream); stream = null; // pass ownership to ServerTransport return(trans); } catch (Exception e) { Close(); throw new TTransportException(TTransportException.ExceptionType.NotOpen, e.Message); } }
private async Task StartListening(CancellationToken cancellationToken) { ServerTransport.Listen(); Logger.LogTrace("Started listening at server"); if (ServerEventHandler != null) { await ServerEventHandler.PreServeAsync(cancellationToken); } while (!cancellationToken.IsCancellationRequested) { if (ServerTransport.IsClientPending()) { Logger.LogTrace("Waiting for client connection"); try { var client = await ServerTransport.AcceptAsync(cancellationToken); await Task.Factory.StartNew(() => Execute(client, cancellationToken), cancellationToken); } catch (TTransportException ttx) { Logger.LogTrace($"Transport exception: {ttx}"); if (ttx.Type != TTransportException.ExceptionType.Interrupted) { Logger.LogError(ttx.ToString()); } } } else { try { await Task.Delay(TimeSpan.FromMilliseconds(_clientWaitingDelay), cancellationToken); } catch (TaskCanceledException) { } } } ServerTransport.Close(); Logger.LogTrace("Completed listening at server"); }
public async Task <RedisTransport> GetTargetAndEstablish() { var transport = await GetTargetAndOpenAsync(); await transport.SendAsync(new Session { State = SessionState.New }, CancellationToken); ServerTransport = await Listener.AcceptTransportAsync(CancellationToken); await ServerTransport.ReceiveAsync(CancellationToken); EstablishedSession = Dummy.CreateSession(SessionState.Established); await ServerTransport.SendAsync(EstablishedSession, CancellationToken); await transport.ReceiveAsync(CancellationToken); return(transport); }
private static void SendResponse(Task previous, ServerTransport transport, ServerResponseContext context, Tuple <RpcServer, long, int?, string> sessionState) { if (context == null) { if (previous.IsFaulted) { try { previous.Exception.Handle(inner => inner is OperationCanceledException); } catch (AggregateException exception) { InvocationHelper.HandleInvocationException( sessionState.Item2, MessageType.Notification, null, sessionState.Item4, exception, sessionState.Item1.Configuration.IsDebugMode ); } } previous.Dispose(); return; } switch (previous.Status) { case TaskStatus.Canceled: { context.Serialize <object>(null, new RpcErrorMessage(RpcError.TimeoutError, "Server task exceeds execution timeout.", null), null); break; } case TaskStatus.Faulted: { context.Serialize <object>(null, new RpcErrorMessage(RpcError.RemoteRuntimeError, "Dispatcher throws exception.", previous.Exception.ToString()), null); break; } } previous.Dispose(); transport.Send(context); }
public async Task SendAsync_FinishingSessionEnvelope_ServerShouldReceive() { // Arrange var target = await GetTargetAndEstablish(); var session = Dummy.CreateSession(SessionState.Finishing); session.Id = EstablishedSession.Id; // Act await target.SendAsync(session, CancellationToken); // Assert var receivedEnvelope = await ServerTransport.ReceiveAsync(CancellationToken); var actualSession = receivedEnvelope.ShouldBeOfType <Session>(); actualSession.State.ShouldBe(SessionState.Finishing); }
private async Task SetupAsync() { TransportListener = CreateTransportListener(); await TransportListener.StartAsync(CancellationToken); var serverTcpTransportTask = TransportListener.AcceptTransportAsync(CancellationToken); ClientTransport = CreateClientTransport(); await ClientTransport.OpenAsync(Uri, CancellationToken); SynchronizedClientTransport = new SynchronizedTransportDecorator(ClientTransport); ServerTransport = await serverTcpTransportTask; await ServerTransport.OpenAsync(Uri, CancellationToken); SynchronizedServerTransport = new SynchronizedTransportDecorator(ServerTransport); Message = Dummy.CreateMessage(Dummy.CreateTextContent()); }
public async Task ReceiveAsync_NotificationEnvelope_ClientShouldReceive() { // Arrange var notification = Dummy.CreateNotification(Event.Received); var target = await GetTargetAndEstablish(); await ServerTransport.SendAsync(notification, CancellationToken); // Act var receivedEnvelope = await target.ReceiveAsync(CancellationToken); // Assert var actual = receivedEnvelope.ShouldBeOfType <Notification>(); actual.Id.ShouldBe(notification.Id); actual.From.ShouldBe(notification.From); actual.To.ShouldBe(notification.To); actual.Event.ShouldBe(notification.Event); }
public void StartServer() { if (!string.IsNullOrEmpty(this["Port"]) || string.IsNullOrEmpty(IpAddress)) { return; } var port = int.Parse(Port); Objects.Clear(); var endPoint = new IPEndPoint(IPAddress.Parse(IpAddress), port); _transport = new ServerTransport(endPoint); _replicator = new Replicator.Replicator(Objects, _transport); _transport.Receive += _transport.Retranslate; _transport.ClientConnected += ClientConnected; _transport.ClientDisconnected += s => ClientsCount--; _transport.StartFailed += s => { ConnectionError = s; IsStarted = false; }; _transport.Start(); IsStarted = true; }
public async Task ReceiveAsync_MessageEnvelope_ClientShouldReceive() { // Arrange var content = Dummy.CreateTextContent(); var message = Dummy.CreateMessage(content); var target = await GetTargetAndEstablish(); await ServerTransport.SendAsync(message, CancellationToken); // Act var receivedEnvelope = await target.ReceiveAsync(CancellationToken); // Assert var actual = receivedEnvelope.ShouldBeOfType <Message>(); actual.Id.ShouldBe(message.Id); actual.From.ShouldBe(message.From); actual.To.ShouldBe(message.To); var actualContent = actual.Content.ShouldBeOfType <PlainText>(); actualContent.Text.ShouldBe(content.Text); }
/// <summary> /// Implementation-specific internal method not to be used by developers /// </summary> public void __setServerTransport(ServerTransport t) { m_ServerTransport = t; }
protected override TTransport AcceptImpl() { try { EnsurePipeInstance(); if (asyncMode) { var evt = new ManualResetEvent(false); Exception eOuter = null; stream.BeginWaitForConnection(asyncResult => { try { if (stream != null) { stream.EndWaitForConnection(asyncResult); } else { eOuter = new TTransportException(TTransportException.ExceptionType.Interrupted); } } catch (Exception e) { if (stream != null) { eOuter = e; } else { eOuter = new TTransportException(TTransportException.ExceptionType.Interrupted, e.Message, e); } } evt.Set(); }, null); evt.WaitOne(); if (eOuter != null) { throw eOuter; // rethrow exception } } else { stream.WaitForConnection(); } var trans = new ServerTransport(stream, asyncMode); stream = null; // pass ownership to ServerTransport return(trans); } catch (TTransportException) { Close(); throw; } catch (Exception e) { Close(); throw new TTransportException(TTransportException.ExceptionType.NotOpen, e.Message, e); } }
public void Invoke(HttpListenerContext c) { var m = new ServerTransport<Message[]>(c.Request.InputStream); ServerSession s = null; if (!this.Clients.ContainsKey(m.Descriptor.Description)) { s = DefaultSession; } else { s = Clients[m.Descriptor.Description]; var now = DateTime.Now; //Console.Write("*"); //Console.WriteLine("Client: " + s.ClientName + " client was offline " + new TimeSpan(now.Ticks - s.LastSeen.Ticks).ToString()); // params for server s.LastSeen = now; s.LastRequest = c.Request; } m.Data = s.Invoke(m.Data, c); if (m.Data.Length == 0) { c.Response.StatusCode = 204; } else { m.WriteTo(c.Response.OutputStream); } c.Response.Close(); }
public override void Stop() { stop = true; ServerTransport?.Close(); }
/// <summary> /// This .ctor is handy for message inspectors. /// Creates a substitute message for the original one with new values. /// Binding-specific context is cloned and headers/correlation data are cloned conditionaly /// </summary> protected RequestMsg(RequestMsg inspectedOriginal, MethodInfo method, Guid? instance, bool cloneHeaders = true, bool cloneCorrelation = true) : this(method, instance) { m_ServerTransport = inspectedOriginal.m_ServerTransport; CloneState(inspectedOriginal, cloneHeaders, cloneCorrelation); }
/// <summary> /// This .ctor is handy for message inspectors. /// Creates a substitute message for the original one with new values. /// Binding-specific context is cloned and headers/correlation data are cloned conditionaly /// </summary> protected RequestMsg(RequestMsg inspectedOriginal, TypeSpec contract, MethodSpec method, bool oneWay, Guid? instance, bool cloneHeaders = true, bool cloneCorrelation = true) : this(contract, method, oneWay, instance) { m_ServerTransport = inspectedOriginal.m_ServerTransport; CloneState(inspectedOriginal, cloneHeaders, cloneCorrelation); }
protected override async Task<TClientTransport> AcceptImplementationAsync(CancellationToken cancellationToken) { try { EnsurePipeInstance(); await _stream.WaitForConnectionAsync(cancellationToken); var trans = new ServerTransport(_stream); _stream = null; // pass ownership to ServerTransport //_isPending = false; return trans; } catch (TTransportException) { Close(); throw; } catch (Exception e) { Close(); throw new TTransportException(TTransportException.ExceptionType.NotOpen, e.Message); } }
/// <summary> /// Use new ThreadPool thread for each new client connection. /// </summary> public override async Task ServeAsync(CancellationToken cancellationToken) { ServerCancellationToken = cancellationToken; try { try { ServerTransport.Listen(); } catch (TTransportException ttx) { LogError("Error, could not listen on ServerTransport: " + ttx); return; } //Fire the preServe server event when server is up but before any client connections if (ServerEventHandler != null) { await ServerEventHandler.PreServeAsync(cancellationToken); } while (!stop) { int failureCount = 0; try { TTransport client = await ServerTransport.AcceptAsync(cancellationToken); #if WINDOWS_UWP await Windows.System.Threading.ThreadPool.RunAsync((source) => this.Execute(client)); #elif NETSTANDARD1_3 Debug.WriteLine("ThreadPool IS NOT SUPPORTED IN NETSTANDARD 1.3"); #else ThreadPool.QueueUserWorkItem(this.Execute, client); #endif } catch (TTransportException ttx) { if (!stop || ttx.Type != TTransportException.ExceptionType.Interrupted) { ++failureCount; LogError(ttx.ToString()); } } } if (stop) { try { ServerTransport.Close(); } catch (TTransportException ttx) { LogError("TServerTransport failed on close: " + ttx.Message); } stop = false; } } finally { ServerCancellationToken = default(CancellationToken); } }
internal override void ReturnTransport( ServerTransport transport ) { Contract.Requires( transport != null ); Contract.Requires( Object.ReferenceEquals( transport.Manager, this ) ); }
/// <summary> /// Invoked from the <see cref="ServerTransport"/> which was created by this manager, /// returns the transport to this manager. /// </summary> /// <param name="transport">The <see cref="ServerTransport"/> which was created by this manager.</param> internal abstract void ReturnTransport( ServerTransport transport );
public static Dictionary <string, object> Receive(StreamWrapper stream, CancellationToken cancellationToken, Action <ConcurrentDictionary <string, int> > onProgressAction = null, Action <string, Exception> onErrorAction = null, Action <int> onTotalChildrenCountKnown = null) { var account = stream.GetAccount().Result; // var client = new Client(account); Commit commit = null; if (stream.Type == StreamWrapperType.Stream || stream.Type == StreamWrapperType.Branch) { stream.BranchName = string.IsNullOrEmpty(stream.BranchName) ? "main" : stream.BranchName; try { var branch = client.BranchGet(cancellationToken, stream.StreamId, stream.BranchName, 1).Result; if (!branch.commits.items.Any()) { throw new SpeckleException("No commits found."); } commit = branch.commits.items[0]; } catch { throw new SpeckleException("No branch found with name " + stream.BranchName); } } else if (stream.Type == StreamWrapperType.Commit) { try { commit = client.CommitGet(cancellationToken, stream.StreamId, stream.CommitId).Result; } catch (Exception ex) { Utils.HandleApiExeption(ex); return(null); } } else if (stream.Type == StreamWrapperType.Object) { commit = new Commit() { referencedObject = stream.ObjectId, id = Guid.NewGuid().ToString() }; } if (commit == null) { throw new SpeckleException("Could not get commit."); } if (cancellationToken.IsCancellationRequested) { return(null); } var transport = new ServerTransport(account, stream.StreamId); var @base = Operations.Receive( commit.referencedObject, cancellationToken, remoteTransport: transport, onProgressAction: onProgressAction, onErrorAction: onErrorAction, onTotalChildrenCountKnown: onTotalChildrenCountKnown, disposeTransports: true ).Result; try { client.CommitReceived(new CommitReceivedInput { streamId = stream.StreamId, commitId = commit?.id, message = commit?.message, sourceApplication = Applications.DynamoRevit }).Wait(); } catch { // Do nothing! } if (cancellationToken.IsCancellationRequested) { return(null); } var converter = new BatchConverter(); var data = converter.ConvertRecursivelyToNative(@base); return(new Dictionary <string, object> { { "data", data }, { "commit", commit } }); }
protected override TTransport AcceptImpl() { try { EnsurePipeInstance(); if (asyncMode) { var evt = new ManualResetEvent(false); Exception eOuter = null; stream.BeginWaitForConnection(asyncResult => { try { if (stream != null) stream.EndWaitForConnection(asyncResult); else eOuter = new TTransportException(TTransportException.ExceptionType.Interrupted); } catch (Exception e) { if (stream != null) eOuter = e; else eOuter = new TTransportException(TTransportException.ExceptionType.Interrupted, e.Message); } evt.Set(); }, null); evt.WaitOne(); if (eOuter != null) throw eOuter; // rethrow exception } else { stream.WaitForConnection(); } var trans = new ServerTransport(stream,asyncMode); stream = null; // pass ownership to ServerTransport return trans; } catch (TTransportException) { Close(); throw; } catch (Exception e) { Close(); throw new TTransportException(TTransportException.ExceptionType.NotOpen, e.Message); } }
/// <summary> /// Set bound transport to this context. /// </summary> /// <param name="transport">The transport to be bound.</param> internal void SetTransport( ServerTransport transport ) { Contract.Requires( transport != null ); this.NextProcess = transport.UnpackRequestHeader; base.SetTransport( transport ); }
public override async Task <StreamState> ReceiveStream(StreamState state, ProgressViewModel progress) { var kit = KitManager.GetDefaultKit(); var converter = kit.LoadConverter(Utils.BentleyAppName); var transport = new ServerTransport(state.Client.Account, state.StreamId); var stream = await state.Client.StreamGet(state.StreamId); var previouslyReceivedObjects = state.ReceivedObjects; if (converter == null) { throw new Exception("Could not find any Kit!"); } if (Control.InvokeRequired) { Control.Invoke(new SetContextDelegate(converter.SetContextDocument), new object[] { Session.Instance }); } else { converter.SetContextDocument(Session.Instance); } if (progress.CancellationTokenSource.Token.IsCancellationRequested) { return(null); } /* * if (Doc == null) * { * progress.Report.LogOperationError(new Exception($"No Document is open.")); * progress.CancellationTokenSource.Cancel(); * } */ //if "latest", always make sure we get the latest commit when the user clicks "receive" Commit commit = null; if (state.CommitId == "latest") { var res = await state.Client.BranchGet(progress.CancellationTokenSource.Token, state.StreamId, state.BranchName, 1); commit = res.commits.items.FirstOrDefault(); } else { commit = await state.Client.CommitGet(progress.CancellationTokenSource.Token, state.StreamId, state.CommitId); } string referencedObject = commit.referencedObject; var commitObject = await Operations.Receive( referencedObject, progress.CancellationTokenSource.Token, transport, onProgressAction : dict => progress.Update(dict), onTotalChildrenCountKnown : num => Execute.PostToUIThread(() => progress.Max = num), onErrorAction : (message, exception) => { progress.Report.LogOperationError(exception); progress.CancellationTokenSource.Cancel(); }, disposeTransports : true ); try { await state.Client.CommitReceived(new CommitReceivedInput { streamId = stream?.id, commitId = commit?.id, message = commit?.message, sourceApplication = Utils.BentleyAppName }); } catch { // Do nothing! } if (progress.Report.OperationErrorsCount != 0) { return(state); } // invoke conversions on the main thread via control var flattenedObjects = FlattenCommitObject(commitObject, converter); List <ApplicationPlaceholderObject> newPlaceholderObjects; if (Control.InvokeRequired) { newPlaceholderObjects = (List <ApplicationPlaceholderObject>)Control.Invoke(new NativeConversionAndBakeDelegate(ConvertAndBakeReceivedObjects), new object[] { flattenedObjects, converter, state, progress }); } else { newPlaceholderObjects = ConvertAndBakeReceivedObjects(flattenedObjects, converter, state, progress); } if (newPlaceholderObjects == null) { converter.Report.ConversionErrors.Add(new Exception("fatal error: receive cancelled by user")); return(null); } DeleteObjects(previouslyReceivedObjects, newPlaceholderObjects); state.ReceivedObjects = newPlaceholderObjects; progress.Report.Merge(converter.Report); if (progress.Report.OperationErrorsCount != 0) { return(null); // the commit is being rolled back } try { //await state.RefreshStream(); WriteStateToFile(); } catch (Exception e) { progress.Report.OperationErrors.Add(e); } return(state); }
public static Dictionary <string, object> Receive(StreamWrapper stream, CancellationToken cancellationToken, Action <ConcurrentDictionary <string, int> > onProgressAction = null, Action <string, Exception> onErrorAction = null, Action <int> onTotalChildrenCountKnown = null) { Core.Credentials.Account account = stream.GetAccount(); stream.BranchName = string.IsNullOrEmpty(stream.BranchName) ? "main" : stream.BranchName; var client = new Client(account); Commit commit = null; if (string.IsNullOrEmpty(stream.CommitId)) { var res = client.StreamGet(cancellationToken, stream.StreamId).Result; var mainBranch = res.branches.items.FirstOrDefault(b => b.name == stream.BranchName); if (mainBranch == null) { Log.CaptureAndThrow(new Exception("No branch found with name " + stream.BranchName)); } if (!mainBranch.commits.items.Any()) { throw new Exception("No commits found."); } commit = mainBranch.commits.items[0]; } else { commit = client.CommitGet(cancellationToken, stream.StreamId, stream.CommitId).Result; } if (commit == null) { throw new Exception("Could not get commit."); } if (cancellationToken.IsCancellationRequested) { return(null); } var transport = new ServerTransport(account, stream.StreamId); var @base = Operations.Receive( commit.referencedObject, cancellationToken, remoteTransport: transport, onProgressAction: onProgressAction, onErrorAction: onErrorAction, onTotalChildrenCountKnown: onTotalChildrenCountKnown ).Result; if (cancellationToken.IsCancellationRequested) { return(null); } var converter = new BatchConverter(); var data = converter.ConvertRecursivelyToNative(@base); return(new Dictionary <string, object> { { "data", data }, { "commit", commit } }); }