コード例 #1
0
ファイル: VertexTableManager.cs プロジェクト: nlebeck/CRA
 internal VertexTable GetRowForActiveVertex(string vertexName)
 {
     return(VertexTable.GetAll(_vertexTable)
            .Where(gn => vertexName == gn.VertexName && !string.IsNullOrEmpty(gn.InstanceName))
            .Where(gn => gn.IsActive)
            .First());
 }
コード例 #2
0
        /// <summary>
        /// Connect a set of vertices in one sharded CRA vertex to another with a full mesh topology, via pre-defined endpoints. We contact the "from" vertex
        /// to initiate the creation of the link.
        /// </summary>
        /// <param name="fromVertexName"></param>
        /// <param name="fromEndpoints"></param>
        /// <param name="toVertexName"></param>
        /// <param name="toEndpoints"></param>
        /// <returns></returns>
        public CRAErrorCode ConnectShardedVerticesWithFullMesh(string fromVertexName, string[] fromEndpoints, string toVertexName, string[] toEndpoints)
        {
            var fromVerticesRows = VertexTable.GetRowsForShardedVertex(_vertexTable, fromVertexName);

            string[] fromVerticesNames = new string[fromVerticesRows.Count()];

            int i = 0;

            foreach (var fromVertexRow in fromVerticesRows)
            {
                fromVerticesNames[i] = fromVertexRow.VertexName;
                i++;
            }

            var toVerticesRows = VertexTable.GetRowsForShardedVertex(_vertexTable, toVertexName);

            string[] toVerticesNames = new string[toVerticesRows.Count()];

            i = 0;
            foreach (var toVertexRow in toVerticesRows)
            {
                toVerticesNames[i] = toVertexRow.VertexName;
                i++;
            }

            return(ConnectShardedVerticesWithFullMesh(fromVerticesNames, fromEndpoints, toVerticesNames, toEndpoints, ConnectionInitiator.FromSide));
        }
コード例 #3
0
        /// <summary>
        /// Disconnect a set of vertices in one sharded CRA vertex from another, via pre-defined endpoints.
        /// </summary>
        /// <param name="fromVertexName"></param>
        /// <param name="fromEndpoints"></param>
        /// <param name="toVertexName"></param>
        /// <param name="toEndpoints"></param>
        /// <returns></returns>
        public void DisconnectShardedVertices(string fromVertexName, string[] fromEndpoints, string toVertexName, string[] toEndpoints)
        {
            var fromVerticesRows = VertexTable.GetRowsForShardedVertex(_vertexTable, fromVertexName);

            string[] fromVerticesNames = new string[fromVerticesRows.Count()];

            int i = 0;

            foreach (var fromVertexRow in fromVerticesRows)
            {
                fromVerticesNames[i] = fromVertexRow.VertexName;
                i++;
            }

            var toVerticesRows = VertexTable.GetRowsForShardedVertex(_vertexTable, toVertexName);

            string[] toVerticesNames = new string[toVerticesRows.Count()];

            i = 0;
            foreach (var toVertexRow in toVerticesRows)
            {
                toVerticesNames[i] = toVertexRow.VertexName;
                i++;
            }

            DisconnectShardedVertices(fromVerticesNames, fromEndpoints, toVerticesNames, toEndpoints);
        }
コード例 #4
0
ファイル: VertexTableManager.cs プロジェクト: nlebeck/CRA
 internal void DeleteShardedVertex(string vertexName)
 {
     foreach (var row in VertexTable.GetRowsForShardedVertex(_vertexTable, vertexName))
     {
         TableOperation deleteOperation = TableOperation.Delete(row);
         _vertexTable.ExecuteAsync(deleteOperation).Wait();
     }
 }
コード例 #5
0
ファイル: VertexTableManager.cs プロジェクト: nlebeck/CRA
        internal void DeactivateVertexOnInstance(string vertexName, string instanceName)
        {
            var newActiveVertex = VertexTable.GetAll(_vertexTable)
                                  .Where(gn => instanceName == gn.InstanceName && vertexName == gn.VertexName)
                                  .First();

            newActiveVertex.IsActive = false;
            TableOperation insertOperation = TableOperation.InsertOrReplace(newActiveVertex);

            _vertexTable.ExecuteAsync(insertOperation).Wait();
        }
