void AssertEquals <T>(T[] expected, T[] actual)
{
if (expected == null)
{
if (actual != null)
{
Assert.Fail("Expected null but got {0}", Sos.SerializeObject(actual));
}
}
else if (actual == null)
{
Assert.Fail("Expected {0} but got null", Sos.SerializeObject(expected));
}
else
{
if (expected.Length != actual.Length)
{
Assert.Fail("Expected array of length {0} but actual was length {1} (expected {2}, actual {3})",
expected.Length, actual.Length, Sos.SerializeObject(expected), Sos.SerializeObject(actual));
}
for (int i = 0; i < expected.Length; i++)
{
if (!expected[i].Equals(actual[i]))
{
Assert.Fail("Array mismatch at index {0} (expected {1}, actual {2})", i, Sos.SerializeObject(expected), Sos.SerializeObject(actual));
}
}
}
}
public static void TestDeserializationToNull(StringBuilder builder, Type type, String str, Int32 expectedLengthUsed)
{
Object obj;
Int32 offset = Sos.Deserialize(out obj, type, str, 0, str.Length);
Console.WriteLine("String '{0}' Object After Deserialization '{1}'", str, obj);
Assert.AreEqual(expectedLengthUsed, offset);
Assert.IsNull(obj);
}
public static void TestSerializer(StringBuilder builder, Object obj)
{
builder.Length = 0;
obj.SerializeObject(builder);
String seralizationString = builder.ToString();
//Console.WriteLine("SerializationString '{0}'", seralizationString);
Object newObject = null;
Int32 offset = -1;
try
{
offset = Sos.Deserialize(out newObject, obj.GetType(), seralizationString, 0, seralizationString.Length);
}
catch (Exception e)
{
throw new Exception(String.Format("Deserialization failed: {0}. Serialized string was '{1}'", e, seralizationString), e);
}
/*
* String objString;
* try
* {
* objString = obj.ToString();
* }
* catch (NullReferenceException)
* {
* objString = "[NullReferenceException in ToString() Method]";
* }
* String newObjectString;
* try
* {
* newObjectString = newObject.ToString();
* }
* catch (NullReferenceException)
* {
* newObjectString = "[NullReferenceException in ToString() Method]";
* }
* Console.WriteLine("Before Serialization '{0}' ({1}) SerializeString '{2}' After '{3}' ({4})",
* objString, obj.GetType(), seralizationString, newObjectString, newObject.GetType());
*/
Assert.AreEqual(seralizationString.Length, offset);
String diffMessage = obj.Diff(newObject);
if (diffMessage != null)
{
Assert.Fail(diffMessage);
}
}
public void TestValidFloatRegex(String floatString)
{
Console.WriteLine("ValidTestString '{0}'", floatString);
//Match m = Sos.FloatNumberRegexBase10.Match(floatString);
Int32 numberLength = Sos.FloatLength(floatString, 0, floatString.Length);
String matchString = floatString.Substring(0, numberLength);
Console.WriteLine("Matched '{0}'", matchString);
Assert.AreEqual(floatString.Length, matchString.Length);
}
public static void TestDeserializeFormatException(StringBuilder builder, Type type, String str)
{
Object obj;
try
{
Int32 offset = Sos.Deserialize(out obj, type, str, 0, str.Length);
Assert.Fail("Expected FormatException but didn't get one for string '{0}'", str);
}
catch (FormatException e)
{
Console.WriteLine("String '{0}' Produced FormatException '{1}'", str, e.Message);
}
}
public void FullUTF16CharacterTestCoverage()
{
StringBuilder builder = new StringBuilder();
Util.TestDeserialization(builder, '\0', @"""\0""");
Util.TestDeserialization(builder, '\n', @"""\n""");
Util.TestDeserialization(builder, '\r', @"""\r""");
Util.TestDeserialization(builder, '\t', @"""\t""");
Util.TestDeserialization(builder, '\\', @"""\\""");
Util.TestDeserialization(builder, '\xab', @"""\xab""");
Util.TestDeserialization(builder, '\x9F', @"""\x9F""");
Util.TestDeserialization(builder, '\uabCe', @"""\uabCe""");
Util.TestDeserialization(builder, '\u9F3C', @"""\u9F3C""");
//Util.TestDeserialization(builder, '\a', @"""\a""");
//Util.TestDeserialization(builder, '\b', @"""\b""");
//Util.TestDeserialization(builder, '\f', @"""\f""");
//Util.TestDeserialization(builder, '\v', @"""\v""");
for (Int32 cAsInt = 0; cAsInt <= 65535; cAsInt++)
{
Char c = (Char)cAsInt;
String seralizationString = c.SerializeChar();
Object newObject = null;
Int32 offset = -1;
try
{
offset = Sos.Deserialize(out newObject, typeof(Char), seralizationString, 0, seralizationString.Length);
}
catch (Exception e)
{
throw new Exception(String.Format("Deserialization failed: {0}. Serialized string was '{1}'", e, seralizationString), e);
}
//Console.WriteLine("Before Serialization '{0}' ({1}) SerializeString '{2}' After '{3}' ({4})",
// c, typeof(Char), seralizationString, newObject, newObject.GetType());
Assert.AreEqual(seralizationString.Length, offset);
String diffMessage = c.Diff(newObject);
if (diffMessage != null)
{
Assert.Fail(diffMessage);
}
}
}
public void TestOidParser(Byte[] expectedBytes, String oidString)
{
oidBytes.Clear();
Console.WriteLine("Testing '{0}'", oidString);
Snmp.ParseOid(oidString, oidBytes);
Byte[] actual = oidBytes.ToArray();
String diff = Sos.Diff(expectedBytes, actual);
if (diff != null)
{
Console.WriteLine("Expected: " + expectedBytes.SerializeObject());
Console.WriteLine("Actual : " + actual.SerializeObject());
Assert.Fail(diff);
}
}
public static void TestDeserialization(StringBuilder builder, Object expectedObject, String str, Int32 expectedLengthUsed)
{
Object newObject;
Int32 offset = Sos.Deserialize(out newObject, expectedObject.GetType(), str, 0, str.Length);
Console.WriteLine("String '{0}' Object After Deserialization '{1}'", str, newObject);
String diffMessage = expectedObject.Diff(newObject);
if (diffMessage != null)
{
Assert.Fail(diffMessage);
}
Assert.AreEqual(expectedLengthUsed, offset);
}
void ThrowExceptionFromCall(String methodName, NpcReturnLine returnLine)
{
Type exceptionType;
try
{
exceptionType = staticClientTypeFinder.FindType(returnLine.sosTypeName);
}
catch (InvalidOperationException)
{
//Console.WriteLine("Could not find type '{0}'", returnLine.sosTypeName);
goto INVALID_EXCEPTION;
}
Object exceptionObject;
try
{
Int32 offset = Sos.Deserialize(out exceptionObject, exceptionType,
returnLine.sosSerializationString, 0, returnLine.sosSerializationString.Length);
if (offset != returnLine.sosSerializationString.Length)
{
goto INVALID_EXCEPTION;
}
}
catch (Exception)
{
//Console.WriteLine("Faild to deserialize exception '{0}'", returnLine.sosTypeName);
goto INVALID_EXCEPTION;
}
try
{
Exception e = (Exception)exceptionObject;
throw e;
}
catch (InvalidCastException)
{
//Console.WriteLine("Could not cast '{0}' to Exception", exceptionObject.GetType().Name);
goto INVALID_EXCEPTION;
}
INVALID_EXCEPTION:
throw new Exception(String.Format("Method '{0}' threw exception {1}: '{2}'",
methodName, returnLine.sosTypeName, returnLine.exceptionMessage));
}
public static void ParseParameters(String parametersString, List <String> parameterList)
{
if (parametersString == null)
{
return;
}
if (parametersString.Length <= 0)
{
return;
}
Int32 offset = 0;
while (true)
{
while (true)
{
Char c = parametersString[offset];
if (Sos.IsValidStartOfSosString(c))
{
break;
}
if (!Char.IsWhiteSpace(c))
{
throw new FormatException(String.Format(
"Every parameter string must start with 0-9,a-z,A-Z,\",[,{{ or ', but parameter {0} started with '{1}' (charcode={2})",
parameterList.Count, c, (UInt32)c));
}
offset++;
if (offset >= parametersString.Length)
{
return;
}
}
Int32 nextSpace = Sos.NextNonQuotedWhitespace(parametersString, offset);
parameterList.Add(parametersString.Substring(offset, nextSpace - offset));
offset = nextSpace + 1;
if (offset >= parametersString.Length)
{
return;
}
}
}
public void TestInvalidStringsForNextWhitespace()
{
String[] invalidStrings = new String[] {
"\" ",
"\"\\\\\\\" ",
};
for (int i = 0; i < invalidStrings.Length; i++)
{
String invalidString = invalidStrings[i];
try
{
Sos.NextNonQuotedWhitespace(invalidString, 0);
Assert.Fail("Expected format exception but didn't get one for '{0}'", invalidString);
}
catch (FormatException e)
{
Console.WriteLine("Expected format exception for '{0}': {1}", invalidString, e.Message);
}
}
}
public void TestInvalidFloatRegex(String floatString)
{
Console.WriteLine("InvalidTestString '{0}'", floatString);
//Match m = Sos.FloatNumberRegexBase10.Match(floatString);
Int32 numberLength = Sos.FloatLength(floatString, 0, floatString.Length);
String matchString = floatString.Substring(0, numberLength);
Console.WriteLine("Invalid '{0}' Matched '{1}'", floatString, matchString);
if (numberLength > 0)
{
try
{
Single.Parse(matchString);
Assert.Fail("Expected parse to fail but didn't");
}
catch (FormatException)
{
}
}
}
public void TestHexStrings()
{
Byte[][] testArrays = new Byte[][] {
new Byte[] {},
new Byte[] { 0 },
new Byte[] { 0, 1, 2, 3 },
new Byte[] { 0xFF, 0xFE },
new Byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 },
};
for (int i = 0; i < testArrays.Length; i++)
{
Byte[] testArray = testArrays[i];
String hexString = testArray.ToHexString(0, testArray.Length);
Console.WriteLine("Testing {0}", hexString);
Byte[] deserializeCopy = new Byte[testArray.Length];
deserializeCopy.ParseHex(0, hexString, 0, hexString.Length);
Sos.Diff(testArray, deserializeCopy);
}
}
public void NextWhitespaceTest()
{
String[] validStrings = new String[] {
"0 ",
"9 ",
"a ",
"z ",
"A ",
"Z ",
"\"\" ",
"\"\\\"\" ",
"\"\\\\\\\"\" ",
"[ ",
"{ ",
};
for (int i = 0; i < validStrings.Length; i++)
{
String validString = validStrings[i];
Int32 offset = Sos.NextNonQuotedWhitespace(validString, 0);
Assert.AreEqual(validString.Length - 1, offset);
}
}
public static List <Bitmap> Decode(MemoryStream stream)
{
var reader = new BinaryReader(stream);
var images = new List <Bitmap>();
stream.Seek(0, SeekOrigin.Begin);
bool eof = false;
for (int image = 1; ; image++)
{
try
{
var imgInfo = new ImgInfo();
while (true)
{
while (reader.ReadByte() != 0xff)
{
;
}
int markerId = reader.ReadByte();
switch ((Markers)markerId)
{
case Markers.App0:
App0.Read(reader, imgInfo);
break;
case Markers.App14:
App14.Read(reader, imgInfo);
break;
case Markers.Dqt:
Dqt.Read(reader, imgInfo);
break;
case Markers.Sof0:
Sof0.Read(reader, imgInfo);
break;
case Markers.Sof2:
Sof2.Read(reader, imgInfo);
break;
case Markers.Dht:
Dht.Read(reader, imgInfo);
break;
case Markers.Sos:
images.Add(Sos.Read(reader, imgInfo));
break;
case Markers.Soi:
imgInfo = new ImgInfo();
//Logger.Write("Start of Image " + image);
//Logger.WriteLine(" at: " + (reader.BaseStream.Position - 2).ToString("X"));
imgInfo.startOfImageFound = true;
break;
case Markers.Dri:
Dri.Read(reader, imgInfo);
break;
case Markers.Eoi:
//Logger.Write("End of Image " + image);
//Logger.WriteLine(" at: " + (reader.BaseStream.Position - 2).ToString("X"));
eof = true;
break;
// Unknown markers, or markers used outside of their specified area
default:
Default.Read(reader, imgInfo, (Markers)markerId);
break;
}
if (eof)
{
eof = false;
break;
}
}
}
catch (EndOfStreamException)
{
break;
}
catch (Exception ex)
{
//Logger.WriteLine(ex.Message);
}
}
reader.Close();
//Logger.Flush();
return(images);
}
// expectedReturnType can be null, but providing the expected return type makes it unnecessary to search
// each assembly for the type
Object PerformCall(Type expectedReturnType, String methodName, String rawNpcLine)
{
if (threadSafe)
{
Monitor.Enter(serverEndPoint);
}
try
{
//
// The reason for the retry logic is because if the underlying socket is disconnected, it may not
// fail until after a send and a receive...so the socket should be reconnected and the request should
// be repeated only once.
//
for (UInt32 attempt = 0; ; attempt++)
{
try
{
Connect();
socketLineReader.socket.Send(Encoding.UTF8.GetBytes(rawNpcLine.ToString()));
String returnLineString = socketLineReader.ReadLine();
if (returnLineString == null)
{
if (attempt == 0)
{
Dispose();
continue; // Retry
}
throw UnexpectedClose();
}
NpcReturnLine returnLine = new NpcReturnLine(returnLineString);
if (returnLine.exceptionMessage != null)
{
ThrowExceptionFromCall(methodName, returnLine);
}
if (expectedReturnType == null)
{
if (returnLine.sosTypeName.Equals("Void"))
{
return(null);
}
expectedReturnType = GetTypeFromSosTypeName(returnLine.sosTypeName);
}
else
{
if (!returnLine.sosTypeName.Equals(expectedReturnType.SosTypeName()))
{
throw new InvalidOperationException(String.Format("Expected return type to be {0} but was {1}",
expectedReturnType.SosTypeName(), returnLine.sosTypeName));
}
}
if (expectedReturnType == typeof(void))
{
return(null);
}
Object returnObject;
Int32 valueStringOffset = Sos.Deserialize(out returnObject, expectedReturnType,
returnLine.sosSerializationString, 0, returnLine.sosSerializationString.Length);
if (valueStringOffset != returnLine.sosSerializationString.Length)
{
throw new InvalidOperationException(String.Format(
"Used {0} characters to deserialize object of type '{1}' but the serialization string had {2} characters",
valueStringOffset, expectedReturnType.SosTypeName(), returnLine.sosSerializationString.Length));
}
return(returnObject);
}
catch (SocketException)
{
if (socketLineReader != null)
{
socketLineReader.Dispose();
socketLineReader = null;
}
if (attempt == 0)
{
continue; // Retry
}
throw;
}
}
}
finally
{
if (threadSafe)
{
Monitor.Exit(serverEndPoint);
}
}
}
public static List <Image> Decode(Stream stream)
{
var reader = new BinaryReader(stream);
var images = new List <Image>();
stream.Seek(0, SeekOrigin.Begin);
var imgInfo = new ImgInfo();
for (long length = stream.Length; ;)
{
int markerId;
do
{
if (stream.Position == length)
{
goto end;
}
} while (reader.ReadByte() != 0xff);
markerId = reader.ReadByte();
switch ((Markers)markerId)
{
case Markers.App0:
App0.Read(reader, imgInfo);
break;
case Markers.App14:
App14.Read(reader, imgInfo);
break;
case Markers.Dqt:
Dqt.Read(reader, imgInfo);
break;
case Markers.Sof0:
Sof0.Read(reader, imgInfo);
break;
case Markers.Sof2:
Sof2.Read(reader, imgInfo);
break;
case Markers.Dht:
Dht.Read(reader, imgInfo);
break;
case Markers.Sos:
images.Add(Sos.Read(reader, imgInfo));
break;
case Markers.Soi:
//Logger.Write("Start of Image " + image);
//Logger.WriteLine(" at: " + (reader.BaseStream.Position - 2).ToString("X"));
imgInfo = new ImgInfo
{
startOfImageFound = true
};
break;
case Markers.Dri:
Dri.Read(reader, imgInfo);
break;
case Markers.Eoi:
//Logger.Write("End of Image " + image);
//Logger.WriteLine(" at: " + (reader.BaseStream.Position - 2).ToString("X"));
//eof = true;
break;
// Unknown markers, or markers used outside of their specified area
default:
Default.Read(reader, imgInfo, (Markers)markerId);
break;
}
}
end:
reader.Dispose();
return(images);
}
//
// Throws NpcErrorException for an npc error
//
public NpcReturnLine(String returnLine)
{
Boolean success = returnLine.StartsWith(NpcReturnObject.NpcReturnLineSuccessPrefix);
if (success || returnLine.StartsWith(NpcReturnObject.NpcReturnLineExceptionPrefix))
{
String noPrefixReturnLine;
if (success)
{
noPrefixReturnLine = returnLine.Substring(NpcReturnLineSuccessPrefix.Length);
if (noPrefixReturnLine.Equals("Void"))
{
this.exceptionMessage = null;
this.sosTypeName = "Void";
this.sosSerializationString = null;
return;
}
}
else
{
noPrefixReturnLine = returnLine.Substring(NpcReturnLineExceptionPrefix.Length);
//
// Exception Message
//
Object exceptionMessageObject;
Int32 offset = Sos.Deserialize(out exceptionMessageObject, typeof(String),
noPrefixReturnLine, 0, noPrefixReturnLine.Length);
this.exceptionMessage = (String)exceptionMessageObject;
if (offset >= noPrefixReturnLine.Length - 1)
{
InvalidReturnLine(returnLine, "Missing exception type and serialized exception");
}
noPrefixReturnLine = noPrefixReturnLine.Substring(offset + 1);
}
//
// Get the return type
//
Int32 spaceIndex = noPrefixReturnLine.IndexOf(' ');
if (spaceIndex < 0 || spaceIndex >= noPrefixReturnLine.Length - 1)
{
InvalidReturnLine(returnLine, "missing the return value");
}
if (spaceIndex == 0)
{
InvalidReturnLine(returnLine, "After 'Success' prefix there were 2 spaces in a row");
}
this.sosTypeName = noPrefixReturnLine.Remove(spaceIndex);
this.sosSerializationString = noPrefixReturnLine.Substring(spaceIndex + 1);
return;
}
if (returnLine.StartsWith(NpcReturnObject.NpcReturnLineNpcErrorPrefix))
{
String errorCode;
returnLine.Peel(out errorCode);
errorCode = errorCode.Peel(out returnLine);
throw new NpcErrorException((NpcErrorCode)Enum.Parse(typeof(NpcErrorCode), errorCode), returnLine);
}
InvalidReturnLine(returnLine, String.Format("does not start with '{0}','{1}' or '{2}'",
NpcReturnObject.NpcReturnLineSuccessPrefix, NpcReturnObject.NpcReturnLineNpcErrorPrefix,
NpcReturnObject.NpcReturnLineExceptionPrefix));
}
private void btnStart_Click(object sender, EventArgs e)
{
if (cmbAlgorithms.Text == "" || cmbFunction.Text == "" || txtExperiments.Text == "")
{
MessageBox.Show("Lütfen bilgileri eksiksiz giriniz.");
}
else
{
table.Columns.Clear();
table.Rows.Clear();
label3.Text = "";
label4.Text = "";
label5.Text = "";
label11.Text = "";
table.Columns.Add("En iyi çözüm", typeof(double));
for (int i = 0; i < nd; i++)
{
table.Columns.Add("Çözüm adayı " + (i + 1), typeof(double));
}
table.Columns.Add("İşlem süresi", typeof(double));
table.Columns.Add("Deney sayısı", typeof(int));
table.Columns.Add("Min en iyi çözüm", typeof(double));
table.Columns.Add("Max en iyi çözüm", typeof(double));
table.Columns.Add("En iyi çözümlerin ortalaması", typeof(double));
table.Columns.Add("Standart sapma", typeof(double));
dgwFitnessInf.DataSource = table;
NumofExp = int.Parse(txtExperiments.Text);
sw.Start();
switch (cmbAlgorithms.Text)
{
case "Genetic Algorithm":
for (int i = 0; i < NumofExp; i++)
{
Genetic gen = new Genetic();
double globalMin = gen.geneticStart(cmbFunction.Text);
if (gen.getDeger() == -1)
{
MessageBox.Show("Fonksiyonun parametre sayısı ile değişkenlerinizin sayısı uyuşmuyor!"); break;
}
else
{
double[][] randPop = gen.getRandPop();
MinBul min = new TekMinBul(gen.getFitness());
int minindex = min.minBul();
sw.Stop();
row = table.NewRow();
row["En iyi çözüm"] = globalMin;
for (int h = 0; h < nd; h++)
{
row["Çözüm adayı " + (h + 1)] = randPop[minindex][h];
}
row["İşlem süresi"] = sw.ElapsedMilliseconds;
table.Rows.Add(row);
dgwFitnessInf.DataSource = table;
}
}
break;
case "SOS Algorithm":
for (int i = 0; i < NumofExp; i++)
{
Sos sos = new Sos();
double globalMin = sos.sosStart(cmbFunction.Text);
if (sos.getDeger() == -1)
{
MessageBox.Show("Fonksiyonun parametre sayısı ile değişkenlerinizin sayısı uyuşmuyor!"); break;
}
else
{
double[][] randPop = sos.getRandPop();
MinBul min = new TekMinBul(sos.getFitness());
int minindex = min.minBul();
sw.Stop();
row = table.NewRow();
row["En iyi çözüm"] = globalMin;
for (int h = 0; h < nd; h++)
{
row["Çözüm adayı " + (h + 1)] = randPop[minindex][h];
}
row["İşlem süresi"] = sw.ElapsedMilliseconds;
table.Rows.Add(row);
dgwFitnessInf.DataSource = table;
}
}
break;
}
try
{
double[] bfs = new double[dgwFitnessInf.Rows.Count - 1];
foreach (DataGridViewRow row in dgwFitnessInf.Rows)
{
ort += Convert.ToDouble(row.Cells[0].Value);
bf = Convert.ToDouble(row.Cells[0].Value);
if (m == dgwFitnessInf.Rows.Count - 1)
{
break;
}
bfs[m] = bf;
m++;
}
average = ort / dgwFitnessInf.Rows.Count;
for (int i = 0; i < dgwFitnessInf.Rows.Count - 1; i++)
{
ss += Math.Pow((bfs[i] - average), 2);
}
ss = ss / (dgwFitnessInf.Rows.Count - 2);
label3.Text = bfs.Min() + "";
label4.Text = bfs.Max() + "";
label5.Text = (average) + "";
label11.Text = ss + "";
row["Deney sayısı"] = txtExperiments.Text;
row["Min en iyi çözüm"] = bfs.Min();
row["Max en iyi çözüm"] = bfs.Max();
row["En iyi çözümlerin ortalaması"] = average;
row["Standart sapma"] = ss;
pnlInfo.Visible = true;
btnStart.Enabled = false;
}
catch (Exception)
{
MessageBox.Show("Lütfen probleminize uygun bir fonksiyon seçiniz.");;
}
}
}
public static Object[] CreateParameterObjects(ParameterInfo[] parameterInfos, params String[] parameterStrings)
{
int parameterStringsLength = (parameterStrings == null) ? 0 : parameterStrings.Length;
int parameterInfosLength = (parameterInfos == null) ? 0 : parameterInfos.Length;
if (parameterInfosLength != parameterStringsLength)
{
throw new InvalidOperationException(String.Format("Expected {0} arguments but got {1}",
parameterInfosLength, parameterStringsLength));
}
if (parameterStringsLength <= 0)
{
return(null);
}
Object[] parameterObjects = new Object[parameterStringsLength];
for (int i = 0; i < parameterStringsLength; i++)
{
String parameterString = parameterStrings[i];
ParameterInfo parameterInfo = parameterInfos[i];
Type parameterType = parameterInfos[i].ParameterType;
//Console.WriteLine("Parameter {0} Type={1}", parameterInfo.Name, parameterType);
//
// Add quotes if parameter is string type and it is missing quotes
//
if (parameterType == typeof(String) && !parameterString.Equals("null"))
{
if (parameterString.Length <= 0)
{
parameterString = "null"; // default to null for empty string
}
else
{
if (parameterString[0] != '"')
{
//
// make sure the string does not contain any whitespace or quotes
//
if (parameterString.IndexOfAny(InvalidCharsForNonQuotedStrings) >= 0)
{
throw new InvalidOperationException(String.Format(
"You provided a non-quoted string with invalid characters '{0}' (invalid characters include whitespace, backslashes or quotes)", parameterString));
}
parameterString = "\"" + parameterString + "\"";
}
}
}
Int32 deserialationIndex;
try
{
deserialationIndex = Sos.Deserialize(
out parameterObjects[i], parameterType, parameterString, 0, parameterString.Length);
}
catch (Exception e)
{
throw new InvalidOperationException(String.Format("Failed to deserialize argument {0} ({1}) of type {2}: {3}",
i + 1, parameterInfo.Name, parameterType.SosTypeName(), e.Message), e);
}
if (deserialationIndex != parameterString.Length)
{
throw new InvalidOperationException(String.Format(
"Argument {0} (type={1}) has {2} characters but deserializtion only used {3} characters",
i, parameterType, parameterString.Length, deserialationIndex));
}
}
return(parameterObjects);
}
private void ExportTimeSeries(bool clearExportedData,
TimeSeriesChangeEvent detectedChange,
TimeSeriesDescription timeSeriesDescription)
{
var locationInfo = GetLocationInfo(timeSeriesDescription.LocationIdentifier);
var(exportDuration, exportLabel) = GetExportDuration(timeSeriesDescription);
var dataRequest = new TimeSeriesDataCorrectedServiceRequest
{
TimeSeriesUniqueId = timeSeriesDescription.UniqueId,
QueryFrom = GetInitialQueryFrom(detectedChange),
ApplyRounding = Context.ApplyRounding,
};
var existingSensor = Sos.FindExistingSensor(timeSeriesDescription);
var deleteExistingSensor = clearExportedData && existingSensor != null;
var assignedOffering = existingSensor?.Identifier;
var lastSensorTime = GetLastSensorTime(existingSensor);
if (HaveExistingSosPointsChanged(dataRequest, lastSensorTime, detectedChange, timeSeriesDescription))
{
Log.Warn($"FirstPointChanged={detectedChange.FirstPointChanged:O} AttributeChange={detectedChange.HasAttributeChange} of '{timeSeriesDescription.Identifier}' precedes LastSensorTime={lastSensorTime:O} of '{existingSensor?.Identifier}'. Forcing delete of existing sensor.");
// A point has changed before the last known observation, so we'll need to throw out the entire sensor
deleteExistingSensor = true;
// We'll also need to fetch more data again
dataRequest.QueryFrom = null;
}
if (dataRequest.QueryFrom == null)
{
// Get the full extraction
var endPoint = dataRequest.QueryTo ?? DateTimeOffset.Now;
var startOfToday = new DateTimeOffset(endPoint.Year, endPoint.Month, endPoint.Day, 0, 0, 0,
timeSeriesDescription.UtcOffsetIsoDuration.ToTimeSpan());
dataRequest.QueryFrom = startOfToday - exportDuration;
}
Log.Info($"Fetching changes from '{timeSeriesDescription.Identifier}' FirstPointChanged={detectedChange.FirstPointChanged:O} HasAttributeChanged={detectedChange.HasAttributeChange} QueryFrom={dataRequest.QueryFrom:O} ...");
var timeSeries = Aquarius.Publish.Get(dataRequest);
TrimExcludedPoints(timeSeriesDescription, timeSeries);
var createSensor = existingSensor == null || deleteExistingSensor;
TimeSeriesPointFilter.FilterTimeSeriesPoints(timeSeries);
var exportSummary = $"{timeSeries.NumPoints} points [{timeSeries.Points.FirstOrDefault()?.Timestamp.DateTimeOffset:O} to {timeSeries.Points.LastOrDefault()?.Timestamp.DateTimeOffset:O}] from '{timeSeriesDescription.Identifier}' with ExportDuration={exportLabel}";
ExportedTimeSeriesCount += 1;
ExportedPointCount += timeSeries.NumPoints ?? 0;
if (Context.DryRun)
{
if (deleteExistingSensor)
{
LogDryRun($"Would delete existing sensor '{existingSensor?.Identifier}'");
}
if (createSensor)
{
LogDryRun($"Would create new sensor for '{timeSeriesDescription.Identifier}'");
}
LogDryRun($"Would export {exportSummary}.");
return;
}
Log.Info($"Exporting {exportSummary} ...");
if (deleteExistingSensor)
{
Sos.DeleteSensor(timeSeries);
Sos.DeleteDeletedObservations();
}
if (createSensor)
{
var sensor = Sos.InsertSensor(timeSeries);
assignedOffering = sensor.AssignedOffering;
}
Sos.InsertObservation(assignedOffering, locationInfo.LocationData, locationInfo.LocationDescription, timeSeries);
}
private bool HaveExistingSosPointsChanged(
TimeSeriesDataCorrectedServiceRequest dataRequest,
DateTimeOffset?lastSensorTime,
TimeSeriesChangeEvent detectedChange,
TimeSeriesDescription timeSeriesDescription)
{
if (detectedChange.HasAttributeChange ?? false)
{
return(true);
}
if (!detectedChange.FirstPointChanged.HasValue || !lastSensorTime.HasValue)
{
return(false);
}
if (lastSensorTime < detectedChange.FirstPointChanged)
{
return(false);
}
var timeSeriesIdentifier = timeSeriesDescription.Identifier;
var sosPoints = new Queue <TimeSeriesPoint>(Sos.GetObservations(timeSeriesDescription, AddMilliseconds(detectedChange.FirstPointChanged.Value, -1), AddMilliseconds(lastSensorTime.Value, 1)));
var aqtsPoints = new Queue <TimeSeriesPoint>(Aquarius.Publish.Get(dataRequest).Points);
var sosCount = sosPoints.Count;
var aqtsCount = aqtsPoints.Count;
Log.Info($"Fetched {sosCount} SOS points and {aqtsCount} AQUARIUS points for '{timeSeriesIdentifier}' from {dataRequest.QueryFrom:O} ...");
while (sosPoints.Any() || aqtsPoints.Any())
{
var sosPoint = sosPoints.FirstOrDefault();
var aqtsPoint = aqtsPoints.FirstOrDefault();
if (aqtsPoint == null)
{
Log.Warn($"'{timeSeriesIdentifier}': AQUARIUS now has fewer points than SOS@{sosPoint?.Timestamp.DateTimeOffset:O}");
return(true);
}
if (sosPoint == null)
{
break;
}
var aqtsValue = (dataRequest.ApplyRounding ?? false)
? double.Parse(aqtsPoint.Value.Display)
: aqtsPoint.Value.Numeric;
var sosValue = sosPoint.Value.Numeric;
if (sosPoint.Timestamp.DateTimeOffset != aqtsPoint.Timestamp.DateTimeOffset)
{
Log.Warn($"'{timeSeriesIdentifier}': Different timestamps: AQUARIUS={aqtsValue}@{aqtsPoint.Timestamp.DateTimeOffset:O} vs SOS={sosValue}@{sosPoint.Timestamp.DateTimeOffset:O}");
return(true);
}
if (!DoubleHelper.AreSame(aqtsValue, sosValue))
{
Log.Warn($"'{timeSeriesIdentifier}': Different values @ {aqtsPoint.Timestamp.DateTimeOffset:O}: AQUARIUS={aqtsValue} vs SOS={sosValue}");
return(true);
}
sosPoints.Dequeue();
aqtsPoints.Dequeue();
}
Log.Info($"'{timeSeriesDescription.Identifier}': All {sosCount} SOS points match between SOS and AQUARIUS.");
dataRequest.QueryFrom = lastSensorTime.Value.AddTicks(1);
return(false);
}
public void TestKnownHashes()
{
TestClass[] tests = new TestClass[] {
new TestClass("abc", 0xA9993E36, 0x4706816A, 0xBA3E2571, 0x7850C26C, 0x9Cd0d89D),
new TestClass("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
0x84983E44, 0x1C3BD26E, 0xBAAE4AA1, 0xF95129E5, 0xE54670F1),
new TestClass("12345678901234567890123456789012345678901234567890123456789012345678901234567890",
0x50ABF570, 0x6A150990, 0xA08B2C5E, 0xA40FA0E5, 0x85554732),
new TestClass("jafdnznjkl89fn4q3poiunqn8vrnaru8apr8umpau8rfpnu312--1-0-139-110un45paiouwepiourpoqiwrud0-ur238901unmxd-0r1u-rdu0-12u3rm-u-uqfoprufquwioperupauwperuq2cfurq2urduq;w3uirmparuw390peuaf;wuir;oui;avuwao; aro aruawrv au;ru ;aweuriafuwer23f0quprmpuqpuqurq[0q5tau=53una54fion[5cnuq30m5uq903uqncf4",
0xEEC53E5E, 0x78191154, 0x0A073AE1, 0x39743E68, 0x8A6CD077),
};
Sha1Builder reusedShaBuilder = new Sha1Builder();
for (int i = 0; i < tests.Length; i++)
{
TestClass test = tests[i];
//
// Test using 1 call
//
{
Sha1Builder newShaBuilder = new Sha1Builder();
newShaBuilder.Add(test.contentBytes, 0, test.contentBytes.Length);
reusedShaBuilder.Add(test.contentBytes, 0, test.contentBytes.Length);
var newFinished = newShaBuilder.Finish(false);
var reusedFinished = reusedShaBuilder.Finish(true);
Console.WriteLine("Content '{0}'", test.contentString);
Console.WriteLine(" Expected {0}", test.expectedHash);
Console.WriteLine(" Actual {0}", newFinished);
Console.WriteLine(" Reused {0}", reusedFinished);
Assert.AreEqual(test.expectedHash, newFinished);
Assert.AreEqual(test.expectedHash, reusedFinished);
//String sosDiff = Sos.Diff(test.expectedHash, finished);
//Assert.IsNull(sosDiff, sosDiff);
}
//
// Test using multiple calls
//
for (int addLength = 1; addLength < test.contentBytes.Length; addLength++)
{
Console.WriteLine("Test AddLength {0}", addLength);
Sha1Builder shaBuilder = new Sha1Builder();
// Add the bytes
Int32 bytesToWrite = test.contentBytes.Length;
Int32 contentBytesOffset = 0;
while (bytesToWrite > 0)
{
Int32 writeLength = Math.Min(bytesToWrite, addLength);
shaBuilder.Add(test.contentBytes, contentBytesOffset, writeLength);
reusedShaBuilder.Add(test.contentBytes, contentBytesOffset, writeLength);
contentBytesOffset += writeLength;
bytesToWrite -= writeLength;
}
var shaFinished = shaBuilder.Finish(false);
var reusedShaFinished = reusedShaBuilder.Finish(true);
var sosDiff = Sos.Diff(test.expectedHash, shaFinished);
if (sosDiff != null)
{
Console.WriteLine("Content '{0}'", test.contentString);
Console.WriteLine(" Expected {0}", test.expectedHash);
Console.WriteLine(" Actual {0}", shaFinished);
Assert.Fail();
}
Assert.AreEqual(test.expectedHash, shaFinished);
Assert.AreEqual(test.expectedHash, reusedShaFinished);
}
}
}
private void ExportTimeSeries(
bool clearExportedData,
TimeSeriesChangeEvent detectedChange,
TimeSeriesDescription timeSeriesDescription)
{
Log.Info($"Fetching changes from '{timeSeriesDescription.Identifier}' FirstPointChanged={detectedChange.FirstPointChanged:O} HasAttributeChanged={detectedChange.HasAttributeChange} ...");
var locationInfo = GetLocationInfo(timeSeriesDescription.LocationIdentifier);
var period = GetTimeSeriesPeriod(timeSeriesDescription);
var dataRequest = new TimeSeriesDataCorrectedServiceRequest
{
TimeSeriesUniqueId = timeSeriesDescription.UniqueId,
QueryFrom = GetInitialQueryFrom(detectedChange),
ApplyRounding = Context.ApplyRounding,
};
var existingSensor = Sos.FindExistingSensor(timeSeriesDescription);
var deleteExistingSensor = clearExportedData && existingSensor != null;
var assignedOffering = existingSensor?.Identifier;
var timeSeries = FetchMinimumTimeSeries(detectedChange, timeSeriesDescription, existingSensor, dataRequest, ref deleteExistingSensor, ref period);
var createSensor = existingSensor == null || deleteExistingSensor;
TimeSeriesPointFilter.FilterTimeSeriesPoints(timeSeries);
var exportSummary = $"{timeSeries.NumPoints} points [{timeSeries.Points.FirstOrDefault()?.Timestamp.DateTimeOffset:O} to {timeSeries.Points.LastOrDefault()?.Timestamp.DateTimeOffset:O}] from '{timeSeriesDescription.Identifier}' with Frequency={period}";
ExportedTimeSeriesCount += 1;
ExportedPointCount += timeSeries.NumPoints ?? 0;
if (Context.DryRun)
{
if (deleteExistingSensor)
{
LogDryRun($"Would delete existing sensor '{existingSensor?.Identifier}'");
}
if (createSensor)
{
LogDryRun($"Would create new sensor for '{timeSeriesDescription.Identifier}'");
}
LogDryRun($"Would export {exportSummary}.");
return;
}
Log.Info($"Exporting {exportSummary} ...");
if (deleteExistingSensor)
{
Sos.DeleteSensor(timeSeries);
Sos.DeleteDeletedObservations();
}
if (createSensor)
{
var sensor = Sos.InsertSensor(timeSeries);
assignedOffering = sensor.AssignedOffering;
}
Sos.InsertObservation(assignedOffering, locationInfo.LocationData, locationInfo.LocationDescription, timeSeries, timeSeriesDescription);
}
