public static void ConflictRequest(RequestType firstRequest, RequestType secondRequest)
{
// For RequestType.Lease, only containg one request (Create with Lease context)
// for the second client, so DeleteAfter is not applicable.
Condition.IfThen(firstRequest == RequestType.UncommitedDelete, secondRequest != RequestType.Lease);
// DeleteAfter is the same as Delete for second request
Condition.IsTrue(secondRequest != RequestType.UncommitedDelete);
switch (firstRequest)
{
case RequestType.ExclusiveLock:
State = FileState.Locked;
break;
case RequestType.Lease:
State = FileState.LeaseGranted;
break;
case RequestType.UncommitedDelete:
State = FileState.ToBeDeleted;
break;
case RequestType.Delete:
State = FileState.Deleted;
break;
// No state changed
case RequestType.Write:
case RequestType.Read:
default:
break;
}
SecondRequest = secondRequest;
}
/// <summary>
/// Initializes a new instance of the <see cref="ScanFileEventArgs" /> class.
/// </summary>
/// <param name="filepath">The file path affected by the event.</param>
/// <param name="track">The track (if one exists) parsed from the file affected by the event.</param>
/// <param name="filestate">The file state affected by the event.</param>
public ScanFileEventArgs(long currentFileNumber, long totalFilesCount, string filepath, RawTrack track, FileState filestate)
{
_currentFileNumber = currentFileNumber;
_totalFilesCount = totalFilesCount;
_filepath = filepath;
_track = track;
_filestate = filestate;
}
public void SetFileAsRemoving()
{
if (State != FileState.Available)
{
throw new NotImplementedException("Currently only Files in an available state can be removed");
}
State = FileState.Removing;
}
public void ConvertMapsToChangeTypeForKnonwStates(FileState fileState, ChangeType expected)
{
// Act
ChangeType actual = HgRepository.Convert(fileState);
// Assert
Assert.Equal(expected, actual);
}
public VCFile(VCFile template)
{
mFileState1 = template.fileState1;
mFileState2 = template.fileState2;
mName1 = template.name1;
mName2 = template.name2;
mPath1 = template.path1;
mPath2 = template.path2;
}
private static void WriteContent(string file, string content)
{
var fileStream = new FileStream(file, FileMode.Truncate);
var state = new FileState
{
FileStream = fileStream
};
var data = Encoding.ASCII.GetBytes(content);
fileStream.BeginWrite(data, 0, data.Length, WriteDone, state);
}
private void ReplaceFileContent(string file)
{
var fileStream = new FileStream(file, FileMode.Open);
var state = new FileState
{
FileStream = fileStream,
FileName = file,
Data = new byte[fileStream.Length]
};
fileStream.BeginRead(state.Data, 0, (int)fileStream.Length, ReadDone, state);
}
public AvailableFile(ClientInstance client, FileDescriptor descriptor)
: base(descriptor)
{
_state = FileState.Available;
_client = client;
_percent = 0d;
_client.FileRequestResponseReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileRequestResponseEventArgs>(_client_FileRequestResponseReceived);
_client.FileTransferProgressed += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileTransferEventArgs>(_client_FileTransferProgressed);
_client.FileTransferCompleted += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileTransferCompletedEventArgs>(_client_FileTransferCompleted);
_client.FileTransferFailed += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.FileDescriptorEventArgs>(_client_FileTransferFailed);
}
/// <summary>
/// 发送方的文件进行续传;如果回复是null;说明不存在
/// </summary>
/// <param name="fileLable">文件标签</param>
/// <param name="stateOne">StateBase</param>
/// <returns>byte[]</returns>
internal byte[] FileContinue(int fileLable, StateBase stateOne)
{
byte[] haveDate = null;
FileState state = FileLabelToState(fileLable);
if (state != null && state.StateFile == 2)
{
haveDate = EncryptionDecryptFile.FileSevenEncryption(PasswordCode._sendUser, PasswordCode._fileContinue, fileLable);
state.StateOne = stateOne; //可以续传；用新的stateOne代替旧的
}
return(haveDate);
}
/// <summary>
/// 对包头文件进行解密
/// </summary>
/// <param name="fileDate"></param>
/// <param name="fs"></param>
/// <returns></returns>
internal static FileState FileHeadDecrypt(byte[] fileDate, FileStream fs)
{
int lable = ByteToDate.ByteToInt(3, fileDate);
long fileLenth = ByteToDate.ByteToLong(7, fileDate);
byte[] fileNameByte = new byte[fileDate.Length - 15];
Array.Copy(fileDate, 15, fileNameByte, 0, fileNameByte.Length);
string fileName = Encoding.UTF8.GetString(fileNameByte);
FileState haveState = new FileState(lable, fileLenth, fileName, fs);
return(haveState);
}
/// <summary>
/// 接收方的文件进行续传;如果回复是null;说明不存在
/// </summary>
/// <param name="fileLable">文件标签</param>
/// <param name="stateOne">StateBase</param>
/// <returns>byte[]</returns>
internal byte[] FileContinue(int fileLable, StateBase stateOne)
{
byte[] haveDate = null;
FileState state = FileLabelToState(fileLable);
if (state != null && state.StateFile == 2)
{
haveDate = EncryptionDecryptFile.ReceiveContingueEncryption(PasswordCode._fileContinue, state);
ExpandBuffer(state, stateOne);
}
return(haveDate);
}
/// <summary>
/// 扩充因要接收文件而增大的缓冲区
/// </summary>
/// <param name="state">FileState</param>
/// <param name="stateOne">stateOne</param>
private void ExpandBuffer(FileState state, StateBase stateOne)
{
if (state.StateOne != stateOne)
{
if (stateOne.Buffer.Length != BufferSize)
{
stateOne.BufferBackup = stateOne.Buffer;
stateOne.Buffer = new byte[BufferSize];
}
state.StateOne = stateOne;
}
}
/// <summary>
/// 得到文件名
/// </summary>
/// <param name="FileLabel">文件编号</param>
/// <returns>文件名</returns>
public string GetFileName(int FileLabel)
{
FileState state = FileLabelToState(FileLabel);
if (state == null)
{
throw new Exception("这文件已不存在");
}
string haveStr = CommonMethod.StringRight(state.FileName, "\\");
return(haveStr);
}
// 点击“打开本地表”按钮
private void btnOpenLocalExcelFile_Click(object sender, EventArgs e)
{
FileState fileState = Utils.GetFileState(AppValues.LocalExcelFilePath);
if (fileState == FileState.Inexist)
{
MessageBox.Show("本地表已不存在，请勿在使用本工具时对母表进行操作", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
System.Diagnostics.Process.Start(AppValues.LocalExcelFilePath);
}
public void ConvertFileAttributes()
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.Converters.Add(new JsonStringEnumConverter());
FileState state = JsonSerializer.Deserialize <FileState>(@"{""Attributes"":""ReadOnly""}", options);
Assert.Equal(FileAttributes.ReadOnly, state.Attributes);
state = JsonSerializer.Deserialize <FileState>(@"{""Attributes"":""Directory, ReparsePoint""}", options);
Assert.Equal(FileAttributes.Directory | FileAttributes.ReparsePoint, state.Attributes);
FileAttributes attributes = JsonSerializer.Deserialize <FileAttributes>(@"""Normal""", options);
Assert.Equal(FileAttributes.Normal, attributes);
attributes = JsonSerializer.Deserialize <FileAttributes>(@"""System, SparseFile""", options);
Assert.Equal(FileAttributes.System | FileAttributes.SparseFile, attributes);
// We are case insensitive on read
attributes = JsonSerializer.Deserialize <FileAttributes>(@"""OFFLINE""", options);
Assert.Equal(FileAttributes.Offline, attributes);
attributes = JsonSerializer.Deserialize <FileAttributes>(@"""compressed, notcontentindexed""", options);
Assert.Equal(FileAttributes.Compressed | FileAttributes.NotContentIndexed, attributes);
// Numbers are cool by default
attributes = JsonSerializer.Deserialize <FileAttributes>(@"131072", options);
Assert.Equal(FileAttributes.NoScrubData, attributes);
attributes = JsonSerializer.Deserialize <FileAttributes>(@"3", options);
Assert.Equal(FileAttributes.Hidden | FileAttributes.ReadOnly, attributes);
string json = JsonSerializer.Serialize(FileAttributes.Hidden, options);
Assert.Equal(@"""Hidden""", json);
json = JsonSerializer.Serialize(FileAttributes.Temporary | FileAttributes.Offline, options);
Assert.Equal(@"""Temporary, Offline""", json);
// Try a unique casing
options = new JsonSerializerOptions();
options.Converters.Add(new JsonStringEnumConverter(new ToLower()));
json = JsonSerializer.Serialize(FileAttributes.NoScrubData, options);
Assert.Equal(@"""noscrubdata""", json);
json = JsonSerializer.Serialize(FileAttributes.System | FileAttributes.Offline, options);
Assert.Equal(@"""system, offline""", json);
// Undefined values should come out as a number (not a string)
json = JsonSerializer.Serialize((FileAttributes)(-1), options);
Assert.Equal(@"-1", json);
// Not permitting integers should throw
options = new JsonSerializerOptions();
options.Converters.Add(new JsonStringEnumConverter(allowIntegerValues: false));
Assert.Throws <JsonException>(() => JsonSerializer.Serialize((FileAttributes)(-1), options));
}
public static IZuneTagContainer GetContainer(string path)
{
if (!File.Exists(path))
{
throw new FileNotFoundException(String.Format("File does not exist: {0}", path), path);
}
string extension = Path.GetExtension(path);
if (extension.ToLower() == ".mp3")
{
try
{
var tagManager = new Id3TagManager();
//TODO: app crashes here when a file is loaded from a remote directory, i.e. on network
FileState status = tagManager.GetTagsStatus(path);
//if we just have id3v1.1 tags
if (status.Id3V1TagFound && !status.Id3V2TagFound)
{
throw new Id3TagException("cannot read id3v1.1");
}
return(new ZuneMP3TagContainer(tagManager.ReadV2Tag(path), path));
}
catch (Id3TagException ex)
{
if (ex.InnerException != null)
{
throw new AudioFileReadException(ex.InnerException.Message, ex.InnerException);
}
throw new AudioFileReadException(ex.Message);
}
}
if (extension.ToLower() == ".wma")
{
try
{
return(new ZuneWMATagContainer(ASFTagManager.ReadTag(path), path));
}
catch (Exception ex)
{
throw new AudioFileReadException(ex.Message, ex);
}
}
throw new AudioFileReadException("The " + Path.GetExtension(path) +
" file extension is not supported with zune social tagger.");
}
/// <summary>
/// 内部用的进度；里面会自动计算
/// </summary>
/// <param name="state">FileState</param>
internal void FileProgress(FileState state)
{
if (state.FileLenth == state.FileOkLenth)
{
FileProgress(state.FileLabel, 100);
}
else
{
long haveLong = state.FileOkLenth * 100 / state.FileLenth;
int haveInt = (int)haveLong;
FileProgress(state.FileLabel, haveInt);
}
}
public async Task MissingSource()
{
using var fileState = new FileState();
var outputDirectory = fileState.CreateTempDirectory();
var outputFile = Path.Combine(outputDirectory, "out.jpg");
var returnCode = await Bootstrapper.Main(
"reproject",
"-vo", outputFile);
VerifyFailedExecution(returnCode);
}
private GitFileInfo[] GetFiles(FileState fileState, bool staged)
{
List <GitFileInfo> results = new List <GitFileInfo>();
foreach (GitFileInfo info in m_files)
{
if (info.FileState == fileState && info.Staged == staged)
{
results.Add(info);
}
}
return(results.ToArray());
}
/// <summary>
/// 得到文件的进度；返回大于0小于100的进度数；如果文件已不存在返回100；不抛异常
/// </summary>
/// <param name="FileLabel">文件标签</param>
/// <returns></returns>
public int FileProgress(int FileLabel)
{
FileState state = FileLabelToState(FileLabel);
if (state == null)
{
return(100);
}
long haveLong = state.FileOkLenth * 100 / state.FileLenth;
var haveInt = (int)haveLong;
return(haveInt);
}
private static CommandLineOptions ValidOptions(FileState fileState)
{
var options = new CommandLineOptions
{
OutputPath = fileState.CreateFile("output.jpg"),
UnderlayPath = fileState.CreateFile("underlay.jpg"),
SourcePath = fileState.CreateFile("source.jpg"),
OverlayPath = fileState.CreateFile("overlay.jpg"),
Threads = 5
};
return(options);
}
public void ValidOutputStitchAndBatch()
{
var options = ValidOptions();
using var state = new FileState();
options.Timestamp = DateTime.Now;
options.IntervalMinutes = 30;
options.SourcePath = Path.Combine(state.CreateTempDirectory(), "*.jpg");
options.OutputPath = state.CreateTempDirectory();
VerifyNoFailure(options);
}
public Task <FileState> SaveAsync(FileState state,
Stream dataStream,
string sessionToken,
IProgress <ParseUploadProgressEventArgs> progress,
CancellationToken cancellationToken = default(CancellationToken))
{
if (state.Url != null)
{
// !isDirty
return(Task.FromResult(state));
}
if (cancellationToken.IsCancellationRequested)
{
var tcs = new TaskCompletionSource <FileState>();
tcs.TrySetCanceled();
return(tcs.Task);
}
var oldPosition = dataStream.Position;
var command = new ParseCommand("files/" + state.Name,
method: "POST",
sessionToken: sessionToken,
contentType: state.MimeType,
stream: dataStream);
return(_commandRunner.RunCommandAsync(command,
uploadProgress: progress,
cancellationToken: cancellationToken).OnSuccess(uploadTask =>
{
var result = uploadTask.Result;
var jsonData = result.Item2;
cancellationToken.ThrowIfCancellationRequested();
return new FileState
{
Name = jsonData["name"] as string,
Url = new Uri(jsonData["url"] as string, UriKind.Absolute),
MimeType = state.MimeType
};
}).ContinueWith(t =>
{
// Rewind the stream on failure or cancellation (if possible)
if ((t.IsFaulted || t.IsCanceled) && dataStream.CanSeek)
{
dataStream.Seek(oldPosition, SeekOrigin.Begin);
}
return t;
}, cancellationToken).Unwrap());
}
public void ValidOutputStitchNoBatch()
{
var options = ValidOptions();
using var state = new FileState();
var outputFile = state.CreateFile("foo.jpg");
options.Timestamp = DateTime.Now;
options.SourcePath = Path.Combine(state.CreateTempDirectory(), "*.jpg");
options.OutputPath = outputFile;
VerifyNoFailure(options);
}
public void OutputIsFileIfLongitudeSpecified()
{
var options = ValidOptions();
options.Longitude = 147;
options.Timestamp = DateTime.Now;
using var state = new FileState();
options.SourcePath = Path.Combine(state.CreateTempDirectory(), "*.jpg");
options.OutputPath = Path.Combine(state.CreateTempDirectory(), "out.jpg");
VerifyNoFailure(options);
}
/// <summary>
/// 发送方对一个文件包头进行加密得到一个byte[]
/// </summary>
/// <param name="fileSend"></param>
/// <returns></returns>
internal static byte[] FileHeadEncryption(FileState fileSend)
{
string fileName = CommonMethod.StringRight(fileSend.FileName, "\\");
byte[] fileNameByte = Encoding.UTF8.GetBytes(fileName);
byte[] haveDate = new byte[15 + fileNameByte.Length];
haveDate[0] = CipherCode._fileCode;
haveDate[1] = CipherCode._sendUser;
haveDate[2] = CipherCode._fileHeadCode;
ByteToDate.IntToByte(fileSend.FileLabel, 3, haveDate);
ByteToDate.IntToByte(fileSend.FileLenth, 7, haveDate);
fileNameByte.CopyTo(haveDate, 15);
return(haveDate);
}
public Task TestFileControllerSaveWithEmptyResult()
{
Tuple <HttpStatusCode, IDictionary <string, object> > response = new Tuple <HttpStatusCode, IDictionary <string, object> >(HttpStatusCode.Accepted, new Dictionary <string, object>());
Mock <IParseCommandRunner> mockRunner = CreateMockRunner(response);
FileState state = new FileState
{
Name = "bekti.png",
MimeType = "image/png"
};
ParseFileController controller = new ParseFileController(mockRunner.Object);
return(controller.SaveAsync(state, dataStream: new MemoryStream(), sessionToken: null, progress: null).ContinueWith(t => Assert.IsTrue(t.IsFaulted)));
}
public FileLoader(frmLegendsViewer form, Button xmlButton, TextBox xmlText, Button historyButton, TextBox historyText, Button sitesButton, TextBox sitesText, Button mapButton, TextBox mapText, Label statusLabel, RichTextBox logText)
{
Form = form;
XMLButton = xmlButton;
XMLText = xmlText;
HistoryButton = historyButton;
HistoryText = historyText;
SitesButton = sitesButton;
SitesText = sitesText;
MapButton = mapButton;
MapText = mapText;
StatusLabel = statusLabel;
LogText = logText;
XMLState = HistoryState = SitesState = MapState = FileState.Default;
XMLButton.Click += XMLClick;
HistoryButton.Click += HistoryClick;
SitesButton.Click += SitesClick;
MapButton.Click += MapClick;
ExtractedFiles = new List <string>();
if (Environment.Is64BitProcess)
{
SevenZipBase.SetLibraryPath("7z64.dll");
}
try
{
var assembly = Assembly.GetExecutingAssembly();
var resourceName = "LegendsViewer.Controls.HTML.Styles.legends.css";
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
Controls.HTMLPrinter.LegendsCSS = reader.ReadToEnd();
}
var chartjsName = "LegendsViewer.Controls.HTML.Scripts.Chart.min.js";
using (Stream stream = assembly.GetManifestResourceStream(chartjsName))
using (StreamReader reader = new StreamReader(stream))
{
Controls.HTMLPrinter.ChartJS = reader.ReadToEnd();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
// 点击“打开Excel母表”按钮
private void btnOpenExcelFile_Click(object sender, EventArgs e)
{
string excelFilePath = txtExcelPath.Text.Trim();
if (string.IsNullOrEmpty(excelFilePath))
{
MessageBox.Show("请先输入或选择国际化Excel母表所在路径", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
FileState fileState = Utils.GetFileState(excelFilePath);
if (fileState == FileState.Inexist)
{
MessageBox.Show("输入的国际化Excel母表所在路径不存在，建议点击\"选择\"按钮进行文件选择", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (!AppValues.EXCEL_FILE_EXTENSION.Equals(Path.GetExtension(excelFilePath), StringComparison.CurrentCultureIgnoreCase))
{
MessageBox.Show(string.Format("本工具仅支持读取扩展名为{0}的Excel文件", AppValues.EXCEL_FILE_EXTENSION), "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (fileState == FileState.IsOpen)
{
MessageBox.Show("该Excel文件正被其他软件打开，请关闭后重试", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// 读取设置的注释行开头字符
_SetCommentLineStartChar();
// 解析Excel母表
string errorString = null;
LangExcelInfo langExcelInfo = AnalyzeHelper.AnalyzeLangExcelFile(excelFilePath, AppValues.CommentLineStartChar, out errorString);
if (errorString == null)
{
AppValues.ExcelFullPath = Path.GetFullPath(excelFilePath);
// 当重新选择了Excel母表文件后重置窗口控件
_ChangeStateWhenSetExcelPath(false);
AppValues.LangExcelInfo = langExcelInfo;
// 设置了合法的Excel母表后，可以使用各个子模块功能
_ChangeStateWhenSetExcelPath(true);
}
else
{
MessageBox.Show(string.Format("选定的Excel母表存在以下错误，请修正后重试\n\n{0}", errorString), "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
/// <inheritdoc />
public async Task <Possible <CasHash, Failure> > AddToCasAsync(
string filename,
FileState fileState,
CasHash?hash,
UrgencyHint urgencyHint,
Guid activityId)
{
if (m_outOfSpace)
{
return(new CacheFailure(s_outOfSpaceError[0]));
}
PutResult result;
if (hash.HasValue)
{
result = await CacheSession.PutFileAsync(
new Context(Logger),
hash.Value.ToContentHash(),
new BuildXL.Cache.ContentStore.Interfaces.FileSystem.AbsolutePath(filename),
fileState.ToMemoization(),
CancellationToken.None,
urgencyHint.ToMemoization());
}
else
{
result = await CacheSession.PutFileAsync(
new Context(Logger),
ContentHashingUtilities.HashInfo.HashType,
new BuildXL.Cache.ContentStore.Interfaces.FileSystem.AbsolutePath(filename),
fileState.ToMemoization(),
CancellationToken.None,
urgencyHint.ToMemoization());
}
if (result.Succeeded)
{
return(result.ContentHash.FromMemoization());
}
string outOfSpaceError;
if (!m_outOfSpace && IsOutOfSpacePut(result, out outOfSpaceError))
{
m_outOfSpace = true;
}
return(new CacheFailure(result.ErrorMessage));
}
private static void AsyncRead()
{
FileStream fs = new FileStream(@"C:\windows\system32\drivers\etc\HOSTS", FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
FileState state = new FileState();
state.Buffer = new byte[fs.Length];
state.File = fs;
fs.BeginRead(state.Buffer, 0, state.Buffer.Length, readCompleted, state);
// Read가 완료된 후의 코드를 readCompleted로 넘겨서 처리
Console.ReadLine();
fs.Close();
}
public Task TestFileControllerSaveWithInvalidResult()
{
var response = new Tuple <HttpStatusCode, IDictionary <string, object> >(HttpStatusCode.Accepted, null);
var mockRunner = CreateMockRunner(response);
var state = new FileState {
Name = "bekti.png",
MimeType = "image/png"
};
var controller = new ParseFileController(mockRunner.Object);
return(controller.SaveAsync(state, dataStream: new MemoryStream(), sessionToken: null, progress: null).ContinueWith(t => {
Assert.True(t.IsFaulted);
}));
}
public void OutputNotFileIfMultipleSource()
{
var options = ValidOptions();
using var state = new FileState();
var outputFile = state.CreateFile("foo.jpg");
options.SourcePath = Path.Combine(state.CreateTempDirectory(), "*.jpg");
options.OutputPath = outputFile;
VerifyFailure(
options,
nameof(GeostationaryOptions.OutputPath),
"If multiple source files are specified, the output must be a directory.");
}
public void SaveFileDialog(ref string filePath, TreeView treeView_, Form mainForm_, FileState fileState_, bool isSaveAs)
{
if (isSaveAs)
{
filePath = null;
}
if (filePath == null)
{
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.Filter = "rexl files |*.rexl";
saveFileDialog1.FilterIndex = 1;
saveFileDialog1.RestoreDirectory = true;
saveFileDialog1.ShowDialog();
if (saveFileDialog1.FileName != "")
{
filePath = saveFileDialog1.FileName;
try
{
NodeHelper helper = new NodeHelper();
var xmlDocument = helper.TreeViewToXmlDocument(treeView_);
xmlDocument.Save(filePath);
mainForm_.Text = "Tree of Thought " + Path.GetFileNameWithoutExtension(filePath);
fileState_.IsFileChanged = false;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
else // over write the currently openned file
{
try
{
NodeHelper helper = new NodeHelper();
var xmlDocument = helper.TreeViewToXmlDocument(treeView_);
xmlDocument.Save(filePath);
fileState_.IsFileChanged = false;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
this.fileState = fileState_;
}
/// <summary>
/// Close the text file. If the file was opened for writing, then first write the lines of
/// text to the physical file.
/// </summary>
public virtual void Close()
{
if (State == FileState.OPEN)
{
if (Mode == FileMode.WRITE && Count > 0)
{
Save();
}
_fileData.Clear();
Position = -1;
DirectoryPath = null;
FileName = null;
Mode = FileMode.INITIAL;
State = FileState.CLOSED;
}
}
public void GetSourceFiles()
{
using var state = new FileState();
var imageFolder = state.CreateTempDirectory();
var sourceFile = Path.Combine(imageFolder, "source.jpg");
var outputPath = Path.Combine(imageFolder, "output", "output.jpg");
File.WriteAllText(sourceFile, "Hey!");
RenderOptions.SourcePath = sourceFile;
RenderOptions.OutputPath = outputPath;
// Run method under test
FileService.GetSourceFiles().Should().BeEquivalentTo(sourceFile);
}
/// <summary>
/// Writes the Start Activity event
/// </summary>
public void Start(string filename, FileState fileState, UrgencyHint urgencyHint)
{
Start();
if (TraceMethodArgumentsEnabled())
{
Write(
ParameterOptions,
new
{
FileName = filename,
FileState = fileState,
UrgencyHint = urgencyHint,
});
}
}
public void OutputNotDirectoryIfLongitudeSpecified()
{
var options = ValidOptions();
options.Longitude = 147;
using var state = new FileState();
options.SourcePath = Path.Combine(state.CreateTempDirectory(), "*.jpg");
options.OutputPath = state.CreateTempDirectory();
VerifyFailure(
options,
nameof(GeostationaryOptions.OutputPath),
"If multiple source files are specified with a target latitude reprojection, the output cannot be a directory.");
}
public static IState Load()
{
if (File.Exists(Path.Combine(Environment.CurrentDirectory, FILE_NAME)))
{
preventSave = true;
var serializer = new XmlSerializer(typeof(BaseState), new Type[] { typeof(FileState) });
using (var stream = new FileStream(Path.Combine(Environment.CurrentDirectory, FILE_NAME), FileMode.Open))
{
var state = serializer.Deserialize(stream) as BaseState;
preventSave = false;
return state;
}
}
else
{
var state = new FileState();
state.Reset(true);
ServiceLocator.Logger.Log(string.Format("The {0} file cannot be found and was created.", FILE_NAME));
return state;
}
}
public void Add(string directory, string file, FileState value)
{
if(_nextValuesIndex >= Values.Length) // Resize
{
Resize();
}
Values[_nextValuesIndex] = value;
var bucket = ComputeBucket(file);
while (true)
{
if (Buckets[bucket].IsEmpty)
{
Buckets[bucket] = new Bucket(directory, file, _nextValuesIndex);
_count++;
_nextValuesIndex++;
return;
}
bucket = NextCandidateBucket(bucket);
}
}
public IOItem OnReadWrite(AccessRoutine routine, string args, long ret)
{
int fd = GetFirstNumeric(args);
FileState fs;
if (!curFiles.TryGetValue(fd, out fs))
{
fs = new FileState("/Unknown-FD/" + fd.ToString(), FDType.Unknown);
curFiles[fd] = fs;
}
AccessType type = (routine == AccessRoutine.Read ||
routine == AccessRoutine.Readv ||
routine == AccessRoutine.Pread) ?
AccessType.Read : AccessType.Write;
long pos;
if (routine == AccessRoutine.Pread || routine == AccessRoutine.Pwrite)
{
string[] argss = args.Split(argumentSplitter, StringSplitOptions.None);
pos = argss[argss.Length - 1].ParseHexLong();
}
else
{
pos = fs.Position;
fs.Position += ret;
}
return new IOItem(pid, fs.Filename, (short)fd,
type, routine, pos, ret, fs.FDType);
}
/// <summary>
/// Добавить файл к индексу.
/// </summary>
/// <param name="index">Индекс, для которого добавляем.</param>
/// <param name="fileState">Данные о файле.</param>
private void AddFile(Index index, FileState fileState)
{
FileInternalData data = this.fileDataCache.GetActualData(fileState.FileInformation);
bool isFileAcceptable = this.IsFileAcceptableForIndex(index, data);
this.filesForByIndexes[index].AddFile(
fileState.FileInformation.FileName,
isFileAcceptable);
}
private unsafe void UpdateState(string directory, ref FileChangeList changes, ref WIN32_FIND_DATAW file, char* filename)
{
int index = _state.IndexOf(directory, filename);
if (index == -1) // file added
{
string path = new string(filename);
if (file.IsDirectory) {
if (_includeSubdirectories) {
_directories.Add(Path.Combine(directory.TrimEnd('*'), path, "*"));
}
}
changes.AddAdded(directory, path);
var newFileState = new FileState(directory, path);
newFileState.LastWrite = file.LastWrite;
newFileState.FileSize = file.FileSize;
newFileState._version = _version;
_state.Add(directory, path, newFileState);
return;
}
_state.Values[index]._version = _version;
if (file.IsDirectory) {
return;
}
var previousState = _state.Values[index];
if (file.LastWrite != previousState.LastWrite || file.FileSize != previousState.FileSize) {
changes.AddChanged(directory, previousState.Path);
_state.Values[index].LastWrite = file.LastWrite;
_state.Values[index].FileSize = file.FileSize;
}
}
public void ConvertThrowsIfFileStateIsAndInvalidDiffState(FileState fileState)
{
// Act and Assert
var ex = Assert.Throws<InvalidOperationException>(() => HgRepository.Convert(fileState));
Assert.Equal(String.Format("Unsupported status '{0}'.", fileState.ToString()), ex.Message);
}
public IOItem OnMmap(int offsetMultiple, string args)
{
if (args.Contains("_ANON"))
return null;
string[] argss = args.Split(argumentSplitter, StringSplitOptions.None);
int fd = int.Parse(argss[4]);
long length = long.Parse(argss[1]);
long offset = argss[5].ParseHexLong();
FileState fs;
if (!curFiles.TryGetValue(fd, out fs))
{
fs = new FileState("/Unknown-FD/" + fd.ToString(), FDType.Unknown);
curFiles[fd] = fs;
}
return new IOItem(pid, fs.Filename, (short)fd,
AccessType.Read, AccessRoutine.Mmap, offset, length, fs.FDType);
}
private void FileParsed(FileInfo filepath, RawTrack track, FileState state)
{
switch (state)
{
case FileState.Added:
_added++;
break;
case FileState.Updated:
_updated++;
break;
case FileState.AddError:
case FileState.UpdateError:
case FileState.Error:
_error++;
break;
case FileState.Removed:
_removed++;
break;
case FileState.Skipped:
_skipped++;
break;
default:
throw new InvalidOperationException("Unknown filestate.");
}
if (Parsed != null)
Parsed(this, new ScanFileEventArgs(_currentFile, _totalFiles, filepath.FullName, track, state));
}
public IOItem OnAccept(string args, long ret)
{
int accepting = GetFirstNumeric(args);
curFiles[(int)ret] = new FileState("/AcceptFrom/" + accepting, FDType.Socket);
return null;
}
void OnGUI()
{
GUI.enabled = BrowserUtility.guiEnabled;
if (!initGUIStyle)
{
InitializeStyle();
LoadSettings();
}
scrollPosition1 = GUILayout.BeginScrollView(scrollPosition1, false, false, GUI.skin.horizontalScrollbar, blankScrollbar, GUILayout.Height(110));
#region Main button row
GUILayout.BeginHorizontal();
DisplayButtons();
GUILayout.EndHorizontal();
#endregion
GUILayout.Space(12);
GUILayout.Box("", GUILayout.ExpandWidth(true), GUILayout.Height(3));
#region Repository location, initialization
GUILayout.BeginHorizontal();
if (!string.IsNullOrEmpty(BrowserUtility.repositoryLocation))
{
GUILayout.Label(versionControlTypeLogo);
GUILayout.Space(10);
GUILayout.Label(BrowserUtility.repositoryShortName);
GUILayout.FlexibleSpace();
/* TODO: Put this in the settings window
*
if (viewMode != BrowserViewMode.ArtistMode)
{
if (GUILayout.Button("Reinitialize"))
BrowserUtility.OnButton_Init(this);
}
*/
var vm = (BrowserViewMode)EditorGUILayout.EnumPopup(viewMode);
if (vm != viewMode)
{
viewMode = vm;
EditorPrefs.SetInt("UnityVersionControl.BrowserViewMode", (int)viewMode);
}
}
else
{
GUI.color = Color.red;
GUILayout.Label("No project repository found!");
GUI.color = Color.white;
GUILayout.FlexibleSpace();
// Todo, make initialization UI prettier
if (GUILayout.Button("Initialize"))
BrowserUtility.OnButton_Init(this);
var vm = (BrowserViewMode)EditorGUILayout.EnumPopup(viewMode);
if (vm != viewMode)
{
viewMode = vm;
EditorPrefs.SetInt("UnityVersionControl.BrowserViewMode", (int)viewMode);
}
}
GUILayout.EndHorizontal();
#endregion
GUILayout.EndScrollView();
mainScrollPosition = GUILayout.BeginScrollView(mainScrollPosition);
GUILayout.BeginHorizontal();
if (viewMode != BrowserViewMode.ArtistMode && showDiff)
{
GUILayout.BeginVertical(GUILayout.Width(horizontalResizeWidget1 - 3));
}
else
{
GUILayout.BeginVertical();
}
#region First scroll area - Staged files (git)
if (VersionControl.versionControlType == VersionControlType.Git && viewMode != BrowserViewMode.ArtistMode && showStagedFiles)
{
GUILayout.BeginVertical(GUILayout.Height(verticalResizeWidget1 - 3));
GUILayout.BeginHorizontal();
GUILayout.Label("Staged files", EditorStyles.toolbarButton);
stagedFilesFilter = (FileState)EditorGUILayout.EnumMaskField(stagedFilesFilter, EditorStyles.toolbarPopup, GUILayout.Width(100));
GUILayout.EndHorizontal();
scrollPosition2 = GUILayout.BeginScrollView(scrollPosition2, false, false);
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
GUI.backgroundColor *= .5f;
GUILayout.Label("State", EditorStyles.toolbarButton, GUILayout.Width(80));
GUILayout.Label("File", EditorStyles.toolbarButton, GUILayout.Width(300));
GUILayout.Label("Path", EditorStyles.toolbarButton, GUILayout.ExpandWidth(true));
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
filteredStagedFiles.Clear();
filteredStagedFiles.AddRange(BrowserUtility.stagedFiles.Values);
FilterFileList(filteredStagedFiles, true);
for(int i = 0; i < filteredStagedFiles.Count; i++)
{
DisplayFile(filteredStagedFiles[i], i, true, filteredStagedFiles);
}
GUILayout.EndVertical();
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
#endregion
#region Resize widget
if (VersionControl.versionControlType == VersionControlType.Git && viewMode != BrowserViewMode.ArtistMode && showStagedFiles)
{
Rect r = new Rect(position.x, position.y - 220, position.width, position.height);
bool drag = GUIHelpers.ResizeWidget(drag1, ref verticalResizeWidget1, 60, position.height - 180, 6, true, r, this);
if (drag != drag1)
{
drag1 = drag;
EditorPrefs.SetFloat("UnityVersionControl.VWidget1", verticalResizeWidget1);
}
}
#endregion
#region Second scroll area - Working tree
if (VersionControl.versionControlType == VersionControlType.Git && viewMode != BrowserViewMode.ArtistMode && showStagedFiles)
{
GUILayout.BeginVertical(GUILayout.Height(position.height - 126 - verticalResizeWidget1 - 3));
}
GUILayout.BeginHorizontal();
GUILayout.Label("Working tree", EditorStyles.toolbarButton);
workingTreeFilter = (FileState)EditorGUILayout.EnumMaskField(workingTreeFilter, EditorStyles.toolbarPopup, GUILayout.Width(100));
GUILayout.EndHorizontal();
scrollPosition3 = GUILayout.BeginScrollView(scrollPosition3, false, false);
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
GUI.backgroundColor *= .5f;
GUILayout.Label("State", EditorStyles.toolbarButton, GUILayout.Width(80));
if (viewMode != BrowserViewMode.ArtistMode)
{
GUILayout.Label("File", EditorStyles.toolbarButton, GUILayout.Width(300));
}
GUILayout.Label("Path", EditorStyles.toolbarButton, GUILayout.ExpandWidth(true));
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
filteredWorkingTree.Clear();
filteredWorkingTree.AddRange(BrowserUtility.workingTree.Values);
FilterFileList(filteredWorkingTree, false);
for(int i = 0; i < filteredWorkingTree.Count; i++)
{
DisplayFile(filteredWorkingTree[i], i, false, filteredWorkingTree);
}
GUILayout.EndVertical();
GUILayout.EndScrollView();
if (VersionControl.versionControlType == VersionControlType.Git && viewMode != BrowserViewMode.ArtistMode && showStagedFiles)
{
GUILayout.EndVertical();
}
#endregion
GUILayout.EndVertical();
#region Resize widget
if (viewMode != BrowserViewMode.ArtistMode && showDiff)
{
bool drag = GUIHelpers.ResizeWidget(drag2, ref horizontalResizeWidget1, 80, position.width - 80, 4, false, position, this);
if (drag != drag2)
{
drag2 = drag;
EditorPrefs.SetFloat("UnityVersionControl.HWidget1", horizontalResizeWidget1);
}
}
#endregion
#region 3rd scroll area - Diff
if (viewMode != BrowserViewMode.ArtistMode && showDiff)
{
GUILayout.BeginVertical(GUILayout.Width(position.width - horizontalResizeWidget1));
GUILayout.BeginHorizontal();
GUILayout.Label("Diff", EditorStyles.toolbarButton, GUILayout.ExpandWidth(true));
GUILayout.EndHorizontal();
scrollPosition4 = GUILayout.BeginScrollView(scrollPosition4, false, false);
EditorGUILayout.SelectableLabel(BrowserUtility.diffString, GUILayout.ExpandHeight(true));
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
#endregion
GUILayout.EndHorizontal();
GUILayout.EndScrollView();
#region Status bar
DisplayStatusBar();
#endregion
GUI.enabled = BrowserUtility.guiEnabled;
if (BrowserUtility.guiEnabled)
{
BrowserUtility.ProcessKeyboardEvents(ref lastSelectedIndex, filteredStagedFiles, filteredWorkingTree);
}
}
private void FileParsed(FileInfo filepath, FileState state)
{
RawTrack track = null;
_existingFiles.TryGetValue(filepath, out track);
FileParsed(filepath, track, state);
}
internal static ChangeType Convert(FileState state)
{
switch (state)
{
case FileState.Added:
return ChangeType.Added;
case FileState.Modified:
return ChangeType.Modified;
case FileState.Removed:
return ChangeType.Deleted;
case FileState.Unknown:
return ChangeType.Untracked;
case FileState.Clean:
case FileState.Ignored:
case FileState.Missing:
default:
break;
}
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
Resources.Error_UnsupportedStatus,
state));
}
void LoadSettings()
{
// View Mode
viewMode = (BrowserViewMode)EditorPrefs.GetInt("UnityVersionControl.BrowserViewMode", (int)BrowserViewMode.Default);
// Staged Files Filter
stagedFilesFilter = (FileState)EditorPrefs.GetInt("UnityVersionControl.StagedFilesFilter",
(int)(FileState.Added | FileState.Copied | FileState.Deleted | FileState.Modified | FileState.Renamed | FileState.Unmerged | FileState.Unmodified | FileState.Untracked | FileState.Ignored));
// Working Tree Filter
workingTreeFilter = (FileState)EditorPrefs.GetInt("UnityVersionControl.WorkingTreeFilter",
(int)(FileState.Added | FileState.Copied | FileState.Deleted | FileState.Modified | FileState.Renamed | FileState.Unmerged | FileState.Untracked));
// Diff Widget
horizontalResizeWidget1 = Mathf.Clamp(EditorPrefs.GetFloat("UnityVersionControl.HWidget1", position.width - 500), 80, position.width - 80);
// Tree/Index Widget
verticalResizeWidget1 = Mathf.Clamp(EditorPrefs.GetFloat("UnityVersionControl.VWidget1", (position.height - 220) / 2), 60, position.height - 180);
// Show staged files
showStagedFiles = EditorPrefs.GetBool("UnityVersionControl.ShowStagedFiles", true);
// Show diff
showDiff = EditorPrefs.GetBool("UnityVersionControl.ShowDiff", true);
}
private ChangeType Convert(FileState state)
{
switch (state) {
case FileState.Added:
return ChangeType.Added;
case FileState.Clean:
break;
case FileState.Ignored:
break;
case FileState.Missing:
break;
case FileState.Modified:
return ChangeType.Modified;
case FileState.Removed:
return ChangeType.Deleted;
case FileState.Unknown:
return ChangeType.Untracked;
default:
break;
}
throw new InvalidOperationException("Unsupported status " + state);
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += HandleException;
var clearTable = bool.Parse(ConfigurationManager.AppSettings["ClearTable"]);
if (clearTable)
{
using (var connection = new SqlConnection(connectionString))
using (var command = new SqlCommand(string.Format("truncate table [{0}]", tableName), connection))
{
connection.Open();
command.ExecuteNonQuery();
connection.Close();
}
}
var folders = new List<string>();
var serverNames = ConfigurationManager.AppSettings["ServerNames"].Split('|');
foreach (var serverName in serverNames)
{
Console.WriteLine("Opening {0}...", serverName);
using (var serverManager = ServerManager.OpenRemote(serverName))
{
Console.WriteLine("{0} opened.\r\n", serverName);
foreach (var site in serverManager.Sites)
{
Console.WriteLine("\tSite name: {0}; Id: {1};", site.Name, site.Id);
Console.WriteLine("\tLog Enabled: {0}; Format: {1}; Columns: {2}", site.LogFile.Enabled, site.LogFile.LogFormat, site.LogFile.LogExtFileFlags);
var folder = String.Format("{0}\\W3SVC{1}", site.LogFile.Directory, site.Id);
if (serverName.Equals(Environment.MachineName, StringComparison.OrdinalIgnoreCase))
folder = "C:" + folder.Substring(13) + "\\";
else
folder = "\\\\" + serverName + "\\C$" + folder.Substring(13) + "\\";
Console.WriteLine("\tLog Folder: {0}\r\n", folder);
folders.Add(folder);
siteNameMapping.Add(string.Format("{0}-W3SVC{1}", serverName, site.Id), site.Name);
}
}
}
var isStandard = bool.Parse(ConfigurationManager.AppSettings["IsStandard"]);
var startDate = DateTime.Parse(ConfigurationManager.AppSettings["StartDate"]);
var endDate = DateTime.Parse(ConfigurationManager.AppSettings["EndDate"]);
var dayStep = int.Parse(ConfigurationManager.AppSettings["DayStep"]);
if (endDate.Date > DateTime.UtcNow.Date)
endDate = DateTime.UtcNow.Date;
foreach (var folder in folders)
{
var date = startDate;
while (date <= endDate)
{
var filename = string.Format("{0}{1}_ex{2:yyMMdd}.log", folder, isStandard ? "u" : "h", date);
var fileState = new FileState(filename, date); // @"C:\inetpub\logs\LogFiles\W3SVC1\u_ex130228.log"
files.Add(fileState);
date = date.AddDays(dayStep);
}
}
files = files.OrderBy(f => f.FileUtcDate).ThenBy(f => f.Filename).ToList();
var concurrentFiles = int.Parse(ConfigurationManager.AppSettings["ConcurrentFiles"]);
for (var i = 0; i < Math.Min(files.Count, concurrentFiles); i++)
ThreadPool.QueueUserWorkItem(ConsumeFile, null);
Console.WriteLine("Press any enter to quit monitoring.\r\n");
Console.ReadLine();
}
public void AttemptLoadFrom(string file)
{
if (!file.EndsWith(".xml") && file != "")
Extract(file);
else if (file.EndsWith(".xml"))
{
XMLText.Text = file;
XMLState = FileState.Ready;
}
LocateOtherFiles(file);
Load();
}
private void Load()
{
if (XMLState != FileState.Ready || HistoryState != FileState.Ready || SitesState != FileState.Ready || MapState != FileState.Ready)
return;
if (!(File.Exists(XMLText.Text) && File.Exists(HistoryText.Text) && File.Exists(SitesText.Text) && File.Exists(MapText.Text)))
return;
string[] files = new string[] { XMLText.Text, HistoryText.Text, SitesText.Text, MapText.Text };
Working = true;
XMLButton.Enabled = HistoryButton.Enabled = SitesButton.Enabled = MapButton.Enabled = false;
LogText.Clear();
StatusLabel.Text = "Loading...";
StatusLabel.ForeColor = Color.Blue;
BackgroundWorker load = new BackgroundWorker();
load.DoWork += load_DoWork;
load.RunWorkerCompleted += load_RunWorkerCompleted;
load.RunWorkerAsync(files);
while (load.IsBusy) Application.DoEvents();
Working = false;
XMLButton.Enabled = HistoryButton.Enabled = SitesButton.Enabled = MapButton.Enabled = true;
XMLState = HistoryState = SitesState = MapState = FileState.Default;
}
private void extract_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Error != null)
{
StatusLabel.Text = "ERROR!";
StatusLabel.ForeColor = Color.Red;
LogText.Text = e.Error.Message;
foreach (string delete in ExtractedFiles)
File.Delete(delete);
ExtractedFiles.Clear();
Working = false;
}
else
{
XMLText.Text = ExtractedFiles[0];
XMLState = FileState.Ready;
HistoryText.Text = ExtractedFiles[1];
HistoryState = FileState.Ready;
SitesText.Text = ExtractedFiles[2];
SitesState = FileState.Ready;
MapText.Text = ExtractedFiles[3];
MapState = FileState.Ready;
}
}
public IOItem OnOpen(string args, long ret)
{
int fd = (int)ret;
string filename = regexOpen.Match(args).Groups[1].Value;
curFiles[fd] = new FileState(NormalizeFilename(filename));
return null;
}
public IOItem OnSocket(string args, long ret)
{
curFiles[(int)ret] = new FileState("/Socket/" + ret, FDType.Socket);
return null;
}
public string GetState(bool write) {
#if SVPN_NUNIT
return String.Empty;
#else
FileState fstate = new FileState();
SocialState state = new SocialState();
if(_node.LocalUser != null) {
state.LocalUser = _node.LocalUser;
fstate.Uid = state.LocalUser.Uid;
fstate.PCID = state.LocalUser.PCID;
}
state.Friends = new SocialUser[_node.Friends.Values.Count];
state.Networks = new NetworkState[_networks.Values.Count];
state.Pending = new string[_pending.Count];
fstate.Friends = new FriendState[_node.Friends.Values.Count];
_pending.CopyTo(state.Pending, 0);
int i = 0;
foreach (KeyValuePair<string, ISocialNetwork> kvp
in _networks) {
state.Networks[i] = new NetworkState();
state.Networks[i].Name = kvp.Key;
state.Networks[i].Message = kvp.Value.Message;
i++;
}
i = 0;
foreach(SocialUser user in _node.Friends.Values) {
string status;
if(_node.IsAllowed(user.Address)) {
if(IsOffline(user.Address)) {
status = StatusTypes.Offline.ToString();
}
else {
status = StatusTypes.Online.ToString();
}
}
else {
status = StatusTypes.Blocked.ToString();
}
state.Friends[i] = new SocialUser(user.Certificate, user.IP,
status);
FriendState friend = new FriendState();
friend.Certificate = user.Certificate;
friend.IP = user.IP;
friend.Status = status;
fstate.Friends[i] = friend;
i++;
}
if(write) {
Utils.WriteConfig(STATEPATH, fstate);
}
return SocialUtils.ObjectToXml<SocialState>(state);
#endif
}
public IOItem OnPipe(string args)
{
Match m = regexPipe.Match(args);
int reading = int.Parse(m.Groups[1].Value);
int writing = int.Parse(m.Groups[2].Value);
curFiles[reading] = new FileState("/Pipe/" + reading, FDType.Pipe);
curFiles[writing] = new FileState("/Pipe/" + writing, FDType.Pipe);
return null;
}