コード例 #6
0
ファイル: CRAWorker.cs プロジェクト: cmeiklejohn/CRA
        private void RestoreVerticesAndConnections()
        {
            var rows = VertexTable.GetAllRowsForInstance(_workerInstanceTable, _workerinstanceName);

            foreach (var _row in rows)
            {
                if (string.IsNullOrEmpty(_row.VertexName))
                {
                    continue;
                }
                RestoreVertexAndConnections(_row);
            }
        }
コード例 #7
0
ファイル: CRAWorker.cs プロジェクト: cmeiklejohn/CRA
        private void RestoreConnections(VertexTable _row)
        {
            // Decide what to do if connection creation fails
            var outRows = ConnectionTable.GetAllConnectionsFromVertex(_connectionTable, _row.VertexName).ToList();

            foreach (var row in outRows)
            {
                Task.Run(() => RetryRestoreConnection(row.FromVertex, row.FromEndpoint, row.ToVertex, row.ToEndpoint, false));
            }

            var inRows = ConnectionTable.GetAllConnectionsToVertex(_connectionTable, _row.VertexName).ToList();

            foreach (var row in inRows)
            {
                Task.Run(() => RetryRestoreConnection(row.FromVertex, row.FromEndpoint, row.ToVertex, row.ToEndpoint, true));
            }
        }
コード例 #8
0
        /// <summary>
        /// Load all vertices for the given instance name, returns only when all
        /// vertices have been initialized and activated.
        /// </summary>
        /// <param name="thisInstanceName"></param>
        /// <returns></returns>
        public ConcurrentDictionary <string, IVertex> LoadAllVertices(string thisInstanceName)
        {
            ConcurrentDictionary <string, IVertex> result = new ConcurrentDictionary <string, IVertex>();
            var rows = VertexTable.GetAllRowsForInstance(_vertexTable, thisInstanceName);

            List <Task> t = new List <Task>();

            foreach (var row in rows)
            {
                if (row.VertexName == "")
                {
                    continue;
                }
                t.Add(LoadVertexAsync(row.VertexName, row.VertexDefinition, row.VertexParameter, thisInstanceName, result));
            }
            Task.WaitAll(t.ToArray());

            return(result);
        }
コード例 #9
0
        /// <summary>
        /// Define a sharded vertex type and register with CRA.
        /// </summary>
        /// <param name="vertexDefinition">Name of the vertex type</param>
        /// <param name="creator">Lambda that describes how to instantiate the vertex, taking in an object as parameter</param>
        public CRAErrorCode DefineVertex(string vertexDefinition, Expression <Func <IShardedVertex> > creator)
        {
            CloudBlobContainer container = _blobClient.GetContainerReference("cra");

            container.CreateIfNotExistsAsync().Wait();
            var             blockBlob  = container.GetBlockBlobReference(vertexDefinition + "/binaries");
            CloudBlobStream blobStream = blockBlob.OpenWriteAsync().GetAwaiter().GetResult();

            AssemblyUtils.WriteAssembliesToStream(blobStream);
            blobStream.Close();

            // Add metadata
            var            newRow          = new VertexTable("", vertexDefinition, vertexDefinition, "", 0, creator, null, true);
            TableOperation insertOperation = TableOperation.InsertOrReplace(newRow);

            _vertexTable.ExecuteAsync(insertOperation).Wait();

            return(CRAErrorCode.Success);
        }
