/**
* Save the cookies from the last request.
*/
private void saveCookie(Env env)
{
WriteStream @out = null;
try {
string path = env.getPwd().lookup(_cookieFilename);
@out = path.openWrite();
int len = _cookie.length();
for (int i = 0; i < len; i++)
{
@out.write((byte)_cookie[i]);
}
}
catch (IOException e) {
throw new QuercusModuleException(e);
}
finally {
try {
if (@out != null)
{
@out.close();
}
}
catch (IOException e) {
// intentionally don't do anything
}
}
}
private void writeStreamClosed(WriteStream writeStream)
{
zipFile.Dispose();
try
{
using (var ionicZip = new Ionic.Zip.ZipFile(resourceLocation))
{
ionicZip.UpdateEntry(writeStream.FileName, writeStream.BaseStream);
ionicZip.Save();
}
--openWriteStreams;
if (openWriteStreams == 0)
{
if (Directory.Exists(tempFolder))
{
Directory.Delete(tempFolder, true);
}
}
else
{
File.Delete(writeStream.TempFileName);
}
}
finally
{
zipFile = new ZipFile(resourceLocation);
}
}
public int WriteLength(StreamContext context)
{
int length = 0;
if (context.fullModel)
{
// Mark unreliable properties as clean and flatten the in-flight cache.
// TODO: Move this out of WriteLength() once we have a prepareToWrite method.
_name = name;
_pointer = pointer;
_cache.Clear();
// Write all properties
length += WriteStream.WriteStringLength((uint)PropertyID.Name, _name);
length += WriteStream.WriteVarint32Length((uint)PropertyID.Pointer, _pointer ? 1u : 0u);
}
else
{
// Reliable properties
if (context.reliableChannel)
{
LocalCacheEntry entry = _cache.localCache;
if (entry.nameSet)
{
length += WriteStream.WriteStringLength((uint)PropertyID.Name, entry.name);
}
if (entry.pointerSet)
{
length += WriteStream.WriteVarint32Length((uint)PropertyID.Pointer, entry.pointer ? 1u : 0u);
}
}
}
return(length);
}
/**
* Closes the output buffer.
*/
public void close()
{
_state |= OutputModule.PHP_OUTPUT_HANDLER_END;
if (!callCallback())
{
// all data that has and ever will be written has now been processed
_state = 0;
doFlush();
}
WriteStream @out = _out;
_out = null;
TempStream tempStream = _tempStream;
_tempStream = null;
try {
if (@out != null)
{
@out.close();
}
} catch (IOException e) {
log.log(Level.FINER, e.ToString(), e);
}
if (tempStream != null)
{
tempStream.destroy();
}
}
public void Write(WriteStream stream, StreamContext context)
{
if (context.fullModel)
{
// Write all properties
stream.WriteString((uint)PropertyID.Name, _name);
stream.WriteVarint32((uint)PropertyID.Pointer, _pointer ? 1u : 0u);
}
else
{
// Reliable properties
if (context.reliableChannel)
{
LocalCacheEntry entry = _cache.localCache;
if (entry.nameSet || entry.pointerSet)
{
_cache.PushLocalCacheToInflight(context.updateID);
}
if (entry.nameSet)
{
stream.WriteString((uint)PropertyID.Name, entry.name);
}
if (entry.pointerSet)
{
stream.WriteVarint32((uint)PropertyID.Pointer, entry.pointer ? 1u : 0u);
}
}
}
}
public void Write(WriteStream stream, StreamContext context)
{
if (context.fullModel)
{
// Active state
stream.WriteVarint32((uint)Properties.ActiveState, _activeState);
// Device type
stream.WriteVarint32((uint)Properties.DeviceType, _deviceType);
}
else
{
// Active state
if (context.reliableChannel)
{
// If we're going to send an update. Push the cache to inflight.
LocalCacheEntry entry = _cache.localCache;
if (entry.activeStateSet || entry.deviceTypeSet)
{
_cache.PushLocalCacheToInflight(context.updateID);
}
if (entry.activeStateSet)
{
stream.WriteVarint32((uint)Properties.ActiveState, entry.activeState);
}
if (entry.deviceTypeSet)
{
stream.WriteVarint32((uint)Properties.DeviceType, entry.deviceType);
}
}
}
}
protected override void Write(WriteStream stream, StreamContext context)
{
var didWriteProperties = false;
if (context.fullModel)
{
stream.WriteVarint32((uint)PropertyID.ClientID, (uint)_clientID);
stream.WriteVarint32((uint)PropertyID.StreamID, (uint)_streamID);
}
else if (context.reliableChannel)
{
LocalCacheEntry entry = _cache.localCache;
if (entry.clientIDSet || entry.streamIDSet)
{
_cache.PushLocalCacheToInflight(context.updateID);
ClearCacheOnStreamCallback(context);
}
if (entry.clientIDSet)
{
stream.WriteVarint32((uint)PropertyID.ClientID, (uint)entry.clientID);
didWriteProperties = true;
}
if (entry.streamIDSet)
{
stream.WriteVarint32((uint)PropertyID.StreamID, (uint)entry.streamID);
didWriteProperties = true;
}
if (didWriteProperties)
{
InvalidateReliableLength();
}
}
}
static void test_serialization()
{
Log("test_serialization");
const int MaxPacketSize = 1024;
var serializer = new TestSerializer();
var buffer = new uint[MaxPacketSize / 4];
var writeStream = new WriteStream();
writeStream.Start(buffer);
TestStruct input;
input.bool_value = true;
input.int_value = -5;
input.uint_value = 215;
input.bits_value = 12345;
serializer.WriteTestStruct(writeStream, ref input);
writeStream.Finish();
var packet = writeStream.GetData();
var readStream = new ReadStream();
readStream.Start(packet);
TestStruct output;
serializer.ReadTestStruct(readStream, out output);
readStream.Finish();
AreEqual(input.bool_value, output.bool_value);
AreEqual(input.int_value, output.int_value);
AreEqual(input.uint_value, output.uint_value);
AreEqual(input.bits_value, output.bits_value);
}
public uint ToBytes(WriteStream stream)
{
uint size = 5;
var span = stream.Advance(4);
stream.WriteByte(4);
size += stream.WriteHeader(EventPropertyType.L_Date, 1);
size += stream.WriteHeader(EventPropertyType.L_32, 1);
size += stream.WriteHeader(EventPropertyType.L_64, 3);
size += stream.WriteHeader(EventPropertyType.L_Str, 5);
size += stream.WriteIndex(7);
size += stream.WriteDate(TradeTime);
size += stream.WriteIndex(9);
size += stream.WriteInt32(ZCVolume);
size += stream.WriteIndex(3);
size += stream.WriteDouble(LastPrice);
size += stream.WriteIndex(6);
size += stream.WriteUInt64(TotalVolume);
size += stream.WriteIndex(8);
size += stream.WriteUInt64(Volume);
size += stream.WriteIndex(0);
size += stream.WriteString(CommodityNo);
size += stream.WriteIndex(1);
size += stream.WriteString(ExchangeID);
size += stream.WriteIndex(2);
size += stream.WriteString(InstrumentID);
size += stream.WriteIndex(4);
size += stream.WriteString(Oper);
size += stream.WriteIndex(5);
size += stream.WriteString(InTime);
BitConverter.TryWriteBytes(span, size);
return(size);
}
public void Write(WriteStream stream, StreamContext context)
{
// Meta model
stream.WriteModel(0, _metaModel, context);
if (context.fullModel)
{
// Write all properties
if (_sceneViewUUID != null && _sceneViewUUID.Length > 0)
{
stream.WriteBytes((uint)PropertyID.SceneViewUUID, _sceneViewUUID);
}
if (_prefabName != null && _prefabName.Length > 0)
{
stream.WriteString((uint)PropertyID.PrefabName, _prefabName);
}
}
// Components
if (_componentsModel != null)
{
stream.WriteModel((uint)PropertyID.Components, _componentsModel, context);
}
// Child Views
if (_childViewsModel != null)
{
stream.WriteModel((uint)PropertyID.ChildViews, _childViewsModel, context);
}
}
// Serialization
public int WriteLength(StreamContext context)
{
int length = 0;
if (context.fullModel)
{
// Flatten cache
_clientID = clientID;
_streamID = streamID;
_cache.Clear();
// ClientID/StreamID
length += WriteStream.WriteVarint32Length(1, WriteStream.ConvertNegativeOneIntToUInt(_clientID));
length += WriteStream.WriteVarint32Length(2, WriteStream.ConvertNegativeOneIntToUInt(_streamID));
}
else
{
// ClientID/StreamID
if (context.reliableChannel)
{
LocalCacheEntry entry = _cache.localCache;
if (entry.clientIDSet)
{
length += WriteStream.WriteVarint32Length(1, WriteStream.ConvertNegativeOneIntToUInt(entry.clientID));
}
if (entry.streamIDSet)
{
length += WriteStream.WriteVarint32Length(2, WriteStream.ConvertNegativeOneIntToUInt(entry.streamID));
}
}
}
return(length);
}
private bool parseImageJpeg(ReadStream is)
{
int ch = @is.read();
if (ch != 0xff)
{
return(false);
}
if (@is.read() != 0xd8)
{
return(false);
}
TempStream ts = new TempStream();
WriteStream ws = new WriteStream(ts);
ws.write(0xff);
ws.write(0xd8);
@is.writeToStream(ws);
ws.close();
// XXX: issues with _jpegHead vs ts.openReadAndSaveBuffer()
_jpegHead = ts.getHead();
@is.close();
_is = new ReadStream();
ts.openRead(_is);
parseJPEG();
return(true);
}
public void Dispose()
{
_stream.Dispose();
_stream = null;
WriteStream.Dispose();
WriteStream = null;
}
private static void highlight(StringValue sb,
WriteStream @out,
StringValue string)
{
if (sb != null)
{
int len = string.length();
for (int i = 0; i < len; i++)
{
char ch = string[i];
switch (ch)
{
case '<':
sb.append("<");
break;
case '>':
sb.append(">");
break;
case ' ':
sb.append(" ");
break;
default:
sb.append(ch);
break;
}
}
}
else
{
int len = string.length();
for (int i = 0; i < len; i++)
{
char ch = string[i];
switch (ch)
{
case '<':
@out.print("<");
break;
case '>':
@out.print(">");
break;
case ' ':
@out.print(" ");
break;
default:
@out.print(ch);
break;
}
}
}
}
public void execute(ReadStream stream)
{
QuercusPage page = parse(stream);
WriteStream os = new WriteStream(StdoutStream.create());
os.setNewlineString("\n");
os.setEncoding("iso-8859-1");
Env env = createEnv(page, os, null, null);
env.start();
try {
env.execute();
} catch (QuercusDieException e) {
log.log(Level.FINER, e.ToString(), e);
} catch (QuercusExitException e) {
log.log(Level.FINER, e.ToString(), e);
} catch (QuercusErrorException e) {
log.log(Level.FINER, e.ToString(), e);
} finally {
env.close();
os.flush();
}
}
private bool parseImage()
{
_image = ImageIO.read(_is);
_width = _image.getWidth();
_height = _image.getHeight();
TempStream ts = new TempStream();
WriteStream os = new WriteStream(ts);
try {
ImageIO.write(_image, "jpeg", os);
} finally {
os.close();
}
/*
* os = Vfs.openWrite("file:/tmp/caucho/qa/test.jpg");
* try {
* ImageIO.write(_image, "jpeg", os);
* } finally {
* os.close();
* }
*
* os = Vfs.openWrite("file:/tmp/caucho/qa/test.png");
* try {
* ImageIO.write(_image, "png", os);
* } finally {
* os.close();
* }
*/
return(parseImageJpeg(ts.openRead()));
}
public int WriteLength(StreamContext context)
{
int length = 0;
// Meta model
length += WriteStream.WriteModelLength(0, _metaModel, context);
if (context.fullModel)
{
// Write all properties
if (_sceneViewUUID != null && _sceneViewUUID.Length > 0)
{
length += WriteStream.WriteBytesLength((uint)PropertyID.SceneViewUUID, _sceneViewUUID.Length);
}
if (_prefabName != null && _prefabName.Length > 0)
{
length += WriteStream.WriteStringLength((uint)PropertyID.PrefabName, _prefabName);
}
}
// Components
if (_componentsModel != null)
{
length += WriteStream.WriteModelLength((uint)PropertyID.Components, _componentsModel, context);
}
// Child Views
if (_childViewsModel != null)
{
length += WriteStream.WriteModelLength((uint)PropertyID.ChildViews, _childViewsModel, context);
}
return(length);
}
public void WriteTestStruct(WriteStream stream, ref TestStruct testStruct)
{
stream.Bool(testStruct.bool_value);
stream.Int(testStruct.int_value, -100, 100);
stream.Uint(testStruct.uint_value, 100, 1000);
stream.Bits(testStruct.bits_value, 23);
}
public void Write(WriteStream stream, StreamContext context)
{
foreach (Component component in _components)
{
stream.WriteModel((uint)component.componentID, component.model, context);
}
}
public override Env createEnv(QuercusPage page,
WriteStream @out,
QuercusHttpServletRequest request,
QuercusHttpServletResponse response)
{
return(new CgiEnv(this, page, @out, request, response));
}
public override void execute()
{
string path = getPwd().lookup(getFileName());
QuercusPage page = parse(path);
WriteStream os = new WriteStream(StdoutStream.create());
os.setNewlineString("\n");
os.setEncoding("iso-8859-1");
Env env = createEnv(page, os, null, null);
env.start();
try {
env.execute();
} catch (QuercusDieException e) {
} catch (QuercusExitException e) {
}
env.close();
os.flush();
}
public uint ToBytes(WriteStream stream)
{
uint size = 5;
var span = stream.Advance(4);
stream.WriteByte(3);
size += stream.WriteHeader(EventPropertyType.L_32, 1);
size += stream.WriteHeader(EventPropertyType.L_64, 2);
size += stream.WriteHeader(EventPropertyType.L_Str, 7);
size += stream.WriteIndex(1);
size += stream.WriteInt32((int)CommodityType);
size += stream.WriteIndex(4);
size += stream.WriteDouble(MarginValue);
size += stream.WriteIndex(5);
size += stream.WriteDouble(FreeValue);
size += stream.WriteIndex(0);
size += stream.WriteString(ExchangeNo);
size += stream.WriteIndex(2);
size += stream.WriteString(CommodityNo);
size += stream.WriteIndex(3);
size += stream.WriteString(InstrumentID);
size += stream.WriteIndex(6);
size += stream.WriteString(ContractExpDate);
size += stream.WriteIndex(7);
size += stream.WriteString(LastTradeDate);
size += stream.WriteIndex(8);
size += stream.WriteString(FirstNoticeDate);
size += stream.WriteIndex(9);
size += stream.WriteString(ContractName);
BitConverter.TryWriteBytes(span, size);
return(size);
}
public FileWriteValue(Path path)
{
super(path);
_os = path.openWrite();
}
private void LogWriteToFile()
{
if (WriteFile != null)
{
WriteFile.Refresh();
}
if (WriteFile == null || WriteFile.Length >= 1024 * 1024)
{
if (WriteStream != null)
{
WriteStream.Dispose();
}
if (!Directory.Exists(m_Directory))
{
Directory.CreateDirectory(m_Directory);
}
var fileName = $"{m_Directory}\\{m_CategoryName}_{DateTime.Now.ToString(m_FileTemplate)}.txt";
WriteStream = new StreamWriter(File.OpenWrite(fileName), Encoding.Unicode);
WriteFile = new FileInfo(fileName);
}
while (m_LogQueue.TryDequeue(out string log))
{
WriteStream.Write(log);
}
WriteStream.Flush();
}
public void ReadBytes(NetIncomingMessage inc)
{
int bytesToRead = inc.LengthBytes - inc.PositionInBytes;
if (Received + (ulong)(bytesToRead) > FileSize)
{
//strip out excess bytes
bytesToRead -= (int)((Received + (ulong)bytesToRead) - FileSize);
}
byte[] all = inc.ReadBytes(bytesToRead);
Received += (ulong)all.Length;
WriteStream.Write(all, 0, all.Length);
int passed = Environment.TickCount - TimeStarted;
float psec = passed / 1000.0f;
if (GameSettings.VerboseLogging)
{
DebugConsole.Log("Received " + all.Length + " bytes of the file " + FileName + " (" + Received + "/" + FileSize + " received)");
}
BytesPerSecond = Received / psec;
Status = Received >= FileSize ? FileTransferStatus.Finished : FileTransferStatus.Receiving;
}
public void init(ReadStream @is, WriteStream os)
{
super.init(@is, os);
_is = is;
_os = os;
}
public void Write(WriteStream stream, StreamContext context)
{
if (context.fullModel)
{
// ClientID/StreamID
stream.WriteVarint32(1, WriteStream.ConvertNegativeOneIntToUInt(_clientID));
stream.WriteVarint32(2, WriteStream.ConvertNegativeOneIntToUInt(_streamID));
}
else
{
// ClientID/StreamID
if (context.reliableChannel)
{
// If we're going to send an update. Push the cache to inflight.
LocalCacheEntry entry = _cache.localCache;
if (entry.clientIDSet || entry.streamIDSet)
{
_cache.PushLocalCacheToInflight(context.updateID);
}
if (entry.clientIDSet)
{
stream.WriteVarint32(1, WriteStream.ConvertNegativeOneIntToUInt(entry.clientID));
}
if (entry.streamIDSet)
{
stream.WriteVarint32(2, WriteStream.ConvertNegativeOneIntToUInt(entry.streamID));
}
}
}
}
//// Writing
public void WriteHeader(int clientIndex, double startTimestamp, byte[] data)
{
if (_mode != Mode.Write)
{
Debug.LogError("SessionCaptureFileStream: Cannot call WriteHeader on read stream.");
return;
}
if (_writing)
{
Debug.LogError("SessionCaptureFileStream: WriteHeader() has been called twice. Ignoring. This is a bug!");
return;
}
// Keep track of start timestamps so all future timestamps can be written as deltas
_startTimestamp = startTimestamp;
// Write local client ID
WriteVarint32ToStream(_gzipStream, WriteStream.ConvertNegativeOneIntToUInt(clientIndex));
// Write start timestamp
WriteDoubleToStream(_gzipStream, _startTimestamp);
// Initial datastore data length
WriteVarint32ToStream(_gzipStream, (uint)data.Length);
// Initial datastore data
_gzipStream.Write(data, 0, data.Length);
_writing = true;
}
public async stt::Task CreateWriteStreamRequestObjectAsync()
{
moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
CreateWriteStreamRequest request = new CreateWriteStreamRequest
{
ParentAsTableName = TableName.FromProjectDatasetTable("[PROJECT]", "[DATASET]", "[TABLE]"),
WriteStream = new WriteStream(),
};
WriteStream expectedResponse = new WriteStream
{
WriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
Type = WriteStream.Types.Type.Buffered,
CreateTime = new wkt::Timestamp(),
CommitTime = new wkt::Timestamp(),
TableSchema = new TableSchema(),
};
mockGrpcClient.Setup(x => x.CreateWriteStreamAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <WriteStream>(stt::Task.FromResult(expectedResponse), null, null, null, null));
BigQueryWriteClient client = new BigQueryWriteClientImpl(mockGrpcClient.Object, null);
WriteStream responseCallSettings = await client.CreateWriteStreamAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
WriteStream responseCancellationToken = await client.CreateWriteStreamAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public void CreateWriteStream()
{
moq::Mock <BigQueryWrite.BigQueryWriteClient> mockGrpcClient = new moq::Mock <BigQueryWrite.BigQueryWriteClient>(moq::MockBehavior.Strict);
CreateWriteStreamRequest request = new CreateWriteStreamRequest
{
ParentAsTableName = TableName.FromProjectDatasetTable("[PROJECT]", "[DATASET]", "[TABLE]"),
WriteStream = new WriteStream(),
};
WriteStream expectedResponse = new WriteStream
{
WriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
Type = WriteStream.Types.Type.Buffered,
CreateTime = new wkt::Timestamp(),
CommitTime = new wkt::Timestamp(),
TableSchema = new TableSchema(),
WriteMode = WriteStream.Types.WriteMode.Unspecified,
};
mockGrpcClient.Setup(x => x.CreateWriteStream(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
BigQueryWriteClient client = new BigQueryWriteClientImpl(mockGrpcClient.Object, null);
WriteStream response = client.CreateWriteStream(request.Parent, request.WriteStream);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
//
//
private Stream GetWriteStream(string key, long contentLength, DateTime expiresUtc, DateTime lastModifiedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata, bool isThrow)
{
if(Logging.On) Logging.Enter(Logging.RequestCache, "WinInetCache.Store()", "Key = " + key);
if (key == null) {
throw new ArgumentNullException("key");
}
if (!CanWrite)
{
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_operation_failed_with_error, "WinInetCache.Store()", SR.GetString(SR.net_cache_access_denied, "Write")));
if(Logging.On) Logging.Exit(Logging.RequestCache, "WinInetCache.Store");
if(isThrow)
{
throw new InvalidOperationException(SR.GetString(SR.net_cache_access_denied, "Write"));
}
return null;
}
_WinInetCache.Entry entry = new _WinInetCache.Entry(key, _MaximumResponseHeadersLength);
entry.Key = key;
entry.OptionalLength = (contentLength < 0L)? 0: contentLength > Int32.MaxValue? Int32.MaxValue: (int)(contentLength);
entry.Info.ExpireTime = _WinInetCache.FILETIME.Zero;
if (expiresUtc != DateTime.MinValue && expiresUtc > s_MinDateTimeUtcForFileTimeUtc) {
entry.Info.ExpireTime = new _WinInetCache.FILETIME(expiresUtc.ToFileTimeUtc());
}
entry.Info.LastModifiedTime = _WinInetCache.FILETIME.Zero;
if (lastModifiedUtc != DateTime.MinValue && lastModifiedUtc > s_MinDateTimeUtcForFileTimeUtc) {
entry.Info.LastModifiedTime = new _WinInetCache.FILETIME(lastModifiedUtc.ToFileTimeUtc());
}
entry.Info.EntryType = _WinInetCache.EntryType.NormalEntry;
if (maxStale > TimeSpan.Zero) {
if (maxStale >= s_MaxTimeSpanForInt32) {
maxStale = s_MaxTimeSpanForInt32;
}
entry.Info.U.ExemptDelta = (int)maxStale.TotalSeconds;
entry.Info.EntryType = _WinInetCache.EntryType.StickyEntry;
}
entry.MetaInfo = CombineMetaInfo(entryMetadata, systemMetadata);
entry.FileExt = "cache";
if(Logging.On) {
Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_expected_length, entry.OptionalLength));
Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_last_modified, (entry.Info.LastModifiedTime.IsNull? "0": DateTime.FromFileTimeUtc(entry.Info.LastModifiedTime.ToLong()).ToString("r"))));
Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_expires, (entry.Info.ExpireTime.IsNull? "0": DateTime.FromFileTimeUtc(entry.Info.ExpireTime.ToLong()).ToString("r"))));
Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_max_stale, (maxStale > TimeSpan.Zero? ((int)maxStale.TotalSeconds).ToString():"n/a")));
if (Logging.IsVerbose(Logging.RequestCache)) {
Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_dumping_metadata));
if (entry.MetaInfo.Length == 0) {
Logging.PrintInfo(Logging.RequestCache, "<null>");
}
else {
if (entryMetadata != null) {
foreach (string s in entryMetadata)
{
Logging.PrintInfo(Logging.RequestCache, s.TrimEnd(LineSplits));
}
}
Logging.PrintInfo(Logging.RequestCache, "------");
if (systemMetadata != null) {
foreach (string s in systemMetadata)
{
Logging.PrintInfo(Logging.RequestCache, s.TrimEnd(LineSplits));
}
}
}
}
}
_WinInetCache.CreateFileName(entry);
Stream result = Stream.Null;
if (entry.Error != _WinInetCache.Status.Success) {
if(Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_create_failed, new Win32Exception((int)entry.Error).Message));
Logging.Exit(Logging.RequestCache, "WinInetCache.Store");
}
if (isThrow)
{
Win32Exception win32Exception = new Win32Exception((int)entry.Error);
throw new IOException(SR.GetString(SR.net_cache_retrieve_failure, win32Exception.Message), win32Exception);
}
return null;
}
try {
result = new WriteStream(entry, isThrow, contentLength, async);
}
catch (Exception exception) {
if (exception is ThreadAbortException || exception is StackOverflowException || exception is OutOfMemoryException) {
throw;
}
if(Logging.On)
{
Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_exception, "WinInetCache.Store()", exception));
Logging.Exit(Logging.RequestCache, "WinInetCache.Store");
}
if (isThrow)
{
throw;
}
return null;
}
if(Logging.On) Logging.Exit(Logging.RequestCache, "WinInetCache.Store", "Filename = " + entry.Filename);
return result;
}
/// <summary>
/// Sendings this instance.
/// </summary>
private void SwitchSending()
{
//try
//{
while (!this.Client.Connected)
{
Thread.SpinWait(100);
}
NetworkStream stream = this.Client.GetStream();
char[] splitOpt = { ',' };
String[] dstMsg;
WriteStream caller = new WriteStream(ParentNode.WriteToNetworkStream);
bool resend = true;
while (this.toSend.Count > 0)
{
lock (this.toSend)
{
dstMsg = this.toSend.Dequeue().Split(splitOpt, 2);
}
SwitchMessage msg = new SwitchMessage();
msg.EncodeMessage(dstMsg[0], this.ParentNode.Name, dstMsg[1]);
//Console.WriteLine(" : " + msg.Info + " : Node " + this.name + " is sending to Node " + dstMsg[0] + " this message " );
while (resend)
{
lock (stream)
{
if (stream.CanWrite)
{
caller.BeginInvoke(stream, msg, null, null);
}
else
{
Console.WriteLine("Node " + this.ParentNode.Name + " cannot write via switch.");
}
}
try
{
//Sleep until an ack is recieved.
Thread.Sleep(10000);
}
catch (ThreadInterruptedException)
{
resend = false;
}
if(this.doneSending == true)
{
resend = false;
}
}
resend = true;
if (this.doneSending == true)
{
break;
}
}
//Console.WriteLine("Sender thread for node " + this.name + " exiting.");
SwitchMessage done = new SwitchMessage();
done.EncodeHiddenComm(GlobalConst.serverName, GlobalConst.serverName);
this.doneSending = true;
while (stream.CanWrite)
{
try
{
stream.Write(done.ToSend, 0, done.ToSend.Length);
Thread.Sleep(1000);
}
catch (System.IO.IOException)
{
break;
}
catch (ThreadInterruptedException)
{
;
}
}
}
/// <summary>
/// Listens for this instance.
/// </summary>
private void SwitchListening()
{
try
{
NetworkStream clientStream = this.Client.GetStream();
byte[] message;
int bytesRead;
WriteStream caller = new WriteStream(this.parentNode.WriteToNetworkStream);
while (true)
{
bytesRead = 0;
message = GlobalConst.getSpaceByteArray(GlobalConst.BUFSIZE);
lock (this.toSend)
{
if (this.toSend.Count < 1)
{
clientStream.ReadTimeout = 30000;
}
}
try
{
//blocks until a client sends a message
bytesRead = clientStream.Read(message, 0, GlobalConst.BUFSIZE);
}
catch
{
//a socket error has occured
Console.WriteLine("Socket error on node " + this.parentNode.Name);
break;
}
if (bytesRead == 0)
{
//the client has disconnected from the server
Console.WriteLine("Node " + this.parentNode.Name + " has disconnected from the switch.");
break;
}
SwitchMessage msg = new SwitchMessage();
bool msgOk = msg.Decode(message);
Console.WriteLine("Got message on switch node " + this.parentNode.Name);
if(!msgOk)
{
}
else if (msg.Ack)
{
if (SenderThread.ThreadState.Equals(ThreadState.WaitSleepJoin))
{
//Notify the sender thread that the receiving node did get it.
SenderThread.Interrupt();
}
else
{
//Console.WriteLine("Node {0} sent to node {1} (really {2}) an ack when it wasn't supposed to!", msg.Sender, msg.Destination, this.name);
}
}
else
{
//message has successfully been received
parentNode.writeOutMessage(msg);
SwitchMessage ackMsg = new SwitchMessage();
ackMsg.EncodeHiddenComm(msg.Sender, msg.Destination);
lock (clientStream)
{
if (clientStream.CanWrite)
{
caller.BeginInvoke(clientStream, ackMsg, null, null);
}
else
{
Console.WriteLine("Node " + this.ParentNode.Name + " can't send an ack.");
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
if(!this.doneSending)
{
this.senderThread.Abort();
this.doneSending = true;
}
this.doneReceiving = true;
while(!this.parentThread.ThreadState.Equals(ThreadState.WaitSleepJoin))
{
Thread.Sleep(100);
}
this.parentThread.Interrupt();
//this.client.Close();
}
private void writeSegment(Segment seg, WriteStream ws)
{
ws.stream.Write(seg.data, 0, seg.data.Length);
seg.parent.byteprogress += seg.data.Length;
seg.data = null;
seg.status = Segment.Status.COMPLETE;
seg.parent.saveprogress = seg.id;
ws.lastuse = DateTime.Now.Millisecond;
}
private void saveSegment(Segment seg)
{
System.Console.WriteLine("Saving seg: " + seg.id);
bool saved = false;
// Check if stream is in cache
List<WriteStream> toremove = new List<WriteStream>();
List<WriteStream>.Enumerator enumer = streams.GetEnumerator();
if(enumer.MoveNext()) {
do
{
WriteStream ws = (WriteStream)enumer.Current;
if (ws.filejob.Equals(seg.parent))
{
// Copy from a tempsaved segment
if (seg.tempsaved)
{
FileStream stream = new FileStream(Properties.Settings.Default.tempFolder + "\\" + seg.tempname, FileMode.Open, FileAccess.Read);
byte[] buffer = new byte[seg.bytes];
stream.Read(buffer, 0, seg.bytes); // May end up blocking if seg.bytes is larger than actual file
seg.data = buffer;
stream.Close();
stream.Dispose();
}
writeSegment(seg, ws);
saved = true;
// Is filejob complete?
if (seg.id == seg.parent.yparts)
{
// Close stream
ws.stream.Flush();
ws.stream.Close();
ws.stream.Dispose();
// Remove from collection
toremove.Add(ws);
seg.parent.complete = true;
}
break;
}
}
while (enumer.MoveNext());
}
foreach (WriteStream ws in toremove)
{
streams.Remove(ws);
}
// Else open a new stream
if (!saved)
{
// Open new stream..
WriteStream ws = new WriteStream();
ws.stream = new FileStream(seg.parent.outputfilename, FileMode.Append, FileAccess.Write);
ws.filejob = seg.parent;
writeSegment(seg, ws);
// Was this the last part?
if (seg.id == seg.parent.yparts || seg.parent.yparts == 0)
{
// Close stream..
ws.stream.Flush();
ws.stream.Close();
ws.stream.Dispose();
}
else
{
streams.Add(ws);
}
}
}
private Stream GetWriteStream(string key, long contentLength, DateTime expiresUtc, DateTime lastModifiedUtc, TimeSpan maxStale, StringCollection entryMetadata, StringCollection systemMetadata, bool isThrow)
{
if (Logging.On)
{
Logging.Enter(Logging.RequestCache, "WinInetCache.Store()", "Key = " + key);
}
if (key == null)
{
throw new ArgumentNullException("key");
}
if (!base.CanWrite)
{
if (Logging.On)
{
Logging.PrintError(Logging.RequestCache, SR.GetString("net_log_operation_failed_with_error", new object[] { "WinInetCache.Store()", SR.GetString("net_cache_access_denied", new object[] { "Write" }) }));
}
if (Logging.On)
{
Logging.Exit(Logging.RequestCache, "WinInetCache.Store");
}
if (isThrow)
{
throw new InvalidOperationException(SR.GetString("net_cache_access_denied", new object[] { "Write" }));
}
return null;
}
_WinInetCache.Entry entry = new _WinInetCache.Entry(key, _MaximumResponseHeadersLength) {
Key = key,
OptionalLength = (contentLength < 0L) ? 0 : ((contentLength > 0x7fffffffL) ? 0x7fffffff : ((int) contentLength))
};
entry.Info.ExpireTime = _WinInetCache.FILETIME.Zero;
if ((expiresUtc != DateTime.MinValue) && (expiresUtc > s_MinDateTimeUtcForFileTimeUtc))
{
entry.Info.ExpireTime = new _WinInetCache.FILETIME(expiresUtc.ToFileTimeUtc());
}
entry.Info.LastModifiedTime = _WinInetCache.FILETIME.Zero;
if ((lastModifiedUtc != DateTime.MinValue) && (lastModifiedUtc > s_MinDateTimeUtcForFileTimeUtc))
{
entry.Info.LastModifiedTime = new _WinInetCache.FILETIME(lastModifiedUtc.ToFileTimeUtc());
}
entry.Info.EntryType = _WinInetCache.EntryType.NormalEntry;
if (maxStale > TimeSpan.Zero)
{
if (maxStale >= s_MaxTimeSpanForInt32)
{
maxStale = s_MaxTimeSpanForInt32;
}
entry.Info.U.ExemptDelta = (int) maxStale.TotalSeconds;
entry.Info.EntryType = _WinInetCache.EntryType.StickyEntry;
}
entry.MetaInfo = this.CombineMetaInfo(entryMetadata, systemMetadata);
entry.FileExt = "cache";
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_expected_length", new object[] { entry.OptionalLength }));
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_last_modified", new object[] { entry.Info.LastModifiedTime.IsNull ? "0" : DateTime.FromFileTimeUtc(entry.Info.LastModifiedTime.ToLong()).ToString("r") }));
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_expires", new object[] { entry.Info.ExpireTime.IsNull ? "0" : DateTime.FromFileTimeUtc(entry.Info.ExpireTime.ToLong()).ToString("r") }));
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_max_stale", new object[] { (maxStale > TimeSpan.Zero) ? ((int) maxStale.TotalSeconds).ToString() : "n/a" }));
if (Logging.IsVerbose(Logging.RequestCache))
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_dumping_metadata"));
if (entry.MetaInfo.Length == 0)
{
Logging.PrintInfo(Logging.RequestCache, "<null>");
}
else
{
if (entryMetadata != null)
{
foreach (string str in entryMetadata)
{
Logging.PrintInfo(Logging.RequestCache, str.TrimEnd(RequestCache.LineSplits));
}
}
Logging.PrintInfo(Logging.RequestCache, "------");
if (systemMetadata != null)
{
foreach (string str2 in systemMetadata)
{
Logging.PrintInfo(Logging.RequestCache, str2.TrimEnd(RequestCache.LineSplits));
}
}
}
}
}
_WinInetCache.CreateFileName(entry);
Stream @null = Stream.Null;
if (entry.Error != _WinInetCache.Status.Success)
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_create_failed", new object[] { new Win32Exception((int) entry.Error).Message }));
Logging.Exit(Logging.RequestCache, "WinInetCache.Store");
}
if (isThrow)
{
Win32Exception innerException = new Win32Exception((int) entry.Error);
throw new IOException(SR.GetString("net_cache_retrieve_failure", new object[] { innerException.Message }), innerException);
}
return null;
}
try
{
@null = new WriteStream(entry, isThrow, contentLength, this.async);
}
catch (Exception exception2)
{
if (((exception2 is ThreadAbortException) || (exception2 is StackOverflowException)) || (exception2 is OutOfMemoryException))
{
throw;
}
if (Logging.On)
{
Logging.PrintError(Logging.RequestCache, SR.GetString("net_log_cache_exception", new object[] { "WinInetCache.Store()", exception2 }));
Logging.Exit(Logging.RequestCache, "WinInetCache.Store");
}
if (isThrow)
{
throw;
}
return null;
}
if (Logging.On)
{
Logging.Exit(Logging.RequestCache, "WinInetCache.Store", "Filename = " + entry.Filename);
}
return @null;
}
/// <summary>
/// Uses the delegate.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="msg">The MSG.</param>
private void UseDelegate(NetworkStream stream, IMessage msg)
{
WriteStream caller = new WriteStream(WriteToNetworkStream);
caller(stream, msg);
caller = null;
}
public ProxyStream(WriteStream writer, ReadStream reader)
{
m_writer = writer ?? base.Write;
m_reader = reader ?? base.Read;
}
public static void CreatePipe(out Stream write, out Stream read)
{
var buffer = new PipeStream();
write = new WriteStream(buffer);
read = new ReadStream(buffer);
}
