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>
/// Implementation-specific internal method not to be used by developers
/// </summary>
public void __setServerTransport(ServerTransport t)
{
m_ServerTransport = t;
}
/// <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 }
});
}