コード例 #10
0
        public IVertex CreateVertex(string vertexDefinition, CloudBlobContainer container)
        {
            if (_dynamicLoadingEnabled)
            {
                var    blockBlob  = container.GetBlockBlobReference(vertexDefinition + "/binaries");
                Stream blobStream = blockBlob.OpenReadAsync().GetAwaiter().GetResult();
                try
                {
                    AssemblyUtils.LoadAssembliesFromStream(blobStream);
                }
                catch (FileLoadException e)
                {
                    Debug.WriteLine("Ignoring exception from assembly loading: " + e.Message);
                    Debug.WriteLine("If vertex creation fails, the caller will need to sideload the vertex.");
                }
                blobStream.Close();
            }
            else
            {
                Debug.WriteLine("Dynamic assembly loading is disabled. The caller will need to sideload the vertex.");
            }

            var row = VertexTable.GetRowForVertexDefinition(_vertexTable, vertexDefinition);

            // CREATE THE VERTEX
            IVertex vertex = null;

            try
            {
                vertex = row.GetVertexCreateAction()();
            }
            catch (Exception e)
            {
                Debug.WriteLine("Vertex creation failed: " + e.Message);
                Debug.WriteLine("The caller will need to sideload the vertex.");
            }
            return(vertex);
        }
コード例 #11
0
ファイル: VertexTableManager.cs プロジェクト: nlebeck/CRA
        internal void ActivateVertexOnInstance(string vertexName, string instanceName)
        {
            var newActiveVertex = VertexTable.GetAll(_vertexTable)
                                  .Where(gn => instanceName == gn.InstanceName && vertexName == gn.VertexName)
                                  .First();

            newActiveVertex.IsActive = true;
            TableOperation insertOperation = TableOperation.InsertOrReplace(newActiveVertex);

            _vertexTable.ExecuteAsync(insertOperation).Wait();

            var procs = VertexTable.GetAll(_vertexTable)
                        .Where(gn => vertexName == gn.VertexName && instanceName != gn.InstanceName);

            foreach (var proc in procs)
            {
                if (proc.IsActive)
                {
                    proc.IsActive = false;
                    TableOperation _insertOperation = TableOperation.InsertOrReplace(proc);
                    _vertexTable.ExecuteAsync(_insertOperation).Wait();
                }
            }
        }
