public void Remove(ID key)
{
lock (this.m_Entries)
{
this.m_Entries.RemoveAll(x => x.Key == key);
}
}
public IEnumerable<LiveEntry> Find(ID key)
{
lock (this.m_Entries)
{
return this.m_Entries.Where(x => x.Key == key).ToArray();
}
}
public LiveEntry GetFirst(ID key, int timeout)
{
var cached = this.m_ObjectStorage.Find(key).FirstOrDefault();
if (cached != null)
{
return cached;
}
if (this.m_LocalNode.Architecture == Architecture.ServerClient && this.m_LocalNode.IsServer)
{
// In the server-client architecture, the server will never ask remote clients whether
// they have an object since the server is the authority on all things. If the server
// doesn't have an object in it's storage, then it doesn't exist in the network.
return null;
}
var fetchMessage = this.m_MessageConstructor.ConstructFetchMessage(key);
var waitFor = new List<IPEndPoint>();
foreach (var kv in this.m_ClientLookup.GetAll())
{
if (object.Equals(kv.Key, this.m_LocalNode.Self.IPEndPoint))
{
continue;
}
kv.Value.Send(fetchMessage);
waitFor.Add(kv.Key);
}
var start = DateTime.Now;
// Wait until all contacts have responded, the timeout is up or we have an entry.
while (
(DateTime.Now - start).TotalMilliseconds < timeout &&
waitFor.Count > 0 &&
this.m_ObjectStorage.Find(key).FirstOrDefault() == null)
{
foreach (var endpoint in waitFor.ToArray())
{
var endpointCopy = endpoint;
if (this.m_MessageSideChannel.Has(x =>
x.Type == MessageType.FetchResult &&
x.FetchKey == key && object.Equals(x.Sender.IPAddress, endpointCopy.Address)
&& x.Sender.Port == endpointCopy.Port))
{
waitFor.Remove(endpoint);
}
}
Thread.Sleep(0);
}
return this.m_ObjectStorage.Find(key).FirstOrDefault();
}
/// <summary>
/// Construct a "fetch" message.
/// </summary>
/// <param name="key">
/// The key.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructFetchMessage(ID key)
{
return new Message { ID = ID.NewRandom(), Type = MessageType.Fetch, FetchKey = key };
}
/// <summary>
/// Construct a "set property" message.
/// </summary>
/// <param name="objectID">
/// The object id.
/// </param>
/// <param name="property">
/// The property.
/// </param>
/// <param name="value">
/// The value.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructSetPropertyMessage(ID objectID, string property, object value)
{
return new Message
{
ID = ID.NewRandom(),
Type = MessageType.SetProperty,
SetPropertyObjectID = objectID,
SetPropertyPropertyName = property,
SetPropertyPropertyValue = this.m_ObjectWithTypeSerializer.Serialize(value)
};
}
/// <summary>
/// Construct a "set property confirmation" message.
/// </summary>
/// <param name="messageID">
/// The message id.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructSetPropertyConfirmationMessage(ID messageID)
{
return new Message
{
ID = ID.NewRandom(),
Type = MessageType.SetPropertyConfirmation,
SetPropertyMessageID = messageID
};
}
/// <summary>
/// Construct an "invoke result" message.
/// </summary>
/// <param name="messageID">
/// The message id.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructInvokeResultMessage(ID messageID, object result)
{
return new Message
{
ID = ID.NewRandom(),
Type = MessageType.InvokeResult,
InvokeMessageID = messageID,
InvokeResult = this.m_ObjectWithTypeSerializer.Serialize(result)
};
}
/// <summary>
/// Construct an "invoke" message.
/// </summary>
/// <param name="objectID">
/// The object id.
/// </param>
/// <param name="method">
/// The method.
/// </param>
/// <param name="typeArguments">
/// The type arguments.
/// </param>
/// <param name="arguments">
/// The arguments.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructInvokeMessage(ID objectID, string method, Type[] typeArguments, object[] arguments)
{
return new Message
{
ID = ID.NewRandom(),
Type = MessageType.Invoke,
InvokeObjectID = objectID,
InvokeMethod = method,
InvokeTypeArguments = typeArguments.Select(x => x.AssemblyQualifiedName).ToArray(),
InvokeArguments = arguments.Select(x => this.m_ObjectWithTypeSerializer.Serialize(x)).ToArray()
};
}
/// <summary>
/// Construct a "get property result" message.
/// </summary>
/// <param name="messageID">
/// The message id.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructGetPropertyResultMessage(ID messageID, object result)
{
return new Message
{
ID = ID.NewRandom(),
Type = MessageType.GetPropertyResult,
GetPropertyMessageID = messageID,
GetPropertyResult = this.m_ObjectWithTypeSerializer.Serialize(result)
};
}
/// <summary>
/// Construct a "get property" message.
/// </summary>
/// <param name="objectID">
/// The object id.
/// </param>
/// <param name="property">
/// The property.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructGetPropertyMessage(ID objectID, string property)
{
return new Message
{
ID = ID.NewRandom(),
Type = MessageType.GetProperty,
GetPropertyObjectID = objectID,
GetPropertyPropertyName = property
};
}
/// <summary>
/// Construct a "fetch confirmation" message.
/// </summary>
/// <param name="key">
/// The key.
/// </param>
/// <param name="results">
/// The results.
/// </param>
/// <returns>
/// The <see cref="Message"/>.
/// </returns>
public Message ConstructFetchResultMessage(ID key, SerializedEntry[] results)
{
if (results == null)
{
throw new ArgumentNullException("results");
}
return new Message
{
ID = ID.NewRandom(),
Type = MessageType.FetchResult,
FetchKey = key,
FetchResult = results
};
}
