internal static SMB2Command GetReadResponse(ReadRequest request, ISMBShare share, SMB2ConnectionState state)
{
SMB2Session session = state.GetSession(request.Header.SessionID);
OpenFileObject openFile = session.GetOpenFileObject(request.FileId);
if (openFile == null)
{
state.LogToServer(Severity.Verbose, "Read failed. Invalid FileId. (SessionID: {0}, TreeID: {1}, FileId: {2})", request.Header.SessionID, request.Header.TreeID, request.FileId.Volatile);
return(new ErrorResponse(request.CommandName, NTStatus.STATUS_FILE_CLOSED));
}
if (share is FileSystemShare)
{
if (!((FileSystemShare)share).HasReadAccess(session.SecurityContext, openFile.Path))
{
state.LogToServer(Severity.Verbose, "Read from '{0}{1}' failed. User '{2}' was denied access.", share.Name, openFile.Path, session.UserName);
return(new ErrorResponse(request.CommandName, NTStatus.STATUS_ACCESS_DENIED));
}
}
byte[] data;
NTStatus readStatus = share.FileStore.ReadFile(out data, openFile.Handle, (long)request.Offset, (int)request.ReadLength);
if (readStatus != NTStatus.STATUS_SUCCESS)
{
state.LogToServer(Severity.Verbose, "Read from '{0}{1}' failed. NTStatus: {2}. (FileId: {3})", share.Name, openFile.Path, readStatus, request.FileId.Volatile);
return(new ErrorResponse(request.CommandName, readStatus));
}
ReadResponse response = new ReadResponse();
response.Data = data;
return(response);
}
public ReadReply ReadHandler(ReadRequest request)
{
Partition partition = server.getPartition(request.ObjectKey.PartitionId);
int partitionClock = partition.getClock();
Console.WriteLine(">>> PartitionName=" + request.ObjectKey.PartitionId + ", PartitionClock=" + partitionClock);
ReadReply reply;
try
{
DataStoreValue value = partition.getData(new DataStoreKey(request.ObjectKey.PartitionId, request.ObjectKey.ObjectId));
reply = new ReadReply
{
Object = new DataStoreValueDto {
Val = value.val
},
ObjectExists = true,
PartitionClock = partitionClock
};
}
catch (Exception)
{
reply = new ReadReply
{
Object = new DataStoreValueDto {
Val = "NA"
},
ObjectExists = false,
PartitionClock = partitionClock
};
}
return(reply);
}
public static async Task <DataValue[]> ReadVar(int node, string[] VarNames)
{
try
{
ReadValueId[] valuesToRead = new ReadValueId[VarNames.Length];
for (int i = 0; i < VarNames.Length; i++)
{
valuesToRead[i] = new ReadValueId
{
// you can parse the nodeId from a string.
NodeId = NodeId.Parse("ns=" + node.ToString() + ";s=" + VarNames[i]),
// variable class nodes have a Value attribute.
AttributeId = AttributeIds.Value
};
}
var readRequest = new ReadRequest
{
NodesToRead = valuesToRead
};
// send the ReadRequest to the server.
var readResult = await channel.ReadAsync(readRequest);
return(readResult.Results);
}
catch (Exception ex)
{
//await channel.AbortAsync();
return(null);
}
}
public IPluginTestScenario Read(Action <ReadRequest> configureRead)
{
var readRequest = new ReadRequest();
configureRead(readRequest);
return(new RunReadJobScenario(_publisher, _configureRequest, readRequest));
}
public async Task StreamingRead()
{
// Snippet: StreamingRead(ReadRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument
ReadRequest request = new ReadRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Table = "",
Columns = { },
KeySet = new KeySet(),
};
// Make the request, returning a streaming response
SpannerClient.StreamingReadStream streamingResponse = spannerClient.StreamingRead(request);
// Read streaming responses from server until complete
IAsyncEnumerator <PartialResultSet> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
PartialResultSet response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
public ReadReply ReadHandler(ReadRequest request)
{
Partition partition = server.getPartition(request.ObjectKey.PartitionId);
ReadReply reply = null;
try
{
DataStoreValue value = partition.getData(new DataStoreKey(request.ObjectKey.PartitionId, request.ObjectKey.ObjectId));
reply = new ReadReply
{
Object = new DataStoreValueDto {
Val = value.val
},
ObjectExists = true
};
}
catch (Exception)
{
reply = new ReadReply
{
Object = new DataStoreValueDto {
Val = "NA"
},
ObjectExists = false
};
}
return(reply);
}
public override Task <ReadCrcResponse> ReadPpuCrc(ReadRequest request, ServerCallContext context)
{
var result = new ReadCrcResponse();
try
{
if (request.Length > 1)
{
Console.Write($"Reading CRC of 0x{request.Address:X4}-0x{request.Address + request.Length - 1:X4} @ PPU... ");
}
else
{
Console.Write($"Reading CRC of 0x{request.Address:X4} @ PPU... ");
}
result.Crc = dumper.ReadPpuCrc((ushort)request.Address, (ushort)request.Length);
Console.WriteLine($"{result.Crc:X4}");
}
catch (Exception ex)
{
PrintError(ex);
result.ErrorInfo = new ErrorInfo()
{
ExceptionName = ex.GetType().ToString(),
ExceptionMessage = ex.Message
};
}
return(Task.FromResult(result));
}
// Server side handler of the SayHello RPC
public override Task <ReadResponse> ReadOpcNodes(ReadRequest request, ServerCallContext context)
{
List <string> names = new List <string> {
};
foreach (var name in request.Names)
{
names.Add(name);
}
ReadStatusCode status;
var values = _services.readValueFromCache(names.ToArray(), out status);
ReadResponse r = new ReadResponse();
foreach (var variable in values)
{
NodeValue val = new NodeValue();
val.Name = variable.name;
val.Type = variable.systemType;
val.Value = variable.value.ToString();
val.Timestamp = variable.timestamp.ToUniversalTime().ToString("o");
r.Nodes.Add(val);
}
r.ErrorMessage = (status == ReadStatusCode.Ok) ? "none" : "Error";
r.IsError = (status != ReadStatusCode.Ok);
return(Task.FromResult(r));
}
public override Tuple Read(Tuple tuple)
{
var request = new ReadRequest(ClientRequestSeqNumber, EndpointURL, tuple);
Log("[SEQ:" + ClientRequestSeqNumber + "] Read: " + tuple);
return(SendBlockingRequest(request));
}
public void VisitRead(Read read)
{
ClientResponse clientResponse;
do
{
clientResponse = null;
ReadRequest readRequest = new ReadRequest(this.client.Id, this.client.GetRequestNumber(), read.Tuple);
while (clientResponse == null)
{
clientResponse = (ClientResponse)this.messageServiceClient.Request(
readRequest,
this.client.Leader,
Timeout.TIMEOUT_SMR_CLIENT);
if (clientResponse != null)
{
break;
}
this.client.DoHandShake();
}
if (clientResponse.Result == null)
{
Thread.Sleep(Timeout.TIMEOUT_SMR_CLIENT_WAIT);
}
} while (clientResponse.Result == null);
Console.WriteLine($"Read tuple = {clientResponse.Result}");
}
public NTStatus ReadFile(out byte[] data, object handle, long offset, int maxCount)
{
data = null;
ReadRequest request = new ReadRequest();
request.Header.CreditCharge = (ushort)Math.Ceiling((double)maxCount / BytesPerCredit);
request.FileId = (FileID)handle;
request.Offset = (ulong)offset;
request.ReadLength = (uint)maxCount;
TrySendCommand(request);
do
{
SMB2Command response = m_client.WaitForCommand(SMB2CommandName.Read);
if (response != null)
{
if (response.Header.Status == NTStatus.STATUS_SUCCESS && response is ReadResponse)
{
data = ((ReadResponse)response).Data;
}
else if (response.Header.Status == NTStatus.STATUS_PENDING)
{
continue;
}
return(response.Header.Status);
}
else
{
return(NTStatus.STATUS_INVALID_SMB);
}
} while (true);
}
public async Task Polling()
{
var channel = new UaTcpSessionChannel(
this.localDescription,
this.certificateStore,
new AnonymousIdentity(),
EndpointUrl,
loggerFactory: this.loggerFactory);
await channel.OpenAsync();
logger.LogInformation($"Opened session with endpoint '{channel.RemoteEndpoint.EndpointUrl}'.");
logger.LogInformation($"SecurityPolicy: '{channel.RemoteEndpoint.SecurityPolicyUri}'.");
logger.LogInformation($"SecurityMode: '{channel.RemoteEndpoint.SecurityMode}'.");
logger.LogInformation($"Activated session '{channel.SessionId}'.");
var readRequest = new ReadRequest { NodesToRead = new[] { new ReadValueId { NodeId = NodeId.Parse(VariableIds.Server_ServerStatus_CurrentTime), AttributeId = AttributeIds.Value } } };
for (int i = 0; i < 10; i++)
{
var readResult = await channel.ReadAsync(readRequest);
logger.LogInformation("Read {0}", readResult.Results[0].GetValueOrDefault<DateTime>());
await Task.Delay(1000);
}
logger.LogInformation($"Closing session '{channel.SessionId}'.");
await channel.CloseAsync();
}
public async Task Read()
{
var channel = new UaTcpSessionChannel(
this.localDescription,
this.certificateStore,
new AnonymousIdentity(),
EndpointUrl,
loggerFactory: this.loggerFactory);
await channel.OpenAsync();
logger.LogInformation($"Opened session with endpoint '{channel.RemoteEndpoint.EndpointUrl}'.");
logger.LogInformation($"SecurityPolicy: '{channel.RemoteEndpoint.SecurityPolicyUri}'.");
logger.LogInformation($"SecurityMode: '{channel.RemoteEndpoint.SecurityMode}'.");
logger.LogInformation($"Activated session '{channel.SessionId}'.");
var readRequest = new ReadRequest { NodesToRead = new[] { new ReadValueId { NodeId = NodeId.Parse(VariableIds.Server_ServerStatus), AttributeId = AttributeIds.Value } } };
var readResult = await channel.ReadAsync(readRequest);
var serverStatus = readResult.Results[0].GetValueOrDefault<ServerStatusDataType>();
logger.LogInformation("Server status:");
logger.LogInformation(" ProductName: {0}", serverStatus.BuildInfo.ProductName);
logger.LogInformation(" SoftwareVersion: {0}", serverStatus.BuildInfo.SoftwareVersion);
logger.LogInformation(" ManufacturerName: {0}", serverStatus.BuildInfo.ManufacturerName);
logger.LogInformation(" State: {0}", serverStatus.State);
logger.LogInformation(" CurrentTime: {0}", serverStatus.CurrentTime);
logger.LogInformation($"Closing session '{channel.SessionId}'.");
await channel.CloseAsync();
}
internal static async Task <Type> GetDataTypeFromNodeId(this UaSession session, NodeId nodeId)
{
var readRequest = new ReadRequest {
NodesToRead = { new ReadValueId {
NodeId = nodeId, AttributeId = Attributes.DataType
}, new ReadValueId{
NodeId = nodeId, AttributeId = Attributes.ValueRank
} }
};
var readResponse = await session.ReadAsync(readRequest);
var dataType = readResponse.Results[0].GetValue(NodeId.Null);
var valueRank = readResponse.Results[1].GetValue(-2);
var type = TypeInfo.GetSystemType(dataType, session.Factory);
if (type != null)
{
if (valueRank > 0)
{
return(type.MakeArrayType(valueRank));
}
return(type);
}
return(typeof(object));
}
public async Task SessionTimeoutCausesFault()
{
// discover available endpoints of server.
var getEndpointsRequest = new GetEndpointsRequest
{
EndpointUrl = EndpointUrl,
ProfileUris = new[] { TransportProfileUris.UaTcpTransport }
};
Console.WriteLine($"Discovering endpoints of '{getEndpointsRequest.EndpointUrl}'.");
var getEndpointsResponse = await UaTcpDiscoveryService.GetEndpointsAsync(getEndpointsRequest);
var selectedEndpoint = getEndpointsResponse.Endpoints.OrderBy(e => e.SecurityLevel).Last();
var selectedTokenType = selectedEndpoint.UserIdentityTokens[0].TokenType;
IUserIdentity selectedUserIdentity;
switch (selectedTokenType)
{
case UserTokenType.UserName:
selectedUserIdentity = new UserNameIdentity("root", "secret");
break;
default:
selectedUserIdentity = new AnonymousIdentity();
break;
}
var channel = new UaTcpSessionChannel(
this.localDescription,
this.certificateStore,
selectedUserIdentity,
selectedEndpoint,
loggerFactory: this.loggerFactory,
options: new UaTcpSessionChannelOptions {
SessionTimeout = 10000
});
await channel.OpenAsync();
Console.WriteLine($"Opened session with endpoint '{channel.RemoteEndpoint.EndpointUrl}'.");
Console.WriteLine($"SecurityPolicy: '{channel.RemoteEndpoint.SecurityPolicyUri}'.");
Console.WriteLine($"SecurityMode: '{channel.RemoteEndpoint.SecurityMode}'.");
Console.WriteLine($"Activated session '{channel.SessionId}'.");
// server should close session due to inactivity
await Task.Delay(20000);
// should throw exception
var readRequest = new ReadRequest {
NodesToRead = new[] { new ReadValueId {
NodeId = NodeId.Parse(VariableIds.Server_ServerStatus_CurrentTime), AttributeId = AttributeIds.Value
} }
};
await channel.ReadAsync(readRequest);
Console.WriteLine($"Closing session '{channel.SessionId}'.");
await channel.CloseAsync();
}
public async Task ReadStreamLimitTest()
{
// setup
Server server = new Server
{
Services = { Publisher.BindService(new PluginCampaigner.Plugin.Plugin()) },
Ports = { new ServerPort("localhost", 0, ServerCredentials.Insecure) }
};
server.Start();
var port = server.Ports.First().BoundPort;
var channel = new Channel($"localhost:{port}", ChannelCredentials.Insecure);
var client = new Publisher.PublisherClient(channel);
var schema = GetTestSchema();
var connectRequest = GetConnectSettings();
var schemaRequest = new DiscoverSchemasRequest
{
Mode = DiscoverSchemasRequest.Types.Mode.Refresh,
ToRefresh = { schema }
};
var request = new ReadRequest()
{
DataVersions = new DataVersions
{
JobId = "test"
},
JobId = "test",
Limit = 1
};
// act
client.Connect(connectRequest);
var schemasResponse = client.DiscoverSchemas(schemaRequest);
request.Schema = schemasResponse.Schemas[0];
var response = client.ReadStream(request);
var responseStream = response.ResponseStream;
var records = new List <Record>();
while (await responseStream.MoveNext())
{
records.Add(responseStream.Current);
}
// assert
Assert.Equal(1, records.Count);
// cleanup
await channel.ShutdownAsync();
await server.ShutdownAsync();
}
private ReadArguments ParseReadRequest(ReadRequest request)
{
return(new ReadArguments {
PartitionId = request.PartitionId,
ObjectId = request.ObjectId,
Timestamp = BuildVectorClock(request.Timestamp)
});
}
private AsyncUnaryCall <ReadReply> ClientReadAsync(ReadRequest request)
{
if (_isAdvanced)
{
return(_client.ReadAdvancedAsync(request));
}
return(_client.ReadAsync(request));
}
private void button2_Click(object sender, EventArgs e)
{
ReadRequest req = new ReadRequest("got back from server woo");
string temp = client.SendRequest <string>(req);
UsernameBox.AppendText(Environment.NewLine + temp);
}
public override Task <Data> Read(ReadRequest request, ServerCallContext context)
{
return(Task.FromResult(new Data
{
Offset = request.Offset,
Message = Google.Protobuf.ByteString.CopyFrom(_storage.Get(request.Offset))
}));
}
public static LogEntry For(ReadRequest request)
{
LogEntry entry = new LogEntry("ReadRequest");
entry.Add("RequestHeader", For(request.RequestHeader));
entry.Add("NodesToRead", For(request.NodesToRead));
return(entry);
}
public async Task ReadStreamTest()
{
// setup
Server server = new Server
{
Services = { Publisher.BindService(new Plugin.Plugin(GetMockHttpMessageHandler().ToHttpClient())) },
Ports = { new ServerPort("localhost", 0, ServerCredentials.Insecure) }
};
server.Start();
var port = server.Ports.First().BoundPort;
var channel = new Channel($"localhost:{port}", ChannelCredentials.Insecure);
var client = new Publisher.PublisherClient(channel);
var connectRequest = GetConnectSettings();
var request = new ReadRequest()
{
Schema = new Schema
{
Id = "[Customers.address]",
Properties =
{
new Property {
Id = "_id", Name = "_id", Type = PropertyType.Integer
},
new Property {
Id = "title", Name = "title", Type = PropertyType.String
}
},
Query = "query"
},
Limit = 2
};
// act
client.Connect(connectRequest);
var response = client.ReadStream(request);
var responseStream = response.ResponseStream;
var records = new List <Record>();
while (await responseStream.MoveNext())
{
records.Add(responseStream.Current);
}
// assert
Assert.Equal(5, records.Count);
// cleanup
await channel.ShutdownAsync();
await server.ShutdownAsync();
}
public async Task ReadStreamTableSchemaTest()
{
// setup
Server server = new Server
{
Services = { Publisher.BindService(new PluginDb2.Plugin.Plugin()) },
Ports = { new ServerPort("localhost", 0, ServerCredentials.Insecure) }
};
server.Start();
var port = server.Ports.First().BoundPort;
var channel = new Channel($"localhost:{port}", ChannelCredentials.Insecure);
var client = new Publisher.PublisherClient(channel);
var connectRequest = GetConnectSettings();
var request = new ReadRequest()
{
DataVersions = new DataVersions
{
JobId = "test"
},
JobId = "test",
};
// act
client.Connect(connectRequest);
var schemas = client.DiscoverSchemas(new DiscoverSchemasRequest());
request.Schema = schemas.Schemas.First();
var response = client.ReadStream(request);
var responseStream = response.ResponseStream;
var records = new List <Record>();
while (await responseStream.MoveNext())
{
records.Add(responseStream.Current);
}
// assert
Assert.Equal(1000, records.Count);
var record = JsonConvert.DeserializeObject <Dictionary <string, object> >(records[0].DataJson);
Assert.Equal((long)1, record["\"ID\""]);
Assert.Equal("Madison", record["\"FIRST_NAME\""]);
// cleanup
await channel.ShutdownAsync();
await server.ShutdownAsync();
}
public static async Task <bool> JobCompletedSuccessfullyAsync(HttpClient httpClient, int workspaceId, int imagingSetId)
{
bool jobComplete = false;
const int maxTimeInMilliseconds = (Constants.Waiting.MAX_WAIT_TIME_IN_MINUTES * 60 * 1000);
const int sleepTimeInMilliSeconds = Constants.Waiting.SLEEP_TIME_IN_SECONDS * 1000;
int currentWaitTimeInMilliseconds = 0;
Guid fieldGuid = Constants.Guids.Fields.ImagingSet.Status;
string url = $"Relativity.REST/api/Relativity.Objects/workspace/{workspaceId}/object/read";
ReadRequest readRequest = new ReadRequest
{
Request = new request
{
Object = new Models.RDO.Object
{
ArtifactID = imagingSetId
},
Fields = new[]
{
new field
{
Guid = fieldGuid.ToString()
}
}
}
};
string request = JsonConvert.SerializeObject(readRequest);
try
{
while (currentWaitTimeInMilliseconds < maxTimeInMilliseconds && jobComplete == false)
{
Thread.Sleep(sleepTimeInMilliSeconds);
HttpResponseMessage response = RESTConnectionManager.MakePost(httpClient, url, request);
string result = await response.Content.ReadAsStringAsync();
bool success = HttpStatusCode.OK == response.StatusCode;
if (!success)
{
throw new Exception("Failed to Check if the Job is Complete.");
}
JObject resultObject = JObject.Parse(result);
jobComplete = resultObject["Object"]["FieldValues"][0]["Value"].Value <string>().Contains("Complete");
currentWaitTimeInMilliseconds += sleepTimeInMilliSeconds;
}
return(jobComplete);
}
catch (Exception ex)
{
throw new Exception($@"Error Checking for Imaging Job Completion: {ex.ToString()}");
}
}
public void ReadRequests_are_forwarded_to_worker()
{
var o = new TestContainer(this);
var req = new ReadRequest(1, 1);
o.Reader.Tell(req);
o.ReadProbe.ExpectMsg <ReadRequest>(m => m == req);
}
public override Task <ReadReply> Read(ReadRequest req, ServerCallContext _)
{
man.CheckFreeze();
ReadReply reply = new ReadReply {
Val = store.Read(req.IdPart, req.IdObj)
};
Lib.Sleep(new Random().Next(minDelay, maxDelay));
return(Task.FromResult(reply));
}
void StartReadRequest()
{
var request = new ReadRequest(_globalSequence + 1, _options.EventsPerReadRequest);
_reader.Tell(request);
_requestedEvents = request.Count;
_lastRequestId = request.RequestID;
_readEvents = 0;
}
public void Reads_with_sequence_above_highest_sends_ReadFinished()
{
var reader = CreateReader();
var req = new ReadRequest(1000, EventCount.Unlimited);
reader.Tell(req);
ExpectMsg <ReadFinished>(m => m.RequestID == req.RequestID);
}
public void Reads_with_count_zero_sends_ReadFinished()
{
var reader = CreateReader();
var req = new ReadRequest(1, 0);
reader.Tell(req);
ExpectMsg <ReadFinished>(m => m.RequestID == req.RequestID);
}
public void ParsesReadRequest()
{
ReadRequest original = new ReadRequest("Hallo Welt.txt", TftpTransferMode.netascii, null);
CommandParser parser = new CommandParser();
ReadRequest parsed = (ReadRequest)parser.Parse(Serialize(original));
Assert.AreEqual(original.Filename, parsed.Filename);
Assert.AreEqual(original.Mode, parsed.Mode);
}
private async Task FetchNamespaceTablesAsync()
{
var readValueIds = new ReadValueId[]
{
new ReadValueId
{
NodeId = NodeId.Parse(VariableIds.Server_NamespaceArray),
AttributeId = AttributeIds.Value
},
new ReadValueId
{
NodeId = NodeId.Parse(VariableIds.Server_ServerArray),
AttributeId = AttributeIds.Value
}
};
var readRequest = new ReadRequest
{
NodesToRead = readValueIds
};
var readResponse = (ReadResponse)await this.RequestAsync(readRequest).ConfigureAwait(false);
if (readResponse.Results.Length == 2)
{
if (StatusCode.IsGood(readResponse.Results[0].StatusCode))
{
this.NamespaceUris.Clear();
this.NamespaceUris.AddRange(readResponse.Results[0].GetValueOrDefault<string[]>());
}
if (StatusCode.IsGood(readResponse.Results[1].StatusCode))
{
this.ServerUris.Clear();
this.ServerUris.AddRange(readResponse.Results[1].GetValueOrDefault<string[]>());
}
}
}
/// <summary>
/// Reads the item values and stores the results in the request object.
/// </summary>
/// <param name="requests">The requests.</param>
public void ReadItemValues(List<ReadRequest> requests)
{
ComDaGroup group = new ComDaGroup(this, false);
try
{
int count1 = 0;
GroupItem[] items = new GroupItem[requests.Count];
ReadRequest[] addItemRequests = new ReadRequest[requests.Count];
// create the items in the temporary group.
for (int ii = 0; ii < requests.Count; ii++)
{
ReadRequest request = requests[ii];
if (request == null)
{
continue;
}
if (!request.ValueRequired)
{
continue;
}
// add the item.
items[count1] = group.CreateItem(request.ItemId, 0, 0, true);
addItemRequests[count1] = request;
count1++;
}
// create the items on the server.
group.ApplyChanges();
// build the list of values to write.
int count2 = 0;
int[] serverHandles = new int[count1];
ReadRequest[] readRequests = new ReadRequest[count1];
for (int ii = 0; ii < count1; ii++)
{
// check for error on create.
GroupItem item = items[ii];
ReadRequest request = addItemRequests[ii];
if (item.ErrorId < 0)
{
request.Value.Error = item.ErrorId;
continue;
}
serverHandles[count2] = item.ServerHandle;
readRequests[count2] = request;
count2++;
}
// write values to the server.
DaValue[] values = group.SyncRead(serverHandles, count2);
// read the values.
for (int ii = 0; ii < count2; ii++)
{
readRequests[ii].Value = values[ii];
}
}
finally
{
// delete the group and items.
group.Delete();
}
}
/// <summary>
/// Begins an asynchronous invocation of the Read service.
/// </summary>
public IAsyncResult BeginRead(
RequestHeader requestHeader,
double maxAge,
TimestampsToReturn timestampsToReturn,
ReadValueIdCollection nodesToRead,
AsyncCallback callback,
object asyncState)
{
ReadRequest request = new ReadRequest();
request.RequestHeader = requestHeader;
request.MaxAge = maxAge;
request.TimestampsToReturn = timestampsToReturn;
request.NodesToRead = nodesToRead;
UpdateRequestHeader(request, requestHeader == null, "Read");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginRead(new ReadMessage(request), callback, asyncState);
}
public ReadResults Read(ReadRequest readRequest)
{
bool hasMoreItems = false;
var msgs = new List<OutgoingMessage>();
var realPageSize = Math.Min(configuration.MaxPageSize, readRequest.PageSize);
// have to be a separate tranasction, so the next read will get it
// we expect that most of the time this is a no op, because there won't be any expired messages
// this also follows the rule of only making the change when it is actually happening, so
// until you read, there isn't any activity in the system
transactionalStorage.Batch(actions => actions.Messages.ResetExpiredMessages());
transactionalStorage.Batch(actions =>
{
var outgoingMessage = actions.Messages.Dequeue(readRequest.Queue, readRequest.LastMessageId);
while (outgoingMessage != null && msgs.Count < realPageSize)
{
if(ShouldConsumeMessage(outgoingMessage.Expiry,outgoingMessage.Queue))
{
actions.Messages.HideMessageFor(outgoingMessage.Id, readRequest.HideTimeout);
}
if (ShouldIncludeMessage(outgoingMessage))
{
var buffer = outgoingMessage.Data;
var memoryStream = new MemoryStream(buffer);
outgoingMessage.Metadata = memoryStream.ToJObject();
outgoingMessage.Data = new byte[outgoingMessage.Data.Length - memoryStream.Position];
Array.Copy(buffer, memoryStream.Position, outgoingMessage.Data, 0, outgoingMessage.Data.Length);
msgs.Add(outgoingMessage);
}
outgoingMessage = actions.Messages.Dequeue(readRequest.Queue, outgoingMessage.Id);
}
hasMoreItems = outgoingMessage != null;
});
return new ReadResults
{
HasMoreResults = hasMoreItems,
Results = msgs,
Queue = readRequest.Queue
};
}
public ReadCommand()
{
ReadRequest = new ReadRequest();
}
/// <summary>
/// Queues the value to the monitored item.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <param name="monitoredItem">The monitored item.</param>
public void QueueValue(ServerSystemContext context, ReadRequest request, MonitoredItem monitoredItem)
{
NodeHandle handle = monitoredItem.ManagerHandle as NodeHandle;
if (handle == null)
{
return;
}
ReadValueId nodeToRead = monitoredItem.GetReadValueId();
DataValue value = new DataValue();
ServiceResult error = null;
// read item value.
DaItemState item = handle.Node as DaItemState;
DaPropertyState daProperty = handle.Node as DaPropertyState;
PropertyState uaProperty = handle.Node as PropertyState;
if (item != null)
{
error = request.GetResult(context, item, nodeToRead, value, monitoredItem.DiagnosticsMasks);
}
// read vendor defined property value.
else if (daProperty != null)
{
error = request.GetResult(context, daProperty, nodeToRead, value, monitoredItem.DiagnosticsMasks);
}
// read UA defined property value.
else if (uaProperty != null)
{
error = request.GetResult(context, uaProperty, nodeToRead, value, monitoredItem.DiagnosticsMasks);
}
value.ServerTimestamp = DateTime.UtcNow;
if (value.StatusCode != StatusCodes.BadNotFound)
{
monitoredItem.QueueValue(value, error);
}
else
{
monitoredItem.QueueValue(value, StatusCodes.BadNodeIdUnknown);
}
}
/// <summary>
/// Queues the value to the monitored item.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
public void QueueValues(ServerSystemContext context, ReadRequest request)
{
for (int ii = 0; ii < m_monitoredItems.Count; ii++)
{
QueueValue(context, request, m_monitoredItems[ii]);
}
m_lastRequest = request;
IncrementSampleTime();
}
/// <summary>
/// Called when the scan properties timer expires.
/// </summary>
private void OnScanProperties(object state)
{
try
{
ComDaClientManager system = (ComDaClientManager)m_context.SystemHandle;
ComDaClient client = (ComDaClient)system.GetLocalizedClient(this.UserIdentity, this.LocaleId);
// collect the list of properties that need reading.
List<SubscribePropertyRequest> requests1 = new List<SubscribePropertyRequest>();
List<ReadRequest> requests2 = new List<ReadRequest>();
lock (m_lock)
{
DateTime now = DateTime.UtcNow;
foreach (SubscribePropertyRequest request1 in m_subscribedProperties.Values)
{
if (request1.NextUpdateTime <= now)
{
requests1.Add(request1);
ReadRequest request2 = new ReadRequest(request1.ItemId);
request2.AddProperty(request1.PropertyIds);
requests2.Add(request2);
}
}
}
// read the properties from teh server.
client.ReadPropertyValues(requests2);
// update the monitored items.
lock (m_lock)
{
for (int ii = 0; ii < requests1.Count; ii++)
{
requests1[ii].QueueValues(m_context, requests2[ii]);
}
}
}
catch (Exception e)
{
Utils.Trace(e, "Unexpected error scanning properties in DA COM server.");
}
}
/// <summary>
/// Invokes the Read service.
/// </summary>
public virtual ResponseHeader Read(
RequestHeader requestHeader,
double maxAge,
TimestampsToReturn timestampsToReturn,
ReadValueIdCollection nodesToRead,
out DataValueCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
ReadRequest request = new ReadRequest();
ReadResponse response = null;
request.RequestHeader = requestHeader;
request.MaxAge = maxAge;
request.TimestampsToReturn = timestampsToReturn;
request.NodesToRead = nodesToRead;
UpdateRequestHeader(request, requestHeader == null, "Read");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (ReadResponse)genericResponse;
}
else
{
ReadResponseMessage responseMessage = InnerChannel.Read(new ReadMessage(request));
if (responseMessage == null || responseMessage.ReadResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.ReadResponse;
ValidateResponse(response.ResponseHeader);
}
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "Read");
}
return response.ResponseHeader;
}
/// <summary>
/// Reads the item values and stores the results in the request object.
/// </summary>
/// <param name="requests">The requests.</param>
private void Da20ReadItemValues(List<ReadRequest> requests)
{
// lock (m_groupLock)
{
// if (m_group == null)
//{
ComDaGroup m_group = new ComDaGroup(this, false);
//}
try
{
int count1 = 0;
GroupItem[] items = new GroupItem[requests.Count];
ReadRequest[] addItemRequests = new ReadRequest[requests.Count];
// create the items in the temporary group.
for (int ii = 0; ii < requests.Count; ii++)
{
ReadRequest request = requests[ii];
if (request == null)
{
continue;
}
if (!request.ValueRequired)
{
continue;
}
// add the item.
items[count1] = m_group.CreateItem(request.ItemId, 0, 0, true);
addItemRequests[count1] = request;
count1++;
}
// create the items on the server.
m_group.ApplyChanges();
// build the list of values to write.
int count2 = 0;
int[] serverHandles = new int[count1];
ReadRequest[] readRequests = new ReadRequest[count1];
for (int ii = 0; ii < count1; ii++)
{
// check for error on create.
GroupItem item = items[ii];
ReadRequest request = addItemRequests[ii];
if (item.ErrorId < 0)
{
request.Value = new DaValue();
request.Value.Error = item.ErrorId;
continue;
}
serverHandles[count2] = item.ServerHandle;
readRequests[count2] = request;
count2++;
}
if (count2 > 0)
{
// write values to the server.
DaValue[] values = m_group.SyncRead(serverHandles, count2);
// read the values.
for (int ii = 0; ii < count2; ii++)
{
if (values != null && values.Length > ii)
{
readRequests[ii].Value = values[ii];
}
else
{
readRequests[ii].Value = new DaValue() { Error = ResultIds.E_FAIL, Timestamp = DateTime.UtcNow };
}
}
// delete the items.
for (int ii = 0; ii < count1; ii++)
{
GroupItem item = items[ii];
if (item.ErrorId >= 0)
{
m_group.RemoveItem(item);
}
}
m_group.ApplyChanges();
}
}
finally
{
// delete the group and items.
m_group.Delete();
}
}
}
/// <summary>
/// Initializes the message with the body.
/// </summary>
public ReadMessage(ReadRequest ReadRequest)
{
this.ReadRequest = ReadRequest;
}