コード例 #12
0
ファイル: CRAWorker.cs プロジェクト: cmeiklejohn/CRA
        internal CRAErrorCode Connect_InitiatorSide(string fromVertexName, string fromVertexOutput, string toVertexName, string toVertexInput, bool reverse, bool killIfExists = true, bool killRemote = true)
        {
            VertexTable row;

            try
            {
                // Need to get the latest address & port
                row = reverse ? VertexTable.GetRowForVertex(_workerInstanceTable, fromVertexName)
                : VertexTable.GetRowForVertex(_workerInstanceTable, toVertexName);
            }
            catch
            {
                return(CRAErrorCode.ActiveVertexNotFound);
            }

            // If from and to vertices are on the same (this) instance,
            // we can convert a "reverse" connection into a normal connection
            if (reverse && (row.InstanceName == InstanceName))
            {
                reverse = false;
            }

            CancellationTokenSource oldSource;
            var conn = reverse ? inConnections : outConnections;

            if (conn.TryGetValue(fromVertexName + ":" + fromVertexOutput + ":" + toVertexName + ":" + toVertexInput,
                                 out oldSource))
            {
                if (killIfExists)
                {
                    Debug.WriteLine("Deleting prior connection - it will automatically reconnect");
                    oldSource.Cancel();
                }
                return(CRAErrorCode.Success);
            }

            if (TryFusedConnect(row.InstanceName, fromVertexName, fromVertexOutput, toVertexName, toVertexInput))
            {
                return(CRAErrorCode.Success);
            }

            // Re-check the connection table as someone may have successfully
            // created a fused connection
            if (conn.TryGetValue(fromVertexName + ":" + fromVertexOutput + ":" + toVertexName + ":" + toVertexInput,
                                 out oldSource))
            {
                if (killIfExists)
                {
                    Debug.WriteLine("Deleting prior connection - it will automatically reconnect");
                    oldSource.Cancel();
                }
                return(CRAErrorCode.Success);
            }

            // Send request to CRA instance
            Stream ns   = null;
            var    _row = VertexTable.GetRowForInstanceVertex(_workerInstanceTable, row.InstanceName, "");

            try
            {
                // Get a stream connection from the pool if available
                if (!_craClient.TryGetSenderStreamFromPool(_row.Address, _row.Port.ToString(), out ns))
                {
                    TcpClient client = new TcpClient(_row.Address, _row.Port);
                    client.NoDelay = true;

                    ns = _craClient.SecureStreamConnectionDescriptor
                         .CreateSecureClient(client.GetStream(), row.InstanceName);
                }
            }
            catch
            {
                return(CRAErrorCode.ConnectionEstablishFailed);
            }

            if (!reverse)
            {
                ns.WriteInt32((int)CRATaskMessageType.CONNECT_VERTEX_RECEIVER);
            }
            else
            {
                ns.WriteInt32((int)CRATaskMessageType.CONNECT_VERTEX_RECEIVER_REVERSE);
            }

            ns.WriteByteArray(Encoding.UTF8.GetBytes(fromVertexName));
            ns.WriteByteArray(Encoding.UTF8.GetBytes(fromVertexOutput));
            ns.WriteByteArray(Encoding.UTF8.GetBytes(toVertexName));
            ns.WriteByteArray(Encoding.UTF8.GetBytes(toVertexInput));
            ns.WriteInt32(killRemote ? 1 : 0);
            CRAErrorCode result = (CRAErrorCode)ns.ReadInt32();

            if (result != 0)
            {
                Debug.WriteLine("Error occurs while establishing the connection!!");
                return(result);
            }
            else
            {
                CancellationTokenSource source = new CancellationTokenSource();

                if (!reverse)
                {
                    if (outConnections.TryAdd(fromVertexName + ":" + fromVertexOutput + ":" + toVertexName + ":" + toVertexInput, source))
                    {
                        Task.Run(() =>
                                 EgressToStream(fromVertexName, fromVertexOutput, toVertexName, toVertexInput, reverse, ns, source, _row.Address, _row.Port));

                        return(CRAErrorCode.Success);
                    }
                    else
                    {
                        source.Dispose();
                        ns.Close();
                        Console.WriteLine("Race adding connection - deleting outgoing stream");
                        return(CRAErrorCode.ConnectionAdditionRace);
                    }
                }
                else
                {
                    if (inConnections.TryAdd(fromVertexName + ":" + fromVertexOutput + ":" + toVertexName + ":" + toVertexInput, source))
                    {
                        Task.Run(() =>
                                 IngressFromStream(fromVertexName, fromVertexOutput, toVertexName, toVertexInput, reverse, ns, source, _row.Address, _row.Port));
                        return(CRAErrorCode.Success);
                    }
                    else
                    {
                        source.Dispose();
                        ns.Close();
                        Debug.WriteLine("Race adding connection - deleting outgoing stream");
                        return(CRAErrorCode.ConnectionAdditionRace);
                    }
                }
            }
        }
コード例 #13
0
ファイル: VertexTable.cs プロジェクト: nlebeck/CRA
        /// <summary>
        /// Equals
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            VertexTable other = obj as VertexTable;

            return(this.PartitionKey.Equals(other.PartitionKey) && this.RowKey.Equals(other.RowKey));
        }
