/// <summary>
/// 写文件错误
/// </summary>
/// <param name="error">错误异常</param>
private void error(Exception error)
{
if (isLog)
{
log.Default.Add(error, null, false);
}
LastException = error;
Monitor.Enter(bufferLock);
byte isDisposed = this.isDisposed;
currentIndex = startIndex;
isWritting = 0;
fileBufferLength = fileLength = 0;
this.isDisposed = 1;
Monitor.Exit(bufferLock);
dispose();
pub.Dispose(ref fileStream);
list <memoryPool.pushSubArray> buffers = null;
Interlocked.Exchange(ref buffers, this.buffers);
try
{
if (buffers != null && buffers.length != 0)
{
memoryPool.pushSubArray[] dataArray = buffers.array;
for (int index = buffers.length; index != 0; dataArray[--index].Push())
{
;
}
}
}
finally
{
currentBuffers = null;
memoryPool.Push(ref buffer);
if (isDisposed == 0)
{
flushWait.Set();
flushWait.Close();
}
}
}
/// <summary>
/// 获取压缩数据
/// </summary>
/// <param name="data">数据</param>
/// <returns>压缩数据,失败返回null</returns>
internal static subArray<byte> GetCompress(subArray<byte> data, memoryPool memoryPool = null, int seek = 0)
{
if (data.Count > GZipSize)
{
subArray<byte> compressData = stream.GZip.GetCompress(data.Array, data.StartIndex, data.Count, seek, memoryPool);
if (compressData.Count != 0)
{
if (compressData.Count + GZipSize < data.Count) return compressData;
if (memoryPool != null) memoryPool.Push(ref compressData.array);
}
}
return default(subArray<byte>);
}
/// <summary>
/// 写入日志
/// </summary>
/// <param name="data">日志数据</param>
/// <returns>是否成功写入缓冲区</returns>
public unsafe bool AppendLog(memoryPool.pushSubArray data)
{
if (currentStep == (int) physicalOld.step.Waitting)
{
byte isCopy = 0, isLog = 0;
if (Interlocked.CompareExchange(ref logFileLock, 1, 0) != 0)
{
do
{
Thread.Sleep(0);
if (Interlocked.CompareExchange(ref logFileLock, 1, 0) == 0) break;
if (isRefreshErrorLog) Thread.Sleep(1);
else Thread.Sleep(0);
} while (Interlocked.CompareExchange(ref logFileLock, 1, 0) != 0);
}
try
{
if (logFileWriter.UnsafeWrite(data) >= 0) return true;
lastException = logFileWriter.LastException;
//subArray<byte> dataArray = data.Value;
//int length = logBufferIndex + dataArray.Length;
//if (length <= Buffers.Size)
//{
// if (logBuffer == null) logBuffer = Buffers.Get();
// fixed (byte* dataFixed = dataArray.Array, bufferFixed = logBuffer)
// {
// unsafer.memory.Copy(dataFixed + dataArray.StartIndex, bufferFixed + logBufferIndex, dataArray.Length);
// }
// logBufferIndex = length;
// isCopy = isLog = 1;
//}
//else if (logBufferIndex == 0)
//{
// if (logFileWriter.UnsafeWrite(data) >= 0) isLog = 1;
// else lastException = logFileWriter.LastException;
//}
//else
//{
// fixed (byte* dataFixed = dataArray.Array, bufferFixed = logBuffer)
// {
// unsafer.memory.Copy(dataFixed + dataArray.StartIndex, bufferFixed + logBufferIndex, length = Buffers.Size - logBufferIndex);
// dataArray.UnsafeSet(dataArray.StartIndex + length, dataArray.Length - length);
// if (logFileWriter.UnsafeWrite(new memoryPool.pushSubArray { Value = subArray<byte>.Unsafe(logBuffer, 0, Buffers.Size), PushPool = Buffers.PushHandle }) >= 0)
// {
// if (dataArray.Length <= Buffers.Size)
// {
// fixed (byte* newBufferFixed = logBuffer = Buffers.Get())
// {
// unsafer.memory.Copy(dataFixed + dataArray.StartIndex, newBufferFixed, logBufferIndex = dataArray.Length);
// }
// isCopy = isLog = 1;
// }
// else if (logFileWriter.UnsafeWrite(data) >= 0)
// {
// logBufferIndex = 0;
// logBuffer = null;
// isLog = 1;
// }
// else lastException = logFileWriter.LastException;
// }
// else
// {
// isCopy = 1;
// lastException = logFileWriter.LastException;
// }
// }
//}
}
catch (Exception error)
{
lastException = error;
}
finally
{
logFileLock = 0;
}
if (isCopy != 0) data.Push();
if (isLog != 0) return true;
Dispose();
}
return false;
}
/// <summary>
/// 写入数据
/// </summary>
/// <param name="data">数据</param>
/// <returns>写入位置,失败返回-1</returns>
internal long UnsafeWrite(memoryPool.pushSubArray data)
{
flushWait.Reset();
subArray<byte> dataArray = data.Value;
interlocked.NoCheckCompareSetSleep0(ref bufferLock);
if (isDisposed == 0)
{
long fileBufferLength = this.fileBufferLength;
this.fileBufferLength += dataArray.Count;
if (isWritting == 0)
{
int length = currentIndex + dataArray.Count;
if (length < bufferLength && flushCount == 0)
{
Buffer.BlockCopy(dataArray.array, dataArray.StartIndex, buffer, currentIndex, dataArray.Count);
checkFlushTime = date.NowSecond.AddTicks(checkFlushTicks);
currentIndex = length;
bufferIndex = this.fileBufferLength;
bufferLock = 0;
data.Push();
setCheckFlush();
}
else
{
buffers.array[0] = data;
buffers.Unsafer.AddLength(1);
bufferSize += dataArray.Count;
isFlush = 0;
isWritting = 1;
isCopyBuffer = 0;
bufferLock = 0;
threadPool.TinyPool.FastStart(writeFileHandle, null, null);
}
}
else
{
try
{
buffers.Add(data);
bufferSize += dataArray.Count;
isCopyBuffer = 0;
}
finally { bufferLock = 0; }
}
return fileBufferLength;
}
bufferLock = 0;
data.Push();
return -1;
}
/// <summary>
/// 开始读取文件
/// </summary>
public unsafe void Read()
{
do
{
int readSize = index.Size + sizeof(int);
try
{
if (FileStream.isDisposed == 0)
{
buffer = (memoryPool = memoryPool.GetOrCreate(readSize)).Get();
FileStream fileReader = FileStream.fileReader;
long offset = fileReader.Position - index.Index;
if (offset >= 0 || -offset < index.Index)
{
fileReader.Seek(offset, SeekOrigin.Current);
}
else
{
fileReader.Seek(index.Index, SeekOrigin.Begin);
}
if (fileReader.Read(buffer, 0, readSize) == readSize)
{
fixed(byte *bufferFixed = buffer)
{
if (*(int *)bufferFixed == index.Size)
{
readSize = index.Size;
}
else
{
log.Default.Add(FileStream.FileName + " index[" + index.Index.toString() + "] size[" + (*(int *)bufferFixed).toString() + "]<>" + index.Size.toString(), new System.Diagnostics.StackFrame(), false);
}
}
}
else
{
readSize = 0;
}
}
}
catch (Exception error)
{
log.Default.Add(error, null, false);
}
Func <fastCSharp.net.returnValue <fastCSharp.code.cSharp.tcpBase.subByteArrayEvent>, bool> onReaded = this.onReaded;
if (readSize == index.Size)
{
if (onReaded(new fastCSharp.code.cSharp.tcpBase.subByteArrayEvent {
Buffer = subArray <byte> .Unsafe(buffer, sizeof(int), index.Size), SerializeEvent = memoryPool
}))
{
buffer = null;
}
else
{
memoryPool.Push(ref buffer);
}
}
else
{
onReaded(default(fastCSharp.code.cSharp.tcpBase.subByteArrayEvent));
if (memoryPool != null)
{
memoryPool.Push(ref buffer);
}
}
reader next = FileStream.next(this);
if (next == null)
{
FileStream = null;
onReaded = null;
memoryPool = null;
typePool <reader> .PushNotNull(this);
return;
}
onReaded = next.onReaded;
index = next.index;
next.onReaded = null;
typePool <reader> .PushNotNull(next);
}while (true);
}
/// <summary>
/// 获取解压数据
/// </summary>
/// <returns>解压数据</returns>
public unsafe subArray<byte> Get(memoryPool memoryPool)
{
if (memoryPool == null)
{
pointer data = fastCSharp.unmanagedPool.StreamBuffers.Get();
try
{
using (dataStream = new unmanagedStream(data.Byte, fastCSharp.unmanagedPool.StreamBuffers.Size))
{
get();
return new subArray<byte>(dataStream.GetArray());
}
}
finally { fastCSharp.unmanagedPool.StreamBuffers.Push(ref data); }
}
else
{
byte[] data = memoryPool.Get();
try
{
fixed (byte* dataFixed = data)
{
using (dataStream = new unmanagedStream(dataFixed, data.Length))
{
get();
if (dataStream.Data == dataFixed)
{
byte[] buffer = data;
data = null;
return subArray<byte>.Unsafe(buffer, 0, dataStream.Length);
}
return new subArray<byte>(dataStream.GetArray());
}
}
}
finally { memoryPool.Push(ref data); }
}
}
/// <summary>
/// 压缩数据
/// </summary>
/// <param name="data">原始数据</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">压缩字节数</param>
/// <param name="seek">起始位置</param>
/// <returns>压缩后的数据,失败返回null</returns>
internal subArray<byte> GetCompressUnsafe(byte[] data, int startIndex, int count, int seek = 0, memoryPool memoryPool = null)
{
int length = count + seek;
if (memoryPool == null)
{
using (MemoryStream dataStream = new MemoryStream())
{
if (seek != 0) dataStream.Seek(seek, SeekOrigin.Begin);
using (Stream compressStream = getStream(dataStream))
{
compressStream.Write(data, startIndex, count);
}
if (dataStream.Position < length)
{
return subArray<byte>.Unsafe(dataStream.GetBuffer(), seek, (int)dataStream.Position - seek);
}
}
}
else
{
byte[] buffer = memoryPool.Get();
try
{
using (MemoryStream dataStream = memoryStream.Get(buffer))
{
if (seek != 0) dataStream.Seek(seek, SeekOrigin.Begin);
using (Stream compressStream = getStream(dataStream))
{
compressStream.Write(data, startIndex, count);
}
if (dataStream.Position < length)
{
byte[] streamBuffer = dataStream.GetBuffer();
if (streamBuffer == buffer) buffer = null;
return subArray<byte>.Unsafe(streamBuffer, seek, (int)dataStream.Position - seek);
}
}
}
catch (Exception error)
{
log.Error.Add(error, null, false);
}
finally
{
memoryPool.Push(ref buffer);
}
}
return default(subArray<byte>);
}
