/// <summary> /// Retrieve a stream connection from a pool of available connections /// </summary> /// <param name="address"> IPAddress of the machine that this CRA client wants to connect to</param> /// <param name="port"> Port number of the CRA entity that this CRA client wants to connect to</param> /// <param name="stream"> A network sender stream that connects this CRA client to the other CRA entity</param> /// <returns>A boolean indicates whether the retrieval operation is successful or not</returns> internal bool TryGetSenderStreamFromPool(string address, string port, out Stream stream) { StreamConnectionPool connectionsPool; StreamConnection streamConnection; if (StreamConnectionPools.TryGetValue(address + ":" + port, out connectionsPool) && connectionsPool.Get(out streamConnection)) { stream = (NetworkStream)streamConnection.Stream; stream.WriteInt32((int)CRATaskMessageType.PING); CRAErrorCode result = (CRAErrorCode)stream.ReadInt32(); if (result != 0) { return(false); } return(true); } else { stream = null; return(false); } }
private static bool DeployShuffleReduceTask(CRAClientLibrary client, ShuffleTask task, OperatorsToplogy topology) { try { client.DefineVertex(typeof(ShuffleOperator).Name.ToLower(), () => new ShuffleOperator()); CRAErrorCode status = client.InstantiateShardedVertex(task.ReducerVertexName, typeof(ShuffleOperator).Name.ToLower(), task, task.DeployDescriptor.InstancesMap()); if (status == CRAErrorCode.Success) { foreach (string fromInputId in task.SecondaryEndpointsDescriptor.FromInputs.Keys) { client.ConnectShardedVertices(task.VerticesConnectionsMap[fromInputId + task.OutputId]); } var fromInput = task.EndpointsDescriptor.FromInputs.First().Key; var newFromInputId = fromInput.Substring(0, fromInput.Length - 1); client.ConnectShardedVertices(task.VerticesConnectionsMap[newFromInputId + task.ReducerVertexName]); return(true); } else { return(false); } } catch (Exception) { Console.WriteLine("Error in deploying a sharded CRA shuffle mapper task. Please, double check your task configurations"); return(false); } }
public static bool DeploySubscribeTask(CRAClientLibrary client, SubscribeTask task, OperatorsToplogy topology) { try { client.DefineVertex(typeof(SubscribeOperator).Name.ToLower(), () => new SubscribeOperator()); CRAErrorCode status = client.InstantiateShardedVertex(task.OutputId, typeof(SubscribeOperator).Name.ToLower(), task, task.DeployDescriptor.InstancesMap()); if (status == CRAErrorCode.Success) { foreach (string fromInputId in task.EndpointsDescriptor.FromInputs.Keys) { client.ConnectShardedVertices(task.VerticesConnectionsMap[fromInputId + task.OutputId]); } return(true); } else { return(false); } } catch (Exception e) { Console.WriteLine("Error in deploying a sharded CRA Subscribe task. Please, double check your task configurations: " + e.ToString()); return(false); } }
/// <summary> /// Connect a set of vertices in one sharded CRA vertex to another with a full mesh toplogy, via pre-defined endpoints. We contact the "from" vertex /// to initiate the creation of the link. /// </summary> /// <param name="fromVerticesNames"></param> /// <param name="fromEndpoints"></param> /// <param name="toVerticesNames"></param> /// <param name="toEndpoints"></param> /// <param name="direction"></param> /// <returns></returns> public CRAErrorCode ConnectShardedVerticesWithFullMesh( string[] fromVerticesNames, string[] fromEndpoints, string[] toVerticesNames, string[] toEndpoints, ConnectionInitiator direction) { // Check if the number of output endpoints in any fromVertex is equal to // the number of toVertices if (fromEndpoints.Length != toVerticesNames.Length) { return(CRAErrorCode.VerticesEndpointsNotMatched); } // Check if the number of input endpoints in any toVertex is equal to // the number of fromVertices if (toEndpoints.Length != fromVerticesNames.Length) { return(CRAErrorCode.VerticesEndpointsNotMatched); } //Connect the sharded vertices in parallel List <Task <CRAErrorCode> > tasks = new List <Task <CRAErrorCode> >(); for (int i = 0; i < fromEndpoints.Length; i++) { for (int j = 0; j < fromVerticesNames.Length; j++) { int fromEndpointIndex = i; int fromVertexIndex = j; tasks.Add(ConnectAsync(fromVerticesNames[fromVertexIndex], fromEndpoints[fromEndpointIndex], toVerticesNames[fromEndpointIndex], toEndpoints[fromVertexIndex], direction)); } } CRAErrorCode[] results = Task.WhenAll(tasks.ToArray()).Result; //Check for the status of connected vertices CRAErrorCode result = CRAErrorCode.VertexEndpointNotFound; for (int i = 0; i < results.Length; i++) { if (results[i] != CRAErrorCode.Success) { Console.WriteLine("We received an error code " + results[i] + " while vertexing the connection pair with number (" + i + ")"); result = results[i]; } else { result = CRAErrorCode.Success; } } if (result != CRAErrorCode.Success) { Console.WriteLine("All CRA instances appear to be down. Restart them and connect these two sharded vertices again!"); } return(result); }
private Stream Connect_InitiatorSide(string fromVertexName, string fromVertexOutput, string toVertexName, string toVertexInput, bool reverse) { bool killRemote = true; // we have no way of receiving connections var _vertexTableManager = _clientLibrary._vertexTableManager; // Need to get the latest address & port var row = reverse ? _vertexTableManager.GetRowForActiveVertex(fromVertexName) : _vertexTableManager.GetRowForActiveVertex(toVertexName); var _row = _vertexTableManager.GetRowForInstance(row.InstanceName); // Send request to CRA instance Stream ns = null; try { if (!_clientLibrary.TryGetSenderStreamFromPool(_row.Address, _row.Port.ToString(), out ns)) { TcpClient client = new TcpClient(_row.Address, _row.Port); client.NoDelay = true; ns = _clientLibrary.SecureStreamConnectionDescriptor .CreateSecureClient(client.GetStream(), row.InstanceName); } } catch { return(null); } 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("Client received error code: " + result); ns.Dispose(); return(null); } else { return(ns); } }
/// <summary> /// Instantiate a sharded vertex on a set of CRA instances. /// </summary> /// <param name="vertexName">Name of the sharded vertex (particular instance)</param> /// <param name="vertexDefinition">Definition of the vertex (type)</param> /// <param name="vertexParameter">Parameters to be passed to each vertex of the sharded vertex in its constructor (serializable object)</param> /// <param name="vertexShards"> A map that holds the number of vertices from a sharded vertex needs to be instantiated for each CRA instance </param> /// <returns>Status of the command</returns> public CRAErrorCode InstantiateVertex(string[] instanceNames, string vertexName, string vertexDefinition, object vertexParameter, int numShardsPerInstance = 1, Expression <Func <int, int> > shardLocator = null) { var allInstances = new List <string>(); var allShards = new List <int>(); var addedShards = new List <int>(); var removedShards = new List <int>(); Task <CRAErrorCode>[] tasks = new Task <CRAErrorCode> [instanceNames.Length * numShardsPerInstance]; int index = 0; foreach (var instanceName in instanceNames) { for (int c = 0; c < numShardsPerInstance; c++) { allInstances.Add(instanceName); allShards.Add(index); addedShards.Add(index); tasks[index] = InstantiateShardedVertexAsync (instanceName, vertexName + "$" + index, vertexDefinition, new Tuple <int, object>(index, vertexParameter)); index++; } } _shardedVertexTableManager.DeleteShardedVertex(vertexName); _shardedVertexTableManager.RegisterShardedVertex(vertexName, allInstances, allShards, addedShards, removedShards, shardLocator); CRAErrorCode[] results = Task.WhenAll(tasks).Result; // Check for the status of instantiated vertices CRAErrorCode result = CRAErrorCode.ConnectionEstablishFailed; for (int i = 0; i < results.Length; i++) { if (results[i] != CRAErrorCode.Success) { Console.WriteLine("We received an error code " + results[i] + " from one CRA instance while instantiating the vertex " + vertexName + "$" + i + " in the sharded vertex"); result = results[i]; } else { result = CRAErrorCode.Success; } } if (result != CRAErrorCode.Success) { Console.WriteLine("All CRA instances appear to be down. Restart them and this sharded vertex will be automatically instantiated"); } return(result); }
private void ConnectVertex_Initiator(object streamObject, bool reverse = false) { var stream = (Stream)streamObject; string fromVertexName = Encoding.UTF8.GetString(stream.ReadByteArray()); string fromVertexOutput = Encoding.UTF8.GetString(stream.ReadByteArray()); string toVertexName = Encoding.UTF8.GetString(stream.ReadByteArray()); string toVertexInput = Encoding.UTF8.GetString(stream.ReadByteArray()); Debug.WriteLine("Processing request to initiate connection"); if (!reverse) { if (!_localVertexTable.ContainsKey(fromVertexName)) { stream.WriteInt32((int)CRAErrorCode.VertexNotFound); Task.Run(() => TryReuseReceiverStream(stream)); return; } var key = GetShardedVertexName(fromVertexOutput); if (!_localVertexTable[fromVertexName].OutputEndpoints.ContainsKey(key) && !_localVertexTable[fromVertexName].AsyncOutputEndpoints.ContainsKey(key) ) { stream.WriteInt32((int)CRAErrorCode.VertexInputNotFound); Task.Run(() => TryReuseReceiverStream(stream)); return; } } else { if (!_localVertexTable.ContainsKey(toVertexName)) { stream.WriteInt32((int)CRAErrorCode.VertexNotFound); Task.Run(() => TryReuseReceiverStream(stream)); return; } if (!_localVertexTable[toVertexName].InputEndpoints.ContainsKey(toVertexInput) && !_localVertexTable[toVertexName].AsyncInputEndpoints.ContainsKey(toVertexInput) ) { stream.WriteInt32((int)CRAErrorCode.VertexInputNotFound); Task.Run(() => TryReuseReceiverStream(stream)); return; } } CRAErrorCode result = Connect_InitiatorSide(fromVertexName, fromVertexOutput, toVertexName, toVertexInput, reverse); stream.WriteInt32((int)result); Task.Run(() => TryReuseReceiverStream(stream)); }
/// <summary> /// Instantiate a sharded vertex on a set of CRA instances. /// </summary> /// <param name="vertexName">Name of the sharded vertex (particular instance)</param> /// <param name="vertexDefinition">Definition of the vertex (type)</param> /// <param name="vertexParameter">Parameters to be passed to each vertex of the sharded vertex in its constructor (serializable object)</param> /// <param name="vertexShards"> A map that holds the number of vertices from a sharded vertex needs to be instantiated for each CRA instance </param> /// <returns>Status of the command</returns> public CRAErrorCode InstantiateShardedVertex <VertexParameterType>(string vertexName, string vertexDefinition, VertexParameterType vertexParameter, ConcurrentDictionary <string, int> vertexShards) { int verticesCount = CountVertexShards(vertexShards); Task <CRAErrorCode>[] tasks = new Task <CRAErrorCode> [verticesCount]; int currentCount = 0; foreach (var key in vertexShards.Keys) { for (int i = currentCount; i < currentCount + vertexShards[key]; i++) { int threadIndex = i; string currInstanceName = key; tasks[threadIndex] = InstantiateShardedVertexAsync(currInstanceName, ShardName(vertexName, threadIndex), vertexDefinition, new Tuple <int, VertexParameterType>(threadIndex, vertexParameter)); } currentCount += vertexShards[key]; } CRAErrorCode[] results = Task.WhenAll(tasks).Result; // Check for the status of instantiated vertices CRAErrorCode result = CRAErrorCode.ConnectionEstablishFailed; for (int i = 0; i < results.Length; i++) { if (results[i] != CRAErrorCode.Success) { Console.WriteLine("We received an error code " + results[i] + " from one CRA instance while instantiating the vertex " + vertexName + "$" + i + " in the sharded vertex"); result = results[i]; } else { result = CRAErrorCode.Success; } } if (result != CRAErrorCode.Success) { Console.WriteLine("All CRA instances appear to be down. Restart them and this sharded vertex will be automatically instantiated"); } return(result); }
public static bool DeployProduceTask(CRAClientLibrary client, ProduceTask task) { try { client.DefineVertex(typeof(ProducerOperator).Name.ToLower(), () => new ProducerOperator()); CRAErrorCode status = client.InstantiateShardedVertex(task.OutputId, typeof(ProducerOperator).Name.ToLower(), task, task.DeployDescriptor.InstancesMap()); if (status == CRAErrorCode.Success) { return(true); } else { return(false); } } catch (Exception e) { Console.WriteLine("Error in deploying a sharded CRA produce task. Please, double check your task configurations: " + e.ToString()); return(false); } }
/// <summary> /// Connect a set of (fromVertex, outputEndpoint) pairs to another set of (toVertex, inputEndpoint) pairs. We contact the "from" vertex /// to initiate the creation of the link. /// </summary> /// <param name="fromToConnections"></param> /// <returns></returns> public CRAErrorCode ConnectShardedVertices(List <ConnectionInfoWithLocality> fromToConnections) { Task <CRAErrorCode>[] tasks = new Task <CRAErrorCode> [fromToConnections.Count]; int i = 0; foreach (var fromToConnection in fromToConnections) { int fromToEndpointIndex = i; var currentFromToConnection = fromToConnection; tasks[fromToEndpointIndex] = ConnectAsync(currentFromToConnection.FromVertex, currentFromToConnection.FromEndpoint, currentFromToConnection.ToVertex, currentFromToConnection.ToEndpoint, ConnectionInitiator.FromSide); i++; } CRAErrorCode[] results = Task.WhenAll(tasks).Result; CRAErrorCode result = CRAErrorCode.VertexEndpointNotFound; for (i = 0; i < results.Length; i++) { if (results[i] != CRAErrorCode.Success) { Console.WriteLine("We received an error code " + results[i] + " while vertexing the connection pair with number (" + i + ")"); result = results[i]; } else { result = CRAErrorCode.Success; } } if (result != CRAErrorCode.Success) { Console.WriteLine("All CRA instances appear to be down. Restart them and connect these two sharded vertices again!"); } return(result); }
internal async Task <CRAErrorCode> Connect_InitiatorSide( string fromVertexName, string fromVertexOutput, string toVertexName, string toVertexInput, bool reverse, bool sharding = true, bool killIfExists = true, bool killRemote = true) { VertexInfo row; try { // Need to get the latest address & port row = (await(reverse ? _vertexInfoProvider.GetRowForActiveVertex(fromVertexName) : _vertexInfoProvider.GetRowForActiveVertex(toVertexName))).Value; } 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 = (await _vertexInfoProvider.GetRowForInstanceVertex(row.InstanceName, "")) .Value; try { // Get a stream connection from the pool if available if (!_craClient.TryGetSenderStreamFromPool(_row.Address, _row.Port.ToString(), out ns)) { var client = new TcpClient(); client.NoDelay = true; if (!client.ConnectAsync(_row.Address, _row.Port).Wait(_tcpConnectTimeoutMs)) { throw new Exception("Failed to connect."); } 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)) { var tmp = Task.Run(() => EgressToStream( fromVertexName, fromVertexOutput, toVertexName, toVertexInput, reverse, ns, source, _row.Address, _row.Port, sharding)); 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)) { var tmp = Task.Run(() => IngressFromStream( fromVertexName, fromVertexOutput, toVertexName, toVertexInput, reverse, ns, source, _row.Address, _row.Port, sharding)); return(CRAErrorCode.Success); } else { source.Dispose(); ns.Close(); Debug.WriteLine("Race adding connection - deleting outgoing stream"); return(CRAErrorCode.ConnectionAdditionRace); } } } }
/// <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); }
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); }
internal async Task <CRAErrorCode> InstantiateVertexAsync( string instanceName, string vertexName, string vertexDefinition, object vertexParameter, bool sharded) { var procDefRow = await _vertexManager.VertexInfoProvider.GetRowForVertexDefinition(vertexDefinition); string blobName = vertexName + "-" + instanceName; using (var blobStream = await _blobStorage.GetWriteStream(vertexDefinition + "/" + blobName)) { byte[] parameterBytes = Encoding.UTF8.GetBytes( SerializationHelper.SerializeObject(vertexParameter)); blobStream.WriteByteArray(parameterBytes); } var newInfo = new VertexInfo( instanceName: instanceName, address: "", port: 0, vertexName: vertexName, vertexDefinition: vertexDefinition, vertexCreateAction: procDefRow.Value.VertexCreateAction, vertexParameter: blobName, isActive: false, isSharded: sharded); await _vertexManager.VertexInfoProvider.InsertOrReplace(newInfo); CRAErrorCode result = CRAErrorCode.Success; // Send request to CRA instance VertexInfo instanceRow; try { instanceRow = (await _vertexManager.GetRowForInstance(instanceName)).Value; // 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(newInfo.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); }