コード例 #14
0
        /// <summary>
        /// Connect one CRA vertex to another, via pre-defined endpoints. We contact the "from" vertex
        /// to initiate the creation of the link.
        /// </summary>
        /// <param name="fromVertexName">Name of the vertex from which connection is being made</param>
        /// <param name="fromEndpoint">Name of the endpoint on the fromVertex, from which connection is being made</param>
        /// <param name="toVertexName">Name of the vertex to which connection is being made</param>
        /// <param name="toEndpoint">Name of the endpoint on the toVertex, to which connection is being made</param>
        /// <param name="direction">Which vertex initiates the connection</param>
        /// <returns>Status of the Connect operation</returns>
        public CRAErrorCode Connect(string fromVertexName, string fromEndpoint, string toVertexName, string toEndpoint, ConnectionInitiator direction)
        {
            // Tell from vertex to establish connection
            // Send request to CRA instance

            // Check that vertex and endpoints are valid and existing
            if (!_vertexTableManager.ExistsVertex(fromVertexName) || !_vertexTableManager.ExistsVertex(toVertexName))
            {
                // Check for sharded vertices
                List <int> fromVertexShards, toVertexShards;

                if (!_vertexTableManager.ExistsShardedVertex(fromVertexName, out fromVertexShards))
                {
                    return(CRAErrorCode.VertexNotFound);
                }

                if (!_vertexTableManager.ExistsShardedVertex(toVertexName, out toVertexShards))
                {
                    return(CRAErrorCode.VertexNotFound);
                }

                return(ConnectSharded(fromVertexName, fromVertexShards, fromEndpoint, toVertexName, toVertexShards, toEndpoint, direction));
            }

            // Make the connection information stable
            _connectionTableManager.AddConnection(fromVertexName, fromEndpoint, toVertexName, toEndpoint);

            // We now try best-effort to tell the CRA instance of this connection
            CRAErrorCode result = CRAErrorCode.Success;

            VertexTable _row;

            try
            {
                // Get instance for source vertex
                _row = direction == ConnectionInitiator.FromSide ?
                       VertexTable.GetRowForVertex(_vertexTable, fromVertexName) :
                       VertexTable.GetRowForVertex(_vertexTable, toVertexName);
            }
            catch
            {
                Console.WriteLine("Unable to find active instance with vertex. On vertex activation, the connection should be completed automatically.");
                return(result);
            }

            try
            {
                if (_localWorker != null)
                {
                    if (_localWorker.InstanceName == _row.InstanceName)
                    {
                        return(_localWorker.Connect_InitiatorSide(fromVertexName, fromEndpoint,
                                                                  toVertexName, toEndpoint, direction == ConnectionInitiator.ToSide));
                    }
                }


                // Send request to CRA instance
                TcpClient client = null;
                // Get address and port for instance, using row with vertex = ""
                var row = VertexTable.GetRowForInstance(_vertexTable, _row.InstanceName);

                // Get a stream connection from the pool if available
                Stream stream;
                if (!TryGetSenderStreamFromPool(row.Address, row.Port.ToString(), out stream))
                {
                    client         = new TcpClient(row.Address, row.Port);
                    client.NoDelay = true;

                    stream = client.GetStream();

                    if (SecureStreamConnectionDescriptor != null)
                    {
                        stream = SecureStreamConnectionDescriptor.CreateSecureClient(stream, _row.InstanceName);
                    }
                }

                if (direction == ConnectionInitiator.FromSide)
                {
                    stream.WriteInt32((int)CRATaskMessageType.CONNECT_VERTEX_INITIATOR);
                }
                else
                {
                    stream.WriteInt32((int)CRATaskMessageType.CONNECT_VERTEX_INITIATOR_REVERSE);
                }

                stream.WriteByteArray(Encoding.UTF8.GetBytes(fromVertexName));
                stream.WriteByteArray(Encoding.UTF8.GetBytes(fromEndpoint));
                stream.WriteByteArray(Encoding.UTF8.GetBytes(toVertexName));
                stream.WriteByteArray(Encoding.UTF8.GetBytes(toEndpoint));

                result = (CRAErrorCode)stream.ReadInt32();
                if (result != 0)
                {
                    Console.WriteLine("Connection was logically established. However, the client received an error code from the connection-initiating CRA instance: " + result);
                }
                else
                {
                    // Add/Return a stream connection to the pool
                    TryAddSenderStreamToPool(row.Address, row.Port.ToString(), stream);
                }
            }
            catch
            {
                Console.WriteLine("The connection-initiating CRA instance appears to be down or could not be found. Restart it and this connection will be completed automatically");
            }
            return(result);
        }
コード例 #15
0
ファイル: CRAWorker.cs プロジェクト: cmeiklejohn/CRA
        private async void RestoreVertexAndConnections(VertexTable _row)
        {
            await _craClient.LoadVertexAsync(_row.VertexName, _row.VertexDefinition, _row.VertexParameter, _workerinstanceName, _localVertexTable);

            RestoreConnections(_row);
        }
