public void MoveToDataSimple()
{
using (var tx = fixture.Env.BeginReadOnlyTransaction()) {
using (var cursor = fixture.Db.OpenMultiValueCursor(tx)) {
var keyData = new KeyDataPair(BitConverter.GetBytes(4), Encoding.UTF8.GetBytes("Test Data"));
KeyDataPair entry;
Assert.True(cursor.GetNearest(keyData, out entry));
}
}
}
private void ProcessProxyResponseHeaders(HttpResponseDataChunk response)
{
List <KeyDataPair <string> > headers = new List <KeyDataPair <string> >(response.Headers);
int i = 0;
while (i < headers.Count)
{
KeyDataPair <string> pair = headers[i];
// We don't send connection headers
if (pair.Name.Equals("Connection", StringComparison.OrdinalIgnoreCase) || pair.Name.Equals("Proxy-Connection"))
{
headers.RemoveAt(i);
}
else
{
++i;
}
}
}
public void IterateOverDuplicatesRange()
{
int key = DatabaseFixture.FirstCount + DatabaseFixture.Gap;
if (key % 2 == 0)
{
key++; // make sure it is odd
}
var keyBytes = BitConverter.GetBytes(key);
int dupIndex = 2;
string startData = fixture.TestData[key][dupIndex];
var startDataBytes = Encoding.UTF8.GetBytes(startData);
string endData = fixture.TestData[key][DatabaseFixture.SecondCount - 1];
var endDataBytes = Encoding.UTF8.GetBytes(endData);
var startEntry = new KeyDataPair(keyBytes, startDataBytes);
var endEntry = new KeyDataPair(keyBytes, endDataBytes);
using (var tx = fixture.Env.BeginReadOnlyTransaction()) {
using (var cursor = fixture.Db.OpenMultiValueCursor(tx)) {
Assert.True(cursor.GetAt(startEntry, out var tmpEntry));
foreach (var dataBytes in cursor.ValuesForwardFromCurrent)
{
if (fixture.Db.DupCompare(tx, dataBytes, endDataBytes) > 0) // end of range test
{
break;
}
var cdata = Encoding.UTF8.GetString(dataBytes);
Assert.Equal(fixture.TestData[key][dupIndex], cdata);
dupIndex++;
output.WriteLine($"{key}: {cdata}");
}
}
}
}
public void MoveToData()
{
var buffer = new byte[1024];
using (var tx = fixture.Env.BeginReadOnlyTransaction()) {
using (var cursor = fixture.Db.OpenMultiValueCursor(tx)) {
var keyBytes = BitConverter.GetBytes(4);
var dataString = fixture.TestData[4][0];
int byteCount = Encoding.UTF8.GetBytes(dataString, 0, dataString.Length, buffer, 0);
var keyData = new KeyDataPair(keyBytes, new ReadOnlySpan <byte>(buffer, 0, byteCount));
Assert.True(cursor.GetAt(keyData, out KeyDataPair entry));
var ckey = BitConverter.ToInt32(entry.Key);
Assert.Equal(4, ckey);
var cdata = Encoding.UTF8.GetString(entry.Data);
Assert.Equal(fixture.TestData[4][0], cdata);
output.WriteLine($"{ckey}: {cdata}");
int secondIndx = DatabaseFixture.FirstCount + DatabaseFixture.Gap;
if (secondIndx % 2 == 0)
{
secondIndx++; // make sure it is odd
}
keyBytes = BitConverter.GetBytes(secondIndx);
dataString = $"Test Data {secondIndx}bty"; // this is between the second and third duplicate (b, c)
byteCount = Encoding.UTF8.GetBytes(dataString, 0, dataString.Length, buffer, 0);
keyData = new KeyDataPair(keyBytes, new ReadOnlySpan <byte>(buffer, 0, byteCount));
Assert.True(cursor.GetNearest(keyData, out entry));
ckey = BitConverter.ToInt32(entry.Key);
Assert.Equal(secondIndx, ckey);
cdata = Encoding.UTF8.GetString(entry.Data);
Assert.Equal(fixture.TestData[secondIndx][2], cdata); // we should be positioned at the third duplicate
output.WriteLine($"{ckey}: {cdata}");
}
}
}
private void SortField(string field)
{
List <KeyDataPair> sortedList = new List <KeyDataPair>();
foreach (string country in CountryHash.Keys)
{
System.Collections.Hashtable fieldHash = (System.Collections.Hashtable)CountryHash[country];
if (fieldHash.Contains(field))
{
try
{
double d = (double)fieldHash[field];
KeyDataPair kp = new KeyDataPair(country, d);
sortedList.Add(kp);
}
catch
{ }
}
}
sortedList.Sort();
SortedFieldData.Add(field, sortedList);
}
private void ProcessProxyRequestHeaders(HttpRequestHeader request)
{
int i = 0;
// If we have a request for a client version which will close then ensure the job is done
if (request.Version.IsVersionUnknown || request.Version.IsVersion10 || _server._config.Version10Proxy)
{
_closeConnection = true;
}
while (i < request.Headers.Count)
{
KeyDataPair <string> pair = request.Headers[i];
// Just remove, we already have handled this
if (pair.Name.Equals("Proxy-Authorization", StringComparison.OrdinalIgnoreCase))
{
request.Headers.RemoveAt(i);
}
else if (pair.Name.Equals("Connection", StringComparison.OrdinalIgnoreCase) ||
pair.Name.Equals("Proxy-Connection", StringComparison.OrdinalIgnoreCase))
{
// If sender wants the connection close then signal it for next response
if (pair.Value.Equals("close", StringComparison.OrdinalIgnoreCase))
{
_closeConnection = true;
}
request.Headers.RemoveAt(i);
}
else
{
++i;
}
}
}
public int CompareTo(object o)
{
KeyDataPair other = (KeyDataPair)o;
return(Data.CompareTo(other.Data));
}
public override DataFrame Read()
{
DataFrame frame = null;
try
{
if (_chunks == null || !_chunks.MoveNext())
{
char firstChar = _reader.ReadChar();
// Check whether we need to upgrade the connection to raw data, could even at this point actually implement
// TLS upgrade (and put back the HTTP parser on top?)
if (_isTransparent)
{
// If transparent send the first chunk along and don't increment enumerator
_chunks = BaseHttpDataAdapter.ReadFrames(new DataFrame(new byte[] { (byte)firstChar }), _reader).GetEnumerator();
}
else
{
_currentHeader = HttpParser.ReadRequestHeader(_reader, _layer._config.RequestStrictParsing, _logger, new char[] { firstChar });
if (_currentHeader.Version.IsVersion11 && _layer._config.Handle100Continue)
{
bool sendResponse = false;
int i = 0;
while (i < _currentHeader.Headers.Count)
{
KeyDataPair <string> header = _currentHeader.Headers[i];
// Remove expect headers
if (header.Name.Equals("Expect", StringComparison.OrdinalIgnoreCase) && header.Value.Equals("100-continue", StringComparison.OrdinalIgnoreCase))
{
_currentHeader.Headers.RemoveAt(i);
sendResponse = true;
}
else
{
i++;
}
}
if (sendResponse)
{
_adapter.Write(new DataFrame("HTTP/1.1 100 Continue\r\n\r\n"));
}
}
_chunks = _currentHeader.ReadFrames(CreateConfig(_currentHeader)).GetEnumerator();
}
// Increment to next chunk
if (!_chunks.MoveNext())
{
throw new EndOfStreamException();
}
}
frame = _chunks.Current;
}
catch (EndOfStreamException)
{
frame = null;
}
return(frame);
}
private void SortField(string field)
{
List<KeyDataPair> sortedList = new List<KeyDataPair>();
foreach (string country in CountryHash.Keys)
{
System.Collections.Hashtable fieldHash = (System.Collections.Hashtable)CountryHash[country];
if (fieldHash.Contains(field))
{
try
{
double d = (double)fieldHash[field];
KeyDataPair kp = new KeyDataPair(country, d);
sortedList.Add(kp);
}
catch
{ }
}
}
sortedList.Sort();
SortedFieldData.Add(field, sortedList);
}
public HTTPData()
{
Headers = new KeyDataPair<string>[0];
Body = new byte[0];
}
public HTTPData()
{
Headers = new KeyDataPair <string> [0];
Body = new byte[0];
}
