protected Notify(Dictionary<String, Object> attributes,
bool deliverInsecure,
Keys keys)
{
this.attributes = attributes;
this.deliverInsecure = deliverInsecure;
this.keys = keys;
}
public UNotify(int clientMajorVersion,
int clientMinorVersion,
Dictionary<String, Object> attributes,
bool deliverInsecure,
Keys keys)
: base(attributes, deliverInsecure, keys)
{
this.clientMajorVersion = clientMajorVersion;
this.clientMinorVersion = clientMinorVersion;
}
/// <summary>
///
/// </summary>
/// <param name="elvin"></param>
/// <param name="subscriptionExpr"></param>
/// <param name="secureMode"></param>
/// <param name="keys"></param>
/// <exception cref="ArgumentException">subscriptionExpr is null or empty</exception>
public Subscription(Elvin elvin, String subscriptionExpr, SecureMode secureMode, Keys keys)
{
if (keys == null) throw new ArgumentNullException("keys");
if (secureMode == null) throw new ArgumentNullException("secureMode");
this.Elvin = elvin;
this.SubscriptionExpr = checkSubscription(subscriptionExpr);
this.SecureMode = secureMode;
this.Keys = keys;
}
public void addRemove()
{
Keys keys = new Keys();
keys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key 1"));
keys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("dual key 2"));
keys.Add(KeyScheme.Sha1Producer, new Key("producer key 1"));
keys.Add(KeyScheme.Sha1Consumer, new Key("consumer key 1"));
DualKeySet dualKeys = keys.KeysetFor(KeyScheme.Sha1Dual);
Assert.AreEqual(1, dualKeys.ConsumerKeys.Count);
Assert.AreEqual(1, dualKeys.ProducerKeys.Count);
keys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key 3"));
Assert.AreEqual(2, keys.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
keys.Remove(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key 3"));
Assert.AreEqual(1, keys.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
keys.Remove(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key 1"));
Assert.AreEqual(0, keys.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
// remove a non-existent key, check nothing Bad happens
keys.Remove(KeyScheme.Sha1Consumer, new Key("blah"));
keys.Remove(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("dual key 2"));
Assert.AreEqual(0, keys.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
SingleKeySet consumerKeys = keys.KeysetFor(KeyScheme.Sha1Consumer);
Assert.AreEqual(1, consumerKeys.Count);
keys.Remove(KeyScheme.Sha1Consumer, new Key("consumer key 1"));
Assert.AreEqual(0, consumerKeys.Count);
SingleKeySet producerKeys = keys.KeysetFor(KeyScheme.Sha1Producer);
Assert.AreEqual(1, producerKeys.Count);
keys.Remove(KeyScheme.Sha1Producer, new Key("producer key 1"));
Assert.AreEqual(0, producerKeys.Count);
Assert.IsTrue(keys.IsEmpty);
// remove a non-existent key, check nothing Bad happens
keys.Remove(KeyScheme.Sha1Consumer, new Key("blah"));
}
public void addRemoveSets()
{
Keys keys1 = new Keys();
Keys keys2 = new Keys();
Keys keys3 = new Keys();
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key prod 1"));
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("dual key cons 1"));
keys1.Add(KeyScheme.Sha1Producer, new Key("producer key 1.1"));
keys1.Add(KeyScheme.Sha1Producer, new Key("producer key 1.2"));
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key prod 2"));
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("dual key cons 2"));
keys2.Add(KeyScheme.Sha1Consumer, new Key("consumer key 1"));
// add keys in bulk to keys3
keys3.Add(keys1);
Assert.AreEqual(1, keys3.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
Assert.AreEqual(1, keys3.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
Assert.AreEqual(2, keys3.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, keys3.KeysetFor(KeyScheme.Sha1Consumer).Count);
keys3.Add(keys2);
Assert.AreEqual(2, keys3.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
Assert.AreEqual(2, keys3.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
Assert.AreEqual(2, keys3.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(1, keys3.KeysetFor(KeyScheme.Sha1Consumer).Count);
keys3.remove(keys1);
Assert.AreEqual(1, keys3.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
Assert.AreEqual(1, keys3.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
Assert.AreEqual(0, keys3.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(1, keys3.KeysetFor(KeyScheme.Sha1Consumer).Count);
keys3.remove(keys2);
Assert.IsTrue(keys3.IsEmpty);
}
/// <summary>
/// Shortcut to efficiently generate a key collection that represents
/// this key collection's union with another.
/// </summary>
/// <param name="keys">The keys to add.</param>
/// <returns>If keys is empty, this method will simply return this
/// collection. If this collection is empty, keys will be
/// returned. Otherwise a new collection instance is created
/// as the union of both.</returns>
public Keys AddedTo(Keys keys)
{
if (keys.IsEmpty)
{
return this;
}
else if (IsEmpty)
{
return keys;
}
else
{
Keys newKeys = new Keys(this);
newKeys.Add(keys);
return newKeys;
}
}
public static Keys Decode(Stream inStream)
{
int length;
using (BinReader r = new BinReader(inStream))
{
length = r.ReadInt32();
}
if (length == 0)
return EmptyKeys;
try
{
Keys keys = new Keys();
for (; length > 0; length--)
{
using (BinReader r = new BinReader(inStream))
{
KeyScheme scheme = KeyScheme.SchemeFor(r.ReadInt32());
int keySetCount = r.ReadInt32();
if (scheme.IsDual())
{
if (keySetCount != 2)
throw new ProtocolCodecException("Dual key scheme with " + keySetCount + " key sets");
DualKeySet keyset = keys.NewKeysetFor((DualKeyScheme)scheme);
DecodeKeys(inStream, keyset.ProducerKeys);
DecodeKeys(inStream, keyset.ConsumerKeys);
}
else
{
if (keySetCount != 1)
throw new ProtocolCodecException
("Single key scheme with " + keySetCount + " key sets");
DecodeKeys(inStream, keys.NewKeysetFor((SingleKeyScheme)scheme));
}
}
}
return keys;
}
catch (ArgumentException ex)
{
// most likely an invalid KeyScheme ID
throw new ProtocolCodecException("Could not decode keys.", ex);
}
}
/// <summary>
/// Add all keys in a collection.
/// </summary>
/// <param name="keys">The keys to add.</param>
public virtual void Add(Keys keys)
{
if (keys == this)
throw new ArgumentException("Cannot add key collection to itself");
foreach (KeyScheme scheme in keys.keySets.Keys)
Add(scheme, keys.keySets[scheme]);
}
public void consumer()
{
Key bobPrivate = new Key("bob private");
Key bobPublic = bobPrivate.PublicKeyFor(KeyScheme.Sha1Consumer);
Keys aliceNtfnKeys = new Keys();
aliceNtfnKeys.Add(KeyScheme.Sha1Consumer, bobPublic);
Keys bobSubKeys = new Keys();
bobSubKeys.Add(KeyScheme.Sha1Consumer, bobPrivate);
Keys eveSubKeys = new Keys();
eveSubKeys.Add(KeyScheme.Sha1Consumer, new Key("Not bob's key"));
Assert.IsTrue(bobSubKeys.Match(aliceNtfnKeys));
Assert.IsFalse(eveSubKeys.Match(aliceNtfnKeys));
}
public override void Decode(Stream inStream)
{
attributes = XdrCoding.getNameValues(inStream);
deliverInsecure = XdrCoding.getBool(inStream);
keys = Keys.Decode(inStream);
}
public void delta()
{
Keys addedKeys = new Keys();
Keys removedKeys = new Keys();
Keys baseKeys = new Keys();
addedKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("added/removed key"));
addedKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("added key 1"));
addedKeys.Add(KeyScheme.Sha1Producer, new Key("added key 2"));
removedKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("added/removed key"));
removedKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("non existent key"));
removedKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("removed key"));
baseKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("kept key"));
baseKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("removed key"));
Keys delta = baseKeys.Alter(addedKeys, removedKeys);
Keys correctKeys = new Keys();
correctKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("added key 1"));
correctKeys.Add(KeyScheme.Sha1Producer, new Key("added key 2"));
correctKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("kept key"));
Assert.AreEqual(correctKeys, delta);
// check delta works with empty keys
Keys keys4 = Keys.EmptyKeys.Alter(addedKeys, removedKeys);
correctKeys = new Keys();
correctKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("added key 1"));
correctKeys.Add(KeyScheme.Sha1Producer, new Key("added key 2"));
Assert.AreEqual(correctKeys, keys4);
}
protected Notify()
{
this.attributes = new Dictionary<string, object>();
this.deliverInsecure = true;
this.keys = Keys.EmptyKeys;
}
/// <summary>
/// Remove all keys in a collection.
/// </summary>
/// <param name="keys">The keys to remove</param>
public virtual void remove(Keys keys)
{
if (keys == this)
throw new ArgumentException("Cannot remove key collection from itself");
foreach (KeyScheme scheme in keys.keySets.Keys)
{
IKeySet myKeys;
if (keySets.TryGetValue(scheme, out myKeys))
{
myKeys.Remove(keys.KeysetFor(scheme));
if (myKeys.IsEmpty)
keySets.Remove(scheme);
}
}
}
public void computeDeltaSingleScheme()
{
Keys keys1 = new Keys();
Keys keys2 = new Keys();
Key key1 = new Key("key 1");
Key key2 = new Key("key 2");
Delta delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Consumer).Count);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Dual).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Consumer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Dual).Count);
// add a single producer key
keys2.Add(KeyScheme.Sha1Producer, key1);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(1, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
checkApplyDelta(delta, keys1, keys2);
// remove a single producer key
keys1.Add(KeyScheme.Sha1Producer, key2);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(1, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
checkApplyDelta(delta, keys1, keys2);
// key1 is now in both sets
keys1.Add(KeyScheme.Sha1Producer, key1);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
// key2 is not in both
keys2.Add(KeyScheme.Sha1Producer, key2);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
checkApplyDelta(delta, keys1, keys2);
}
/// <summary>
/// Create a new key collection with some keys added/removed. This
/// does not modify the current collection.
/// </summary>
/// <param name="toAdd">Keys to add.</param>
/// <param name="toRemove">Keys to remove</param>
/// <returns>A new key set with keys added/removed. If both add/remove
/// key sets are empty, this returns the current instance.</returns>
public Keys Alter(Keys toAdd, Keys toRemove)
{
if (toAdd.IsEmpty && toRemove.IsEmpty)
{
return this;
}
else
{
Keys keys = new Keys(this);
keys.Add(toAdd);
keys.remove(toRemove);
return keys;
}
}
public bool Equals(Keys keys)
{
if (keySets.Count != keys.keySets.Count)
return false;
foreach (KeyScheme scheme in keys.keySets.Keys)
{
if (!KeysetFor(scheme).Equals(keys.KeysetFor(scheme)))
return false;
}
return true;
}
/// <summary>
/// Check applying delta to keys1 gives keys2
/// </summary>
/// <param name="delta"></param>
/// <param name="keys1"></param>
/// <param name="keys2"></param>
private static void checkApplyDelta(Delta delta,
Keys keys1, Keys keys2)
{
Assert.AreEqual(keys1.Alter(delta.Added, delta.Removed), keys2);
}
public void producer()
{
Key alicePrivate = new Key("alice private");
Key alicePublic = alicePrivate.PublicKeyFor(KeyScheme.Sha1Producer);
Keys aliceNtfnKeys = new Keys();
aliceNtfnKeys.Add(KeyScheme.Sha1Producer, alicePrivate);
Keys bobSubKeys = new Keys();
bobSubKeys.Add(KeyScheme.Sha1Producer, alicePublic);
Keys eveSubKeys = new Keys();
eveSubKeys.Add(KeyScheme.Sha1Producer, new Key("Not alice's key").PublicKeyFor(KeyScheme.Sha1Producer));
Assert.IsTrue(bobSubKeys.Match(aliceNtfnKeys));
Assert.IsFalse(eveSubKeys.Match(aliceNtfnKeys));
}
public void IO()
{
using (MemoryStream buff = new MemoryStream())
{
Keys keys = new Keys();
keys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key 1"));
keys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("dual key 2"));
keys.Add(KeyScheme.Sha1Producer, new Key("producer key 1"));
keys.Add(KeyScheme.Sha1Consumer, new Key("consumer key 1"));
keys.Add(KeyScheme.Sha1Consumer, new Key("consumer key 2"));
// test roundtrip encode/decode
keys.Encode(buff);
buff.Seek(0, SeekOrigin.Begin); // reset to start
Keys newKeys = Keys.Decode(buff);
Assert.IsTrue(keys.Equals(newKeys));
}
}
public void equality()
{
Assert.IsTrue(new Key("a test key number 1").Equals(new Key("a test key number 1")));
Assert.IsFalse(new Key("a test key number 1").Equals(new Key("a test key number 2")));
Assert.AreEqual(new Key("a test key number 1").GetHashCode(),
new Key("a test key number 1").GetHashCode());
// test Keys.equals ()
Keys keys1 = new Keys();
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key 1"));
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("dual key 2"));
keys1.Add(KeyScheme.Sha1Producer, new Key("producer key 1"));
keys1.Add(KeyScheme.Sha1Consumer, new Key("consumer key 1"));
Keys keys2 = new Keys();
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, new Key("dual key 1"));
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, new Key("dual key 2"));
keys2.Add(KeyScheme.Sha1Producer, new Key("producer key 1"));
keys2.Add(KeyScheme.Sha1Consumer, new Key("consumer key 1"));
Assert.AreEqual(keys1.GetHashCode(), keys2.GetHashCode());
Assert.AreEqual(keys1, keys2);
keys2.Remove(KeyScheme.Sha1Consumer, new Key("consumer key 1"));
Assert.IsFalse(keys1.Equals(keys2));
}
public void dual()
{
Key alicePrivate = new Key("alice private");
Key alicePublic = alicePrivate.PublicKeyFor(KeyScheme.Sha1Dual);
Key bobPrivate = new Key("bob private");
Key bobPublic = bobPrivate.PublicKeyFor(KeyScheme.Sha1Dual);
Keys aliceNtfnKeys = new Keys();
aliceNtfnKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, bobPublic);
aliceNtfnKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, alicePrivate);
Keys bobSubKeys = new Keys();
bobSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, bobPrivate);
bobSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, alicePublic);
Keys eveSubKeys = new Keys();
Key randomPrivate = new Key("Not bob's key");
eveSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, randomPrivate);
eveSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, randomPrivate.PublicKeyFor(KeyScheme.Sha1Dual));
Assert.IsTrue(bobSubKeys.Match(aliceNtfnKeys));
Assert.IsFalse(aliceNtfnKeys.Match(bobSubKeys));
Assert.IsFalse(eveSubKeys.Match(aliceNtfnKeys));
}
/// <summary>
/// Compute the changes between one key collection and another.
/// </summary>
/// <param name="keys">The target key collection.</param>
/// <returns>The delta (i.e. key sets to be added and removed)
/// required to change this collection into the target.</returns>
public Delta DeltaFrom(Keys keys)
{
if (keys == this)
return Delta.EMPTY_DELTA;
Keys addedKeys = new Keys();
Keys removedKeys = new Keys();
foreach (KeyScheme scheme in KeyScheme.Schemes)
{
IKeySet existingKeyset = KeysetFor(scheme);
IKeySet otherKeyset = keys.KeysetFor(scheme);
addedKeys.Add(scheme, otherKeyset.Subtract(existingKeyset));
removedKeys.Add(scheme, existingKeyset.Subtract(otherKeyset));
}
return new Delta(addedKeys, removedKeys);
}
public ElvinOptions(ConnectionOptions connectionOptions,
Keys notificationKeys,
Keys subscriptionKeys)
{
if (notificationKeys == null) throw new ArgumentNullException("notificationKeys");
if (subscriptionKeys == null) throw new ArgumentNullException("subscriptionKeys");
if (connectionOptions == null) throw new ArgumentNullException("connectionOptions");
this.connectionOptions = connectionOptions;
this.notificationKeys = notificationKeys;
this.subscriptionKeys = subscriptionKeys;
this.requireAuthenticatedServer = false;
this.receiveTimeout = 10000;
this.livenessTimeout = 60000;
}
/// <summary>
/// Test whether a given key collection matches this one for the
/// purpose of notification delivery.
/// </summary>
/// <param name="producerKeys">The producer keys to match against this (consumer) key collection.</param>
/// <returns>True if a consumer using this key collection could
/// receive a notification from a producer with the given
/// producer key collection.</returns>
public bool Match(Keys producerKeys)
{
if (IsEmpty || producerKeys.IsEmpty)
return false;
foreach (var entry in producerKeys.keySets)
{
KeyScheme scheme = entry.Key;
IKeySet keyset = entry.Value;
if (keySets.ContainsKey(scheme) &&
scheme.Match(keyset, keySets[scheme]))
{
return true;
}
}
return false;
}
public NotifyEmit(Dictionary<String, Object> attributes,
bool deliverInsecure,
Keys keys)
: base(attributes, deliverInsecure, keys)
{
}
public Keys(Keys keys)
: this()
{
Add(keys);
}
public void computeDeltaDual()
{
Keys keys1 = new Keys();
Keys keys2 = new Keys();
Key key1 = new Key("key 1");
Key key2 = new Key("key 2");
Key key3 = new Key("key 3");
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, key1);
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, key2);
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, key3);
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, key3);
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, key3);
Delta delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(1, delta.Added.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
checkApplyDelta(delta, keys1, keys2);
}