public Maybe <CloudApplicationDefinition> Inspect()
{
var runtimeSerializer = new CloudFormatter();
var definitionBlob = _blobs.GetBlob <CloudApplicationDefinition>(ContainerName, ApplicationDefinitionBlobName, runtimeSerializer);
Maybe <byte[]> packageBlob;
string packageETag;
if (definitionBlob.HasValue)
{
packageBlob = _blobs.GetBlobIfModified <byte[]>(AssemblyLoader.ContainerName, AssemblyLoader.PackageBlobName, definitionBlob.Value.PackageETag, out packageETag, runtimeSerializer);
if (!packageBlob.HasValue || definitionBlob.Value.PackageETag == packageETag)
{
return(definitionBlob.Value);
}
}
else
{
packageBlob = _blobs.GetBlob <byte[]>(AssemblyLoader.ContainerName, AssemblyLoader.PackageBlobName, out packageETag, runtimeSerializer);
}
if (!packageBlob.HasValue)
{
return(Maybe <CloudApplicationDefinition> .Empty);
}
var definition = Analyze(packageBlob.Value, packageETag);
_blobs.PutBlob(ContainerName, ApplicationDefinitionBlobName, definition, runtimeSerializer);
return(definition);
}
static ITableStorageProvider TableStorageProvider(IContext c)
{
IDataSerializer formatter;
if (!c.TryResolve(out formatter))
{
formatter = new CloudFormatter();
}
return new TableStorageProvider(c.Resolve<CloudTableClient>(), formatter);
}
public void Serialization()
{
// overflowing message
var om = new OverflowWrapper {ContainerName = "con", BlobName = "blo"};
var stream = new MemoryStream();
var serializer = new CloudFormatter();
serializer.Serialize(om, stream, om.GetType());
stream.Position = 0;
var omBis = (OverflowWrapper) serializer.Deserialize(stream, typeof (OverflowWrapper));
Assert.AreEqual(om.ContainerName, omBis.ContainerName, "#A00");
Assert.AreEqual(om.BlobName, omBis.BlobName, "#A01");
}
public void UnknownType()
{
var formatter = new CloudFormatter();
using (var stream = new MemoryStream())
{
var item = new MockWithObject {
Generic = DateTime.UtcNow.Second > 30 ? (object)100 : "hello"
};
formatter.Serialize(item, stream, typeof(MockWithObject));
stream.Seek(0, SeekOrigin.Begin);
var output = (MockWithObject)formatter.Deserialize(stream, typeof(MockWithObject));
Assert.AreEqual(item.Generic, output.Generic);
}
}
public void CanSetCustomDataSerializer()
{
var serializerInstance = new CloudFormatter();
var providersCustom = CloudStorage.ForInMemoryStorage().WithDataSerializer(serializerInstance).BuildStorageProviders();
Assert.AreSame(serializerInstance, ((MemoryBlobStorageProvider)providersCustom.BlobStorage).DefaultSerializer);
Assert.AreSame(serializerInstance, ((MemoryTableStorageProvider)providersCustom.TableStorage).DataSerializer);
Assert.AreSame(serializerInstance, ((MemoryQueueStorageProvider)providersCustom.QueueStorage).DefaultSerializer);
var providersDefault = CloudStorage.ForInMemoryStorage().BuildStorageProviders();
Assert.AreNotSame(serializerInstance, ((MemoryBlobStorageProvider)providersDefault.BlobStorage).DefaultSerializer);
Assert.AreNotSame(serializerInstance, ((MemoryTableStorageProvider)providersDefault.TableStorage).DataSerializer);
Assert.AreNotSame(serializerInstance, ((MemoryQueueStorageProvider)providersDefault.QueueStorage).DefaultSerializer);
}
public QueuesModel QueryQueues()
{
var queueStorage = _storage.QueueStorage;
var inspector = new CloudApplicationInspector(_storage.BlobStorage);
var applicationDefinition = inspector.Inspect();
var runtimeSerializer = new CloudFormatter();
var failingMessages = queueStorage.ListPersisted(FailingMessagesStoreName)
.Select(key => queueStorage.GetPersisted(FailingMessagesStoreName, key, runtimeSerializer))
.Where(m => m.HasValue)
.Select(m => m.Value)
.OrderByDescending(m => m.PersistenceTime)
.Take(50)
.ToList();
return(new QueuesModel
{
Queues = queueStorage.List(null).Select(queueName => new AzureQueue
{
QueueName = queueName,
MessageCount = queueStorage.GetApproximateCount(queueName),
Latency = queueStorage.GetApproximateLatency(queueName).Convert(ts => ts.PrettyFormat(), string.Empty),
Services = applicationDefinition.Convert(cd => cd.QueueServices.Where(d => d.QueueName == queueName).ToArray(), new QueueServiceDefinition[0])
}).ToArray(),
HasQuarantinedMessages = failingMessages.Count > 0,
Quarantine = failingMessages
.GroupBy(m => m.QueueName)
.Select(group => new AzureQuarantineQueue
{
QueueName = group.Key,
Messages = group.OrderByDescending(m => m.PersistenceTime)
.Select(m => new AzureQuarantineMessage
{
Inserted = (DateTime.UtcNow - m.InsertionTime.UtcDateTime).PrettyFormat() + " ago",
Persisted = (DateTime.UtcNow - m.PersistenceTime.UtcDateTime).PrettyFormat() + " ago",
Reason = HttpUtility.HtmlEncode(m.Reason),
Content = FormatQuarantinedLogEntryXmlContent(m),
Key = m.Key,
HasData = m.IsDataAvailable,
HasXml = m.DataXml.HasValue
})
.ToArray()
})
.ToArray()
});
}
public void Serialization()
{
// overflowing message
var om = new MessageWrapper {
ContainerName = "con", BlobName = "blo"
};
var stream = new MemoryStream();
var serializer = new CloudFormatter();
serializer.Serialize(om, stream, om.GetType());
stream.Position = 0;
var omBis = (MessageWrapper)serializer.Deserialize(stream, typeof(MessageWrapper));
Assert.AreEqual(om.ContainerName, omBis.ContainerName, "#A00");
Assert.AreEqual(om.BlobName, omBis.BlobName, "#A01");
}
public void SerializeDeserializeAbstractBaseType()
{
var baseType = typeof(MockAbstract);
var formatter = new CloudFormatter();
using (var stream = new MemoryStream())
{
var test = new MockConcrete()
{
Number = 123, Text = "hello!"
};
formatter.Serialize(test, stream, baseType);
stream.Seek(0, SeekOrigin.Begin);
var deserialized = (MockConcrete)formatter.Deserialize(stream, baseType);
Assert.AreEqual(test.Text, deserialized.Text);
Assert.AreEqual(test.Number, deserialized.Number);
}
}
static IQueueStorageProvider QueueStorageProvider(IContext c)
{
IDataSerializer formatter;
if (!c.TryResolve(out formatter))
{
formatter = new CloudFormatter();
}
return new QueueStorageProvider(
c.Resolve<CloudQueueClient>(),
c.Resolve<IBlobStorageProvider>(),
formatter,
// RuntimeFinalizer is a dependency (as the name suggest) on the worker runtime
// This dependency is typically not available in a pure O/C mapper scenario.
// In such case, we just pass a dummy finalizer (that won't be used any
c.ResolveOptional<IRuntimeFinalizer>());
}
public void SerializeDeserialize()
{
var formatter = new CloudFormatter();
using (var stream = new MemoryStream())
{
var test = "hello!";
formatter.Serialize(test, stream, typeof(string));
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(test, formatter.Deserialize(stream, typeof(string)));
//Console.WriteLine(stream.CanSeek);
}
using (var stream = new MemoryStream())
{
var test = 123;
formatter.Serialize(test, stream, typeof(int));
stream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(test, formatter.Deserialize(stream, typeof(int)));
}
using (var stream = new MemoryStream())
{
var test = new byte[] { 1, 2, 3 };
formatter.Serialize(test, stream, typeof(int));
stream.Seek(0, SeekOrigin.Begin);
CollectionAssert.AreEquivalent(test, (byte[])formatter.Deserialize(stream, typeof(byte[])));
}
using (var stream = new MemoryStream())
{
var items = new MockComplex[3];
items[0] = new MockComplex
{
Prop1 = "0",
Prop2 = 0,
Flags = new List <MockEnum> {
MockEnum.Item1
},
Ignored = "hi!",
InvoiceId = "700",
Field = 0.0F
};
items[1] = new MockComplex
{
Prop1 = "1",
Prop2 = 1,
Flags = new List <MockEnum> {
MockEnum.Item2
},
Ignored = "hi!",
InvoiceId = "800",
Field = 1.0F
};
items[2] = new MockComplex
{
Prop1 = "2",
Prop2 = 2,
Flags = new List <MockEnum> {
MockEnum.Item3, MockEnum.Item1
},
Ignored = "hi!",
Field = 2.0F
};
formatter.Serialize(items, stream, items.GetType());
stream.Seek(0, SeekOrigin.Begin);
var output = (MockComplex[])formatter.Deserialize(stream, typeof(MockComplex[]));
Assert.AreEqual(items.Length, output.Length);
for (int i = 0; i < items.Length; i++)
{
Assert.AreEqual(items[i].Field, output[i].Field);
Assert.AreEqual(items[i].Prop1, output[i].Prop1);
Assert.AreEqual(items[i].Prop2, output[i].Prop2);
CollectionAssert.AreEquivalent(items[i].Flags, output[i].Flags);
Assert.IsNull(output[i].Ignored);
Assert.AreEqual(items[i].InvoiceId, output[i].InvoiceId);
}
}
using (var stream = new MemoryStream())
{
var item = new MockComplex2
{
Prop1 = "0",
Prop2 = 0,
Flags = new List <MockEnum> {
MockEnum.Item1
},
};
formatter.Serialize(item, stream, item.GetType());
stream.Seek(0, SeekOrigin.Begin);
var output = (MockComplex2)formatter.Deserialize(stream, typeof(MockComplex2));
Assert.AreEqual(item.Prop1, output.Prop1);
Assert.AreEqual(item.Prop2, output.Prop2);
Assert.AreEqual(item.Flags.Count, output.Flags.Count);
}
// Test "big" object
using (var stream = new MemoryStream())
{
var hugeArray = new double[10000];
for (int i = 0; i < hugeArray.Length; i++)
{
hugeArray[i] = i;
}
formatter.Serialize(hugeArray, stream, hugeArray.GetType());
stream.Seek(0, SeekOrigin.Begin);
var output = (double[])formatter.Deserialize(stream, typeof(double[]));
CollectionAssert.AreEquivalent(hugeArray, output);
}
}
public void UnpackRepack()
{
var formatter = new CloudFormatter();
// STRING
foreach (var result in ApplyUnpackRepackXml(formatter, "test!"))
{
Assert.AreEqual("test!", result, "string");
}
// INTEGER
foreach (var result in ApplyUnpackRepackXml(formatter, 123))
{
Assert.AreEqual(123, result, "integer");
}
// BYTE ARRAY
var byteArray = new byte[] { 1, 2, 3 };
foreach (var result in ApplyUnpackRepackXml(formatter, byteArray))
{
CollectionAssert.AreEquivalent(byteArray, result, "byte array");
}
// COMPLEX DATA
var complexInput = new[]
{
new MockComplex
{
Prop1 = "0",
Prop2 = 0,
Flags = new List <MockEnum> {
MockEnum.Item1
},
Ignored = "hi!",
InvoiceId = "700",
Field = 0.0F
},
new MockComplex
{
Prop1 = "1",
Prop2 = 1,
Flags = new List <MockEnum> {
MockEnum.Item2
},
Ignored = "hi!",
InvoiceId = "800",
Field = 1.0F
},
new MockComplex
{
Prop1 = "2",
Prop2 = 2,
Flags = new List <MockEnum> {
MockEnum.Item3, MockEnum.Item1
},
Ignored = "hi!",
Field = 2.0F
}
};
foreach (var result in ApplyUnpackRepackXml(formatter, complexInput))
{
Assert.AreEqual(complexInput.Length, result.Length);
for (int i = 0; i < complexInput.Length; i++)
{
Assert.AreEqual(complexInput[i].Field, result[i].Field);
Assert.AreEqual(complexInput[i].Prop1, result[i].Prop1);
Assert.AreEqual(complexInput[i].Prop2, result[i].Prop2);
CollectionAssert.AreEquivalent(complexInput[i].Flags, result[i].Flags);
Assert.IsNull(result[i].Ignored);
Assert.AreEqual(complexInput[i].InvoiceId, result[i].InvoiceId);
}
}
// SERIALIZABLE INSTEAD OF DATA CONTRACT
var serializableInput = new MockComplex2
{
Prop1 = "0",
Prop2 = 0,
Flags = new List <MockEnum> {
MockEnum.Item1
},
};
foreach (var result in ApplyUnpackRepackXml(formatter, serializableInput))
{
Assert.AreEqual(serializableInput.Prop1, result.Prop1);
Assert.AreEqual(serializableInput.Prop2, result.Prop2);
Assert.AreEqual(serializableInput.Flags.Count, result.Flags.Count);
}
// UNTYPED DATA
var unknownInput = new MockWithObject {
Generic = DateTime.UtcNow.Second > 30 ? (object)100 : "hello"
};
foreach (var result in ApplyUnpackRepackXml(formatter, unknownInput))
{
Assert.AreEqual(unknownInput.Generic, result.Generic);
}
}
public CachedMyDocumentSet(IBlobStorageProvider blobs)
: base(blobs, key => new BlobLocation("document-container", key.ToString()))
{
_cache = MemoryCache.Default;
Serializer = new CloudFormatter();
}
