public List <HTTPHeader> CreateHeaderCredentials()
{
List <HTTPHeader> headers = new List <HTTPHeader>();
if (this.passwordAuth != null)
{
var passwordAuthString = this.passwordAuth.GetUserName() + ":" + this.passwordAuth.GetPassword();
var passwordAuthData = Encoding.UTF8.GetBytes(passwordAuthString);
var httpHeader = new HTTPHeader(AuthenticationConstants.HEADER_KEY_AUTH_PASSWORD, System.Convert.ToBase64String(passwordAuthData));
headers.Add(httpHeader);
}
if (!string.IsNullOrEmpty(this.apiToken))
{
var httpHeader = new HTTPHeader(AuthenticationConstants.HEADER_KEY_AUTH_APITOKEN, this.apiToken);
headers.Add(httpHeader);
}
if (this.basicAuth != null)
{
var basicAuthString = this.basicAuth.GetUserName() + ":" + this.basicAuth.GetPassword();
var basicAuthData = Encoding.UTF8.GetBytes(basicAuthString);
var httpHeader = new HTTPHeader(AuthenticationConstants.HEADER_KEY_AUTH_BASIC, AuthenticationConstants.AUTH_BASIC_PREFIX + System.Convert.ToBase64String(basicAuthData));
headers.Add(httpHeader);
}
return(headers);
}
public SplitSdkApiClient(HTTPHeader header,
string baseUrl,
long connectionTimeOut,
long readTimeout,
IMetricsLog metricsLog = null) : base(header, baseUrl, connectionTimeOut, readTimeout, metricsLog)
{
}
public async ValueTask <int> ConsumeAsync(ReadOnlyMemory <byte> toConsume)
{
if (Header == null)
{
if (Parser == null)
{
Parser = new HTTPHeaderParser();
}
var consumed = await Parser.ConsumeAsync(toConsume);
if (consumed > -1)
{
toConsume = toConsume.Slice(consumed);
Header = await Parser.GetProductAsync();
Console.WriteLine("Header done.");
}
}
if (Header != null)
{
Console.WriteLine($"Read {Encoding.UTF8.GetString(toConsume.Span)}");
}
return(-1);
}
public void ExecuteGetWithoutResults()
{
//Arrange
var baseUrl = "https://sdk-aws-staging.split.io/api/";
var httpHeader = new HTTPHeader()
{
authorizationApiKey = "0",
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "net-0.0.0",
splitSDKSpecVersion = "1.2",
};
var sdkApiClient = new SplitSdkApiClient(httpHeader, baseUrl, 10000, 10000);
var apiSplitChangeFetcher = new ApiSplitChangeFetcher(sdkApiClient);
var sdkSegmentApiClient = new SegmentSdkApiClient(httpHeader, baseUrl, 10000, 10000);
var apiSegmentChangeFetcher = new ApiSegmentChangeFetcher(sdkSegmentApiClient);
var gates = new InMemoryReadinessGatesCache();
var segmentCache = new InMemorySegmentCache(new ConcurrentDictionary <string, Segment>());
var selfRefreshingSegmentFetcher = new SelfRefreshingSegmentFetcher(apiSegmentChangeFetcher, gates, 30, segmentCache, 4);
var splitParser = new InMemorySplitParser(selfRefreshingSegmentFetcher, segmentCache);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
var selfRefreshingSplitFetcher = new SelfRefreshingSplitFetcher(apiSplitChangeFetcher, splitParser, gates, 30, splitCache);
selfRefreshingSplitFetcher.Start();
//Act
gates.IsSDKReady(10);
var result = splitCache.GetSplit("condition_and");
//Assert
Assert.IsNull(result);
}
public void ExecuteGetSuccessfulWithResults()
{
//Arrange
var baseUrl = "https://sdk-aws-staging.split.io/api/";
var httpHeader = new HTTPHeader()
{
authorizationApiKey = "///PUT API KEY HERE///",
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "net-0.0.0",
splitSDKSpecVersion = "1.2",
};
var sdkApiClient = new SegmentSdkApiClient(httpHeader, baseUrl, 10000, 10000);
var apiSegmentChangeFetcher = new ApiSegmentChangeFetcher(sdkApiClient);
var gates = new InMemoryReadinessGatesCache();
var segmentCache = new InMemorySegmentCache(new ConcurrentDictionary <string, Segment>());
var selfRefreshingSegmentFetcher = new SelfRefreshingSegmentFetcher(apiSegmentChangeFetcher, gates, 30, segmentCache, 4);
//Act
var name = "payed";
selfRefreshingSegmentFetcher.InitializeSegment(name);
while (!gates.AreSegmentsReady(1000))
{
Thread.Sleep(10);
}
//Assert
Assert.IsTrue(segmentCache.IsInSegment(name, "abcdz"));
}
private static void AddHeadersToMessage(HTTPRequestMsg message,
IDictionary <string, IList <string> > requestHeaders)
{
foreach (var kvp in requestHeaders)
{
var header = new HTTPHeader();
header.Values.Add(kvp.Value);
message.Headers.Add(kvp.Key, header);
}
}
public static HTTPHeader ConvertExtToInt(this HTTPHeaderExt obj)
{
var convert = new HTTPHeader()
{
Name = obj.Name,
Value = obj.Value
};
return(convert);
}
public static HTTPHeaderExt ConvertIntToExt(this HTTPHeader obj)
{
var convert = new HTTPHeaderExt()
{
Name = obj.Name,
Value = obj.Value
};
return(convert);
}
public HandlePackage(
HTTPHeader requestHeader,
HTTPHeader responseHeader,
ContentStream requestContent,
ContentStream contentStream,
HTTPServer server)
{
this.RequestHeader = requestHeader;
this.ResponseHeader = responseHeader;
this.RequestContent = requestContent;
this.ContentStream = contentStream;
this.Server = server;
}
private void BuildSdkApiClients()
{
var header = new HTTPHeader();
header.authorizationApiKey = ApiKey;
header.encoding = HttpEncoding;
header.splitSDKVersion = SdkVersion;
header.splitSDKSpecVersion = SdkSpecVersion;
header.splitSDKMachineName = SdkMachineName;
header.splitSDKMachineIP = SdkMachineIP;
metricsSdkApiClient = new MetricsSdkApiClient(header, EventsBaseUrl, HttpConnectionTimeout, HttpReadTimeout);
BuildMetricsLog();
splitSdkApiClient = new SplitSdkApiClient(header, BaseUrl, HttpConnectionTimeout, HttpReadTimeout, metricsLog);
segmentSdkApiClient = new SegmentSdkApiClient(header, BaseUrl, HttpConnectionTimeout, HttpReadTimeout, metricsLog);
treatmentSdkApiClient = new TreatmentSdkApiClient(header, EventsBaseUrl, HttpConnectionTimeout, HttpReadTimeout);
}
public HTTPHeader RemoveHeader(string key)
{
foreach (HTTPHeader current in Headers)
{
if (current.Key == key)
{
HTTPHeader t = current;
Headers.Remove(current);
return(t);
}
}
return(null);
}
private void BuildSdkApiClients()
{
var header = new HTTPHeader
{
authorizationApiKey = ApiKey,
splitSDKVersion = _config.SdkVersion,
splitSDKSpecVersion = _config.SdkSpecVersion,
splitSDKMachineName = _config.SdkMachineName,
splitSDKMachineIP = _config.SdkMachineIP
};
_metricsSdkApiClient = new MetricsSdkApiClient(header, _config.EventsBaseUrl, _config.HttpConnectionTimeout, _config.HttpReadTimeout);
BuildMetricsLog();
_splitSdkApiClient = new SplitSdkApiClient(header, _config.BaseUrl, _config.HttpConnectionTimeout, _config.HttpReadTimeout, _metricsLog);
_segmentSdkApiClient = new SegmentSdkApiClient(header, _config.BaseUrl, _config.HttpConnectionTimeout, _config.HttpReadTimeout, _metricsLog);
_treatmentSdkApiClient = new TreatmentSdkApiClient(header, _config.EventsBaseUrl, _config.HttpConnectionTimeout, _config.HttpReadTimeout);
_eventSdkApiClient = new EventSdkApiClient(header, _config.EventsBaseUrl, _config.HttpConnectionTimeout, _config.HttpReadTimeout);
}
public async Task ExecuteGetShouldReturnEmptyIfNotAuthorized()
{
//Arrange
var baseUrl = "https://sdk.aws.staging.split.io/api";
var httpHeader = new HTTPHeader()
{
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "net-0.0.0",
splitSDKSpecVersion = "1.2"
};
var SplitSdkApiClient = new SplitSdkApiClient(httpHeader, baseUrl, 10000, 10000);
//Act
var result = await SplitSdkApiClient.FetchSplitChanges(-1);
//Assert
Assert.IsTrue(result == string.Empty);
}
public async void ExecuteGetShouldReturnErrorNotAuthorized()
{
//Arrange
var baseUrl = "http://demo7064886.mockable.io";
var httpHeader = new HTTPHeader()
{
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "1",
splitSDKSpecVersion = "2"
};
var SdkApiClient = new SdkApiClient(httpHeader, baseUrl, 10000, 10000);
//Act
var result = await SdkApiClient.ExecuteGet("/messages?item=msg2");
//Assert
Assert.AreEqual(result.statusCode, HttpStatusCode.Unauthorized);
}
public async Task ExecuteFetchSplitChangesSuccessful()
{
//Arrange
var baseUrl = "http://sdk-aws-staging.split.io/api/";
var httpHeader = new HTTPHeader()
{
authorizationApiKey = "///PUT API KEY HERE///",
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "net-0.0.0",
splitSDKSpecVersion = "1.2",
};
var SplitSdkApiClient = new SplitSdkApiClient(httpHeader, baseUrl, 10000, 10000);
//Act
var result = await SplitSdkApiClient.FetchSplitChanges(-1);
//Assert
Assert.IsTrue(result.Contains("splits"));
}
public async void ExecuteGetShouldReturnNotFoundOnInvalidRequest()
{
//Arrange
var baseUrl = "http://demo706abcd.mockable.io";
var httpHeader = new HTTPHeader()
{
authorizationApiKey = "ABCD",
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "1",
splitSDKSpecVersion = "2"
};
var SdkApiClient = new SdkApiClient(httpHeader, baseUrl, 10000, 10000);
//Act
var result = await SdkApiClient.ExecuteGet("/messages?item=msg2");
//Assert
Assert.AreEqual(result.statusCode, HttpStatusCode.NotFound);
}
public async void ExecuteGetSuccessful()
{
//Arrange
var baseUrl = "http://demo7064886.mockable.io";
var httpHeader = new HTTPHeader()
{
authorizationApiKey = "ABCD",
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "1",
splitSDKSpecVersion = "2"
};
var SdkApiClient = new SdkApiClient(httpHeader, baseUrl, 10000, 10000);
//Act
var result = await SdkApiClient.ExecuteGet("/messages?item=msg1");
//Assert
Assert.AreEqual(result.statusCode, HttpStatusCode.OK);
Assert.IsTrue(result.content.Contains("Hello World"));
}
public async Task ExecuteGetShouldReturnEmptyResponseOnInvalidURL()
{
//Arrange
var baseUrl = "http://demo70e.iio";
var httpHeader = new HTTPHeader()
{
authorizationApiKey = "ABCD",
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "1",
splitSDKSpecVersion = "2"
};
var SdkApiClient = new SdkApiClient(httpHeader, baseUrl, 10000, 10000);
//Act
var result = await SdkApiClient.ExecuteGet("/messages?item=msg2");
//Assert
Assert.IsNotNull(result);
Assert.IsNull(result.content);
}
public void ExecuteGetSuccessfulWithResults()
{
//Arrange
var baseUrl = "https://sdk-aws-staging.split.io/api/";
//var baseUrl = "http://localhost:3000/api/";
var httpHeader = new HTTPHeader()
{
authorizationApiKey = "///PUT API KEY HERE///",
splitSDKMachineIP = "1.0.0.0",
splitSDKMachineName = "localhost",
splitSDKVersion = "net-0.0.0",
splitSDKSpecVersion = "1.2",
encoding = "gzip"
};
var sdkApiClient = new SplitSdkApiClient(httpHeader, baseUrl, 10000, 10000);
var apiSplitChangeFetcher = new ApiSplitChangeFetcher(sdkApiClient);
var sdkSegmentApiClient = new SegmentSdkApiClient(httpHeader, baseUrl, 10000, 10000);
var apiSegmentChangeFetcher = new ApiSegmentChangeFetcher(sdkSegmentApiClient);
var gates = new InMemoryReadinessGatesCache();
var segmentCache = new InMemorySegmentCache(new ConcurrentDictionary <string, Segment>());
var selfRefreshingSegmentFetcher = new SelfRefreshingSegmentFetcher(apiSegmentChangeFetcher, gates, 30, segmentCache, 4);
var splitParser = new InMemorySplitParser(selfRefreshingSegmentFetcher, segmentCache);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
var selfRefreshingSplitFetcher = new SelfRefreshingSplitFetcher(apiSplitChangeFetcher, splitParser, gates, 30, splitCache);
selfRefreshingSplitFetcher.Start();
//Act
gates.IsSDKReady(1000);
selfRefreshingSplitFetcher.Stop();
ParsedSplit result = (ParsedSplit)splitCache.GetSplit("Pato_Test_1");
ParsedSplit result2 = (ParsedSplit)splitCache.GetSplit("Manu_Test_1");
//Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.name == "Pato_Test_1");
Assert.IsTrue(result.conditions.Count > 0);
}
private void SendRequest()
{
// Record when we first started the download
headerLength = 0;
startTime = DateTime.Now;
// Create a HTTP request using the Deusty.Net.HTTP.HTTPHeader class.
// The HTTP protocol is fairly straightforward, but this class helps hide protocol
// specific information that we're not really concerned with for this AsyncSocket sameple.
HTTPHeader request = HTTPHeader.CreateRequest("GET", FETCH_REQUEST);
request.SetHeaderFieldValue("Host", FETCH_HOST);
String requestStr = request.ToString();
LogInfo("Sending Request:");
LogMessage(requestStr);
// Convert HTTPHeader object to a byte array.
byte[] requestData = Encoding.UTF8.GetBytes(requestStr);
Console.WriteLine(Data.ToHexString(requestData));
// Now write the data over the socket.
// This call is asynchronous, and returns immediately.
// When finished writing, the asyncSocket_DidWrite method is called.
asyncSocket.Write(requestData, WRITE_TIMEOUT, HTTP_HEADERS);
// Setup http response
response = HTTPHeader.CreateEmptyResponse();
// And start reading in the response
asyncSocket.Read(AsyncSocket.CRLFData, READ_HEADER_TIMEOUT, HTTP_HEADERS);
// Reset progress bar
progressBar.Value = 0;
}
private static void CompleteDownload(LocalStorageFileState state)
{
bool flag = true;
object[] args = new object[] { state };
s_log.LogDebug("Download completed for State={0}", args);
HTTPHeader header = ParseHTTPHeader(state.FileData);
if (header == null)
{
object[] objArray2 = new object[] { state };
s_log.LogWarning("Parsinig of HTTP header failed for State={0}", objArray2);
}
else
{
byte[] destinationArray = new byte[header.ContentLength];
Array.Copy(state.FileData, header.ContentStart, destinationArray, 0, header.ContentLength);
if (ComputeSHA256(destinationArray) != state.CH.Sha256Digest)
{
object[] objArray3 = new object[] { state };
s_log.LogWarning("Integrity check failed for State={0}", objArray3);
}
else
{
flag = false;
DecompressStateIfPossible(state, destinationArray);
}
}
if (flag || (state.FileData == null))
{
ExecuteFailedDownload(state);
}
else
{
ExecuteSucessfulDownload(state);
}
}
public bool IsCoreRequest(HTTPHeader header)
{
return(header.URL.ToLower().StartsWith(this.coreString));
}
public MetricsSdkApiClient(HTTPHeader header, string baseUrl, long connectionTimeOut, long readTimeout)
: base(header, baseUrl, connectionTimeOut, readTimeout)
{
}
public Boolean GetHeaderAndBody(Stream myStream, out HTTPHeader myHttpHeader, out Byte[] myBody)
{
myHttpHeader = null;
myBody = null;
#region Data Definition
var ReadBuffer = new Byte[16 * 1024];
Int32 BytesRead = 0;
// TODO: Use an byte[] and resize it if needed
var FirstBytesList = new List <Byte>();
#endregion
#region Read the FirstBytes until no Data is available or we read more than we can store in a List of Bytes
do
{
BytesRead = myStream.Read(ReadBuffer, 0, ReadBuffer.Length);
if (BytesRead == ReadBuffer.Length)
{
FirstBytesList.AddRange(ReadBuffer);
}
else
{
var _TempBytes = new Byte[BytesRead];
Array.Copy(ReadBuffer, 0, _TempBytes, 0, BytesRead);
FirstBytesList.AddRange(_TempBytes);
}
}
//DataAvailable is not available for stream this is a problem if the saerver can't send the whole header
//while (myStream.DataAvailable && BytesRead > 0 && FirstBytesList.Count < (Int32.MaxValue - ReadBuffer.Length));
while (BytesRead > 0 && FirstBytesList.Count < (Int32.MaxValue - ReadBuffer.Length) && (BytesRead == ReadBuffer.Length));
#endregion
#region Find Header
Int32 CurPos = 4;
Byte[] FirstBytes = FirstBytesList.ToArray();
if (FirstBytes.Length <= CurPos)
{
// If header length < 4 we have an invalid header
myStream.Close();
return(false);
}
while ((CurPos < FirstBytes.Length) && !(FirstBytes[CurPos - 4] == 13 && FirstBytes[CurPos - 3] == 10 && FirstBytesList[CurPos - 2] == 13 && FirstBytesList[CurPos - 1] == 10))
{
CurPos++;
}
var HeaderBytes = new Byte[CurPos];
Array.Copy(FirstBytes, 0, HeaderBytes, 0, CurPos);
var HeaderString = Encoding.UTF8.GetString(HeaderBytes);
myHttpHeader = new HTTPHeader(HeaderString);
#endregion
#region Body
myBody = new Byte[myHttpHeader.ContentLength];
if (myHttpHeader.ContentLength > 0)
{
if (myHttpHeader.ContentLength < (UInt64)(FirstBytes.Length - CurPos))
{
// contentlength defined in the header is lower than the recieved bytes
return(false);
}
Array.Copy(FirstBytes, CurPos, myBody, 0, FirstBytes.Length - CurPos);
// Read the rest of the bytes
if (myHttpHeader.ContentLength > (UInt64)(FirstBytes.Length - CurPos))
{
var TotalBytesRead = (Int64)FirstBytes.Length - CurPos;
while ((UInt64)TotalBytesRead < myHttpHeader.ContentLength)
{
if (!WaitForStreamDataAvailable())
{
return(true);
}
BytesRead = myStream.Read(ReadBuffer, 0, ReadBuffer.Length);
Array.Copy(ReadBuffer, 0, myBody, TotalBytesRead, BytesRead);
TotalBytesRead += (Int64)BytesRead;
}
}
}
#endregion
return(true);
}
public static HTTPError Request(HTTPMethod method, string Url, object Addition, HTTPRequest.RequestCallback callback, HTTPCookie cookie = null, HTTPHeader additionHeader = null, string PostData = null)
{
HTTPStateObject state = new HTTPStateObject();
HTTPRequest request = new HTTPRequest()
{
method = method
};
Uri path = new Uri(Url);
request.Cookie = cookie?.GetCookie(path.Host);
request.Header = additionHeader;
request.Callback = callback;
request.Addition = Addition;
request.SetUrl(path.Scheme, path.PathAndQuery, path.Host);
request.PostData = PostData;
return(Request(request));
}
public void AddHeader(HTTPHeader header)
{
Headers.Add(header);
}
public HTTPRequest MakeRequest(HTTPMethod?method, string Url, object Addition, HTTPRequest.RequestCallback callback, HTTPCookie cookie = null, HTTPHeader additionHeader = null, string PostData = null)
{
Uri path = new Uri(Url);
if (path.Host != request.Host)
{
HTTPOp.Request(method.Value, Url, Addition, callback, cookie, additionHeader, PostData);
return(null);
}
else
{
HTTPRequest newRequest = request.CopyTo();
newRequest.method = method == null ? newRequest.method : method.Value;
newRequest.Url = path.PathAndQuery;
newRequest.Addition = Addition ?? newRequest.Addition;
newRequest.Callback = callback ?? newRequest.Callback;
//newRequest.Cookie = cookie ?? newRequest.Cookie ;
newRequest.Cookie = this.cookie?.AddCookie(cookie).GetCookie(path.Host);
newRequest.PostData = PostData;
//newRequest.Header = header ?? newRequest.Header ;
return(newRequest);
}
}
