/** * 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); }