コード例 #16
0
ファイル: VertexTableManager.cs プロジェクト: nlebeck/CRA
 internal VertexTable GetRowForInstanceVertex(string instanceName, string vertexName)
 {
     return(VertexTable.GetAll(_vertexTable).Where(gn => instanceName == gn.InstanceName && vertexName == gn.VertexName).First());
 }
コード例 #17
0
ファイル: VertexTableManager.cs プロジェクト: nlebeck/CRA
 internal VertexTable GetRowForDefaultInstance()
 {
     return(VertexTable.GetAll(_vertexTable).Where(gn => string.IsNullOrEmpty(gn.VertexName)).First());
 }
コード例 #18
0
        internal CRAErrorCode InstantiateVertex(string instanceName, string vertexName, string vertexDefinition, object vertexParameter, bool sharded)
        {
            var procDefRow = VertexTable.GetRowForVertexDefinition(_vertexTable, vertexDefinition);

            string blobName = vertexName + "-" + instanceName;

            // Serialize and write the vertex parameters to a blob
            CloudBlobContainer container = _blobClient.GetContainerReference("cra");

            container.CreateIfNotExistsAsync().Wait();
            var             blockBlob  = container.GetBlockBlobReference(vertexDefinition + "/" + blobName);
            CloudBlobStream blobStream = blockBlob.OpenWriteAsync().GetAwaiter().GetResult();

            byte[] parameterBytes = Encoding.UTF8.GetBytes(
                SerializationHelper.SerializeObject(vertexParameter));
            blobStream.WriteByteArray(parameterBytes);
            blobStream.Close();

            // Add metadata
            var newRow = new VertexTable(instanceName, vertexName, vertexDefinition, "", 0,
                                         procDefRow.VertexCreateAction,
                                         blobName,
                                         false, sharded);
            TableOperation insertOperation = TableOperation.InsertOrReplace(newRow);

            _vertexTable.ExecuteAsync(insertOperation).Wait();

            CRAErrorCode result = CRAErrorCode.Success;

            // Send request to CRA instance
            VertexTable instanceRow;

            try
            {
                instanceRow = VertexTable.GetRowForInstance(_vertexTable, instanceName);

                // Get a stream connection from the pool if available
                Stream stream;
                if (!TryGetSenderStreamFromPool(instanceRow.Address, instanceRow.Port.ToString(), out stream))
                {
                    TcpClient client = new TcpClient(instanceRow.Address, instanceRow.Port);
                    client.NoDelay = true;

                    stream = client.GetStream();
                    if (SecureStreamConnectionDescriptor != null)
                    {
                        stream = SecureStreamConnectionDescriptor.CreateSecureClient(stream, instanceName);
                    }
                }

                stream.WriteInt32((int)CRATaskMessageType.LOAD_VERTEX);
                stream.WriteByteArray(Encoding.UTF8.GetBytes(vertexName));
                stream.WriteByteArray(Encoding.UTF8.GetBytes(vertexDefinition));
                stream.WriteByteArray(Encoding.UTF8.GetBytes(newRow.VertexParameter));
                result = (CRAErrorCode)stream.ReadInt32();
                if (result != 0)
                {
                    Console.WriteLine("Vertex was logically loaded. However, we received an error code from the hosting CRA instance: " + result);
                }

                // Add/Return stream connection to the pool
                TryAddSenderStreamToPool(instanceRow.Address, instanceRow.Port.ToString(), stream);
            }
            catch
            {
                Console.WriteLine("The CRA instance appears to be down. Restart it and this vertex will be instantiated automatically");
            }
            return(result);
        }
