public bool Connect()
{
if (_TcpClient != null)
{
if (_TcpClient.Connected)
return true;
}
try
{
_TcpClient = new TcpClient();
_TcpClient.Connect(ServerAddress, ServerPort);
//_TcpClient.NoDelay = true;
BinaryBuffer buff = new BinaryBuffer();
buff.BeginWrite();
buff.WriteField(Username);
buff.WriteField(Password);
buff.EndWrite();
Database.WriteBuffer(buff.ByteBuffer, _TcpClient.GetStream());
}
catch (Exception)
{
if (_TcpClient != null)
{
if (_TcpClient.Connected)
{
_TcpClient.Close();
}
}
}
if (_TcpClient != null)
{
if (_TcpClient.Connected)
return true;
}
return false;
}
public PacketEventArgs(ushort packetID, int packetSize, BinaryBuffer packetData)
{
PacketID = packetID;
PacketSize = packetSize;
PacketData = packetData;
}
private int writeOType(BinaryBuffer buffer, Object value, OType valueType, OType? linkedType)
{
int pointer = 0;
switch (valueType)
{
case OType.Integer:
case OType.Long:
case OType.Short:
pointer = buffer.WriteVariant(Convert.ToInt32(value));
break;
case OType.String:
pointer = buffer.Write((string)value);
break;
case OType.Double:
pointer = buffer.Write((double)value);
break;
case OType.Float:
pointer = buffer.Write((float)value);
break;
case OType.Byte:
pointer = buffer.Write((byte)value);
break;
case OType.Boolean:
pointer = buffer.Write(((bool)value) ? (byte)1 : (byte)0);
break;
case OType.DateTime:
DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
pointer = buffer.WriteVariant((long)((DateTime)value - unixEpoch).TotalMilliseconds);
break;
//case OType.Decimal:
// /*
// * The Decimal is converted to an integer and stored as scale and value
// * (example "10234.546" is stored as scale "3" and value as:"10234546")
// * +---------------+-------------------+--------------+
// * | scale:byte[4] | valueSize:byte[4] | value:byte[] |
// * +---------------+-------------------+--------------+
// * scale an 4 byte integer that represent the scale of the value
// * valueSize the length of the value
// * bytes value the bytes that represent the value of the decimal in big-endian order.
// */
// var dec = ((decimal)value);
// byte[] bytes = BinarySerializer.ToArray(dec);
// var unscaledValueBytes = FromDecimal(dec);
// var unscaledValue = new BigInteger(unscaledValueBytes);
// break;
case OType.Link:
ORID rid = (ORID)value;
pointer = buffer.Write(rid);
break;
case OType.LinkList:
case OType.LinkSet:
var col = (ICollection<ORID>)value;
pointer = buffer.WriteVariant(col.Count);
foreach (var item in col)
{
if (item == null)
{
buffer.Write(NULL_RECORD_ID);
}
else
{
buffer.Write(item);
}
}
break;
case OType.LinkBag:
break;
default:
throw new NotImplementedException("Type " + valueType + " still not supported");
}
return pointer;
}
public byte[] Serialize(ODocument document)
{
var buffer = new BinaryBuffer();
ODocument schema = null; // Until Implementing schema this is null class
// Version
buffer.Add((byte)SERIALIZER_VERSION);
// Class Name
if (!String.IsNullOrEmpty(document.OClassName))
{
buffer.WriteVariant(document.OClassName.Length);
var className = BinarySerializer.ToArray(document.OClassName);
buffer.AddRange(className);
}
else
{
var length = BinarySerializer.ToArray((int)0);
buffer.AddRange(length);
}
// Header
var propNames = document.Keys.Where(k => !k.StartsWith("@")).ToArray();
var pos = new int[propNames.Length];
var val = new KeyValuePair<string, Object>[propNames.Length];
for (var i = 0; i < propNames.Length; i++)
{
var prop = propNames[i];
if (schema != null)
{
}
else
{
buffer.WriteVariant(prop.Length);
var propName = BinarySerializer.ToArray(prop);
buffer.AddRange(propName);
pos[i] = buffer.Allocate(sizeof(int) + 1);
}
val[i] = new KeyValuePair<string, object>(prop, document.GetField<object>(prop));
}
buffer.WriteVariant(0); // Header stop byte
// Data
for (int i = 0; i < val.Length; i++)
{
int pointer = 0;
var value = val[i].Value;
if (value != null)
{
var valueType = TypeConverter.TypeToDbName(value.GetType());
pointer = writeOType(buffer, value, valueType, getLinkedType(valueType, val[i].Key));
buffer.Write(pos[i], pointer);
if (schema == null)
{
buffer.Write((pos[i] + sizeof(int)), (byte)valueType);
}
}
}
return buffer.ToArray();
}
private string SerializeObjectValue(object value, Type valueType)
{
StringBuilder bld = new StringBuilder();
if ((valueType.IsArray) || (valueType.GetTypeInfo().IsGenericType))
{
if (valueType.Name == "Dictionary`2")
{
bld.Append("{");
IDictionary<string, object> collection = (IDictionary<string, object>)value;
bool first = true;
foreach (var keyVal in collection)
{
if (!first)
bld.Append(",");
first = false;
string serialized = SerializeValue(keyVal.Value);
bld.Append("\"" + keyVal.Key + "\":" + serialized);
}
bld.Append("}");
}
else
{
bld.Append(valueType.Name == "HashSet`1" ? "<" : "[");
IEnumerable collection = (IEnumerable)value;
bool first = true;
foreach (object val in collection)
{
if (!first)
bld.Append(",");
first = false;
bld.Append(SerializeValue(val));
}
bld.Append(valueType.Name == "HashSet`1" ? ">" : "]");
}
}
// if property is ORID type it needs to be serialized as ORID
else if (valueType.GetTypeInfo().IsClass && (valueType.Name == "ORID"))
{
bld.Append(((ORID)value).RID);
}
else if (valueType.GetTypeInfo().IsClass && (valueType.Name == "ODocument"))
{
bld.AppendFormat("({0})", SerializeDocument((ODocument)value));
}
else if (valueType.GetTypeInfo().IsClass && (valueType.Name == "OEmbeddedRidBag"))
{
//bld.AppendFormat("({0})", SerializeDocument((ODocument)value));
OEmbeddedRidBag ridbag = (OEmbeddedRidBag)value;
if (ridbag.Count > 0)
{
BinaryBuffer buffer = new BinaryBuffer();
bld.Append("%");
buffer.Write((byte)1); // config
buffer.Write(ridbag.Count); //size
foreach (var item in ridbag)
{
buffer.Write(item);
}
bld.Append(Convert.ToBase64String(buffer.ToArray()));
bld.Append(";");
}
}
return bld.ToString();
}
private void ReadEV3Directory(bool resetposition)
{
MemoryStream data = new MemoryStream();
// if (!ev3path.Equals("/proc/")) // avoid locking up the brick
{
// get data from brick
BinaryBuffer b = new BinaryBuffer();
b.Append16(500); // expect max 500 bytes per packet
b.AppendZeroTerminated(internalPath(ev3path));
byte[] response = connection.SystemCommand(EV3Connection.LIST_FILES, b);
if (response == null)
{
throw new Exception("No response to LIST_FILES");
}
if (response.Length < 6)
{
throw new Exception("Response too short for LIST_FILES");
}
if (response[0] != EV3Connection.SUCCESS && response[0] != EV3Connection.END_OF_FILE)
{
throw new Exception("Unexpected status at LIST_FILES: " + response[0]);
}
int handle = response[5] & 0xff;
data.Write(response, 6, response.Length - 6);
// continue reading until have total buffer
while (response[0] != EV3Connection.END_OF_FILE)
{
b.Clear();
b.Append8(handle);
b.Append16(500); // expect max 500 bytes per packet
response = connection.SystemCommand(EV3Connection.CONTINUE_LIST_FILES, b);
// Console.WriteLine("follow-up response length: " + response.Length);
if (response == null)
{
throw new Exception("No response to CONTINUE_LIST_FILES");
}
if (response.Length < 2)
{
throw new Exception("Too short response to CONTINUE_LIST_FILES");
}
if (response[0] != EV3Connection.SUCCESS && response[0] != EV3Connection.END_OF_FILE)
{
throw new Exception("Unexpected status at CONTINUE_LIST_FILES: " + response[0]);
}
// Console.WriteLine("subsequent response length: " + response.Length);
data.Write(response, 2, response.Length - 2);
}
}
List <DirectoryEntry> list = new List <DirectoryEntry>();
data.Position = 0; // start reading at beginning
StreamReader tr = new StreamReader(data, Encoding.GetEncoding("iso-8859-1"));
String l;
while ((l = tr.ReadLine()) != null)
{
if (l.EndsWith("/"))
{
String n = l.Substring(0, l.Length - 1);
if ((!n.Equals(".")) && (!n.Equals("..")))
{
list.Add(new DirectoryEntry(n, 0, true));
}
}
else
{
int firstspace = l.IndexOf(' ');
if (firstspace < 0)
{
continue;
}
int secondspace = l.IndexOf(' ', firstspace + 1);
if (secondspace < 0)
{
continue;
}
int size = int.Parse(l.Substring(firstspace, secondspace - firstspace).Trim(), System.Globalization.NumberStyles.HexNumber);
list.Add(new DirectoryEntry(l.Substring(secondspace + 1), size, false));
}
}
// sort list
list.Sort((x, y) => x.FileName.CompareTo(y.FileName));
// put data into listview
EV3Directory.Items.Clear();
foreach (DirectoryEntry de in list)
{
EV3Directory.Items.Add(de);
}
// let the WPF system re-calculate all column widths so everthing fits as good as possible
foreach (var gvc in EV3DirectoryGridView.Columns)
{
gvc.Width = gvc.ActualWidth;
gvc.Width = Double.NaN;
}
// move the controls scroller to top position
if (resetposition)
{
if (EV3Directory.Items.Count > 0)
{
EV3Directory.ScrollIntoView(EV3Directory.Items[0]);
}
}
}
/// <summary>
/// This will only be used if the server is linked to MYSQL, This will be changed.
/// </summary>
/// <param name="Query"></param>
/// <param name="useParentconnection"></param>
/// <param name="args"></param>
/// <returns></returns>
public bool SetDataTable(string Query, bool useParentconnection, params string[] args)
{
bool Result = false;
if (Connect())
{
BinaryBuffer buff = new BinaryBuffer();
buff.BeginWrite();
args = args ?? new string[] { };
buff.Write(1);
buff.Write(args.Length);
for (int i = 0; i < args.Length; i++)
buff.WriteField(args[i]);
buff.Write((byte)0);
buff.WriteField(Query);
buff.EndWrite();
try
{
Database.WriteBuffer(buff.ByteBuffer, _TcpClient.GetStream());
byte[] data = Database.ReadBuffer(_TcpClient.GetStream());
BinaryBuffer buffRead = new BinaryBuffer(data);
buffRead.BeginRead();
buffRead.ReadInt();
Result = buffRead.ReadByte() == (byte)1;
buffRead.EndRead();
}
catch (Exception)
{
}
if (!useParentconnection)
Disconnect();
}
return Result;
}
protected int GetInt4(DataRow row)
{
return(BinaryBuffer.ReadIntNetwork(row.Data, 0));
}
/// <summary>
/// Only If Server is MYSQL.
/// </summary>
/// <param name="Query"></param>
/// <param name="useParentconnection"></param>
/// <param name="args"></param>
/// <returns></returns>
public DataTable GetDataTable(string Query, bool useParentconnection, params string[] args)
{
DataTable dt = null;
if (Connect())
{
BinaryBuffer buff = new BinaryBuffer();
buff.BeginWrite();
args = args ?? new string[] { };
buff.Write(1);
buff.Write(args.Length);
for (int i = 0; i < args.Length; i++)
buff.WriteField(args[i]);
buff.Write((byte)1);
buff.WriteField(Query);
buff.EndWrite();
try
{
Database.WriteBuffer(buff.ByteBuffer, _TcpClient.GetStream());
byte[] data = Database.ReadBuffer(_TcpClient.GetStream());
dt = BinaryBuffer.ConvertBlobToDataTable(ref data);
}
catch (Exception)
{
}
if (!useParentconnection)
Disconnect();
}
return dt;
}
public override unsafe IReadOnlyList <T> DecodeBinary(
DataRow row, PostgresClientState state)
{
// TODO
if (row.Length < 4 * 0)
{
// TODO
throw new Exception();
}
// https://stackoverflow.com/questions/4016412/postgresqls-libpq-encoding-for-binary-transport-of-array-data
fixed(byte *dataPtrBase = row.Data)
{
var dimentions = BinaryBuffer
.ReadIntNetworkUnsafe(dataPtrBase);
var noNullBitmap = BinaryBuffer
.ReadIntNetworkUnsafe(&dataPtrBase[4 * 1]);
var oid = BinaryBuffer
.ReadIntNetworkUnsafe(&dataPtrBase[4 * 2]);
if (dimentions < 1)
{
throw new ArgumentOutOfRangeException(
nameof(dimentions), dimentions,
"Invalid dimention count.");
}
if (oid < 1)
{
throw new ArgumentOutOfRangeException(
nameof(oid), oid,
"Invalid oid.");
}
var hasDimentions = dimentions > 1;
if (hasDimentions)
{
throw new ArgumentOutOfRangeException(
nameof(dimentions), dimentions,
"Multi-dimentional arrays are not supported.");
}
var dimentionalArray = hasDimentions
? new List <IReadOnlyList <T> >(dimentions)
: null;
var dataPtr = &dataPtrBase[4 * 3];
for (var dimention = 0; dimention < dimentions; ++dimention)
{
var elementCount = BinaryBuffer
.ReadIntNetworkUnsafe(dataPtr);
dataPtr = &dataPtr[4];
// TODO:
var firstIndex = BinaryBuffer
.ReadIntNetworkUnsafe(dataPtr);
dataPtr = &dataPtr[4];
IReadOnlyList <T> array;
if (elementCount == 0)
{
array = EmptyArray <T> .Value;
}
else
{
var length = row.Data.Length - (dataPtr - dataPtrBase);
array = _wrappedCodec.DecodeBinaryArray(
dataPtr, (int)length, elementCount, state);
}
if (!hasDimentions)
{
return(array);
}
dimentionalArray.Add(array);
}
throw new ArgumentOutOfRangeException(
nameof(dimentions), dimentions,
"Multi-dimentional arrays are not supported.");
}
}
public override long DecodeBinary(DataRow row, PostgresClientState state)
{
PostgresTypeConverter.DemandDataLength(row, 8);
return(BinaryBuffer.ReadLongNetworkUnsafe(row.Data, 0));
}
protected virtual void OnPacketReceived(ushort packetID, int packetSize, BinaryBuffer packetData)
{
EventHandler<PacketEventArgs> pr = PacketReceived;
if (pr != null)
pr(this, new PacketEventArgs(packetID, packetSize, packetData));
}
public void Send(BinaryBuffer data)
{
Send(data.GetData());
}
public void CopyTo(BinaryBuffer target)
{
target.AppendBytes(buffer, 0, len);
}
public void BinaryBufferUnserialize(BinaryBuffer buffer)
{
}
public StageConfig(BinaryBuffer buffer)
{
BinaryBufferUnserialize(buffer);
}