コード例 #19
0
ファイル: CRAClientLibrary.cs プロジェクト: cmeiklejohn/CRA
        /// <summary>
        /// Load a vertex on the local instance
        /// </summary>
        /// <param name="vertexName"></param>
        /// <param name="vertexDefinition"></param>
        /// <param name="vertexParameter"></param>
        /// <param name="instanceName"></param>
        /// <param name="table"></param>
        /// <returns></returns>
        public async Task <IVertex> LoadVertexAsync(string vertexName, string vertexDefinition, string vertexParameter, string instanceName, ConcurrentDictionary <string, IVertex> table)
        {
            // Deactivate vertex
            _vertexTableManager.DeactivateVertexOnInstance(vertexName, instanceName);

            CloudBlobContainer container = _blobClient.GetContainerReference("cra");

            container.CreateIfNotExistsAsync().Wait();
            var    blockBlob  = container.GetBlockBlobReference(vertexDefinition + "/binaries");
            Stream blobStream = blockBlob.OpenReadAsync().GetAwaiter().GetResult();

            AssemblyUtils.LoadAssembliesFromStream(blobStream);
            blobStream.Close();

            var row = VertexTable.GetRowForVertexDefinition(_vertexTable, vertexDefinition);

            // CREATE THE VERTEX
            var vertex = row.GetVertexCreateAction()();

            // INITIALIZE
            if ((VertexBase)vertex != null)
            {
                ((VertexBase)vertex).VertexName    = vertexName;
                ((VertexBase)vertex).ClientLibrary = this;
            }

            // LATCH CALLBACKS TO POPULATE ENDPOINT TABLE
            vertex.OnAddInputEndpoint((name, endpt) => _endpointTableManager.AddEndpoint(vertexName, name, true, false));
            vertex.OnAddOutputEndpoint((name, endpt) => _endpointTableManager.AddEndpoint(vertexName, name, false, false));
            vertex.OnAddAsyncInputEndpoint((name, endpt) => _endpointTableManager.AddEndpoint(vertexName, name, true, true));
            vertex.OnAddAsyncOutputEndpoint((name, endpt) => _endpointTableManager.AddEndpoint(vertexName, name, false, true));

            //ADD TO TABLE
            if (table != null)
            {
                table.AddOrUpdate(vertexName, vertex, (procName, oldProc) => { oldProc.Dispose(); return(vertex); });

                vertex.OnDispose(() =>
                {
                    // Delete all endpoints of the vertex
                    foreach (var key in vertex.InputEndpoints)
                    {
                        _endpointTableManager.DeleteEndpoint(vertexName, key.Key);
                    }
                    foreach (var key in vertex.AsyncInputEndpoints)
                    {
                        _endpointTableManager.DeleteEndpoint(vertexName, key.Key);
                    }
                    foreach (var key in vertex.OutputEndpoints)
                    {
                        _endpointTableManager.DeleteEndpoint(vertexName, key.Key);
                    }
                    foreach (var key in vertex.AsyncOutputEndpoints)
                    {
                        _endpointTableManager.DeleteEndpoint(vertexName, key.Key);
                    }

                    IVertex old;
                    if (!table.TryRemove(vertexName, out old))
                    {
                        Console.WriteLine("Unable to remove vertex on disposal");
                    }
                    var entity  = new DynamicTableEntity(instanceName, vertexName);
                    entity.ETag = "*";
                    TableOperation deleteOperation = TableOperation.Delete(entity);
                    _vertexTable.ExecuteAsync(deleteOperation).Wait();
                });
            }


            string blobName = vertexName + "-" + instanceName;

            var    parametersBlob   = container.GetBlockBlobReference(vertexDefinition + "/" + blobName);
            Stream parametersStream = parametersBlob.OpenReadAsync().GetAwaiter().GetResult();

            byte[] parametersBytes = parametersStream.ReadByteArray();
            string parameterString = Encoding.UTF8.GetString(parametersBytes);

            parametersStream.Close();

            var par = SerializationHelper.DeserializeObject(parameterString);

            vertex.Initialize(par);
            await vertex.InitializeAsync(par);

            // Activate vertex
            ActivateVertex(vertexName, instanceName);

            return(vertex);
        }
コード例 #20
0
ファイル: VertexTable.cs プロジェクト: nlebeck/CRA
        internal static bool ContainsRow(CloudTable instanceTable, VertexTable entity)
        {
            var temp = GetAll(instanceTable);

            return(temp.Where(gn => entity.Equals(gn)).Count() > 0);
        }