public Task <TOutput> InvokeAsync(TParameters parameters, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
Verify.Argument.IsNotNull(parameters, "parameters");
var command = CreateCommand(parameters);
var parser = CreateParser();
var stdOutReceiver = new AsyncTextParser(parser);
var stdErrReceiver = new AsyncTextReader();
return(_commandExecutor
.ExecuteCommandAsync(
command, stdOutReceiver, stdErrReceiver, GetExecutionFlags(), cancellationToken)
.ContinueWith(task =>
{
int exitCode = TaskUtility.UnwrapResult(task);
if (exitCode != 0)
{
HandleNonZeroExitCode(stdErrReceiver, exitCode);
}
return parser.GetResult();
},
cancellationToken,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default));
}
static IEnumerator <object> ReceiveTask(SocketDataAdapter adapter)
{
var input = new AsyncTextReader(adapter, Encoding.ASCII);
int i = 0;
string message = null;
Reader = input;
while (true)
{
var f = input.ReadLine();
yield return(f);
if (!f.GetResult(out message))
{
throw new DisconnectedException();
}
if (message == null)
{
throw new DisconnectedException();
}
else
{
i += 1;
}
if ((i % 1000) == 0)
{
Console.WriteLine("Recieved: {0}", i);
}
}
}
private Task <GitOutput> ExecuteCommandAsyncCore(Command command, Encoding encoding, CommandExecutionFlags flags, CancellationToken cancellationToken)
{
OnCommandExecuting(command);
var stdOutReceiver = new AsyncTextReader();
var stdErrReceiver = new AsyncTextReader();
var input = PrepareInput(command, encoding);
var processExecutor = CreateProcessExecutor();
var cancellationMethod = GetCancellationMethod(flags);
return(processExecutor
.ExecuteAsync(
input,
stdOutReceiver,
stdErrReceiver,
cancellationMethod,
cancellationToken)
.ContinueWith(
task =>
{
int exitCode = TaskUtility.UnwrapResult(task);
var stdOut = stdOutReceiver.GetText();
var stdErr = stdErrReceiver.GetText();
return new GitOutput(stdOut, stdErr, exitCode);
},
cancellationToken,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default));
}
public IEnumerator <object> ServeProcessIndex(HttpListenerContext context, ProcessInfo process)
{
var authLevel = GetAuthLevel(context);
if (authLevel == AuthLevel.Unauthorized)
{
context.Response.Redirect("/eve/login");
yield break;
}
context.Response.ContentType = "text/html";
context.Response.AddHeader("X-UA-Compatible", "IE=edge");
var sauce = GetSauceForUser(context, false);
using (var stream = GetResourceStream("process_index.html"))
using (var reader = new AsyncTextReader(new StreamDataAdapter(stream, false), Encoding.UTF8)) {
string indexHtml = null;
yield return(reader.ReadToEnd().Bind(() => indexHtml));
indexHtml = indexHtml.Replace("{pid}", process.Process.Id.ToString())
.Replace("{authLevel}", authLevel.ToString());
using (var writer = context.GetResponseWriter(Encoding.UTF8))
yield return(writer.Write(indexHtml));
}
}
public Task <byte[]> InvokeAsync(TParameters parameters, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
Verify.Argument.IsNotNull(parameters, nameof(parameters));
var command = _commandFactory(parameters);
var stdInReceiver = new AsyncBytesReader();
var stdErrReceiver = new AsyncTextReader();
return(_commandExecutor
.ExecuteCommandAsync(
command,
stdInReceiver,
stdErrReceiver,
CommandExecutionFlags.None,
cancellationToken)
.ContinueWith(
t =>
{
var exitCode = TaskUtility.UnwrapResult(t);
if (exitCode != 0)
{
throw new GitException(stdErrReceiver.GetText());
}
return stdInReceiver.GetBytes();
},
cancellationToken,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default));
}
public static AsyncTextReader GetRequestReader(this HttpListenerContext context)
{
var encoding = context.Request.ContentEncoding ?? Encoding.UTF8;
var adapter = new StreamDataAdapter(context.Request.InputStream, true);
var result = new AsyncTextReader(adapter, encoding);
return(result);
}
public Task <IList <ReferencePushResult> > InvokeAsync(PushParameters parameters,
IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
Verify.Argument.IsNotNull(parameters, nameof(parameters));
var command = _commandFactory(parameters, true);
progress?.Report(new OperationProgress(Resources.StrsConnectingToRemoteHost.AddEllipsis()));
var errorMessages = default(List <string>);
var stdOutReceiver = new AsyncTextReader();
var stdErrReceiver = new NotifyingAsyncTextReader();
stdErrReceiver.TextLineReceived += (s, e) =>
{
if (!string.IsNullOrWhiteSpace(e.Text))
{
var parser = new GitParser(e.Text);
var operationProgress = parser.ParseProgress();
progress?.Report(operationProgress);
if (operationProgress.IsIndeterminate)
{
if (errorMessages == null)
{
errorMessages = new List <string>();
}
errorMessages.Add(operationProgress.ActionName);
}
else
{
errorMessages?.Clear();
}
}
};
return(_commandExecutor
.ExecuteCommandAsync(
command,
stdOutReceiver,
stdErrReceiver,
CommandExecutionFlags.None,
cancellationToken)
.ContinueWith(task =>
{
int exitCode = TaskUtility.UnwrapResult(task);
if (exitCode != 0)
{
var errorMessage = errorMessages != null && errorMessages.Count != 0
? string.Join(Environment.NewLine, errorMessages)
: string.Format(CultureInfo.InvariantCulture, "git process exited with code {0}", exitCode);
throw new GitException(errorMessage);
}
return _resultsParser(stdOutReceiver.GetText());
},
cancellationToken,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default));
}
public GitOutput ExecuteCommand(Command command, Encoding encoding, CommandExecutionFlags flags)
{
OnCommandExecuting(command);
var stdOutReceiver = new AsyncTextReader();
var stdErrReceiver = new AsyncTextReader();
var executor = CreateProcessExecutor();
var exitCode = executor.Execute(PrepareInput(command, encoding), stdOutReceiver, stdErrReceiver);
return new GitOutput(stdOutReceiver.GetText(), stdErrReceiver.GetText(), exitCode);
}
public GitOutput ExecuteCommand(Command command, Encoding encoding, CommandExecutionFlags flags)
{
OnCommandExecuting(command);
var stdOutReceiver = new AsyncTextReader();
var stdErrReceiver = new AsyncTextReader();
var executor = CreateProcessExecutor();
var exitCode = executor.Execute(PrepareInput(command, encoding), stdOutReceiver, stdErrReceiver);
return(new GitOutput(stdOutReceiver.GetText(), stdErrReceiver.GetText(), exitCode));
}
public static IEnumerator <object> RunProcessWithResult(ProcessStartInfo psi, ProcessPriorityClass?priority = null)
{
psi.UseShellExecute = false;
psi.CreateNoWindow = true;
psi.RedirectStandardOutput = true;
psi.RedirectStandardError = true;
psi.WindowStyle = ProcessWindowStyle.Hidden;
var fProcess = StartProcess(psi);
yield return(fProcess);
if (priority.HasValue)
{
try {
fProcess.Result.PriorityClass = priority.Value;
} catch {
}
}
using (var process = fProcess.Result)
using (var stdout = new AsyncTextReader(
new StreamDataAdapter(process.StandardOutput.BaseStream, false), Encoding.ASCII, 1024 * 16
))
using (var stderr = new AsyncTextReader(
new StreamDataAdapter(process.StandardError.BaseStream, false), Encoding.ASCII, 1024 * 16
))
try {
var fStdOut = stdout.ReadToEnd();
var fStdErr = stderr.ReadToEnd();
yield return(WaitForProcessExit(process));
yield return(fStdOut);
yield return(fStdErr);
yield return(new Result(new RunProcessResult {
StdOut = fStdOut.Result,
StdErr = fStdErr.Result,
ExitCode = process.ExitCode
}));
} finally {
try {
if (!process.HasExited)
{
process.Kill();
}
} catch {
}
}
}
public static Version CheckVersion(string gitExe)
{
var stdErrReceiver = new AsyncTextReader();
var stdOutReceiver = new AsyncTextReader();
var executor = new GitProcessExecutor(gitExe);
var exitCode = executor.Execute(new GitInput(new Command("--version")), stdOutReceiver, stdErrReceiver);
var output = new GitOutput(stdOutReceiver.GetText(), stdErrReceiver.GetText(), exitCode);
output.ThrowOnBadReturnCode();
var parser = new GitParser(output.Output);
return(parser.ReadVersion());
}
static IEnumerator <object> PeerTask(TcpClient client, Peer peer)
{
var adapter = new SocketDataAdapter(client.Client, true);
var input = new AsyncTextReader(adapter, Encoding.ASCII);
var output = new AsyncTextWriter(adapter, Encoding.ASCII);
adapter.ThrowOnDisconnect = false;
adapter.ThrowOnFullSendBuffer = false;
output.AutoFlush = true;
peer.Input = input;
peer.Output = output;
yield return(output.WriteLine("Welcome! Please enter your name."));
string name = null;
yield return(input.ReadLine().Bind(() => name));
if (name == null)
{
PeerDisconnected(peer);
yield break;
}
peer.Name = name;
PeerConnected(peer);
yield return(output.Write(VT100.EraseScreen));
string nextLine = null;
while (peer.Connected)
{
var f = input.ReadLine();
yield return(f);
if (!f.GetResult(out nextLine) || nextLine == null)
{
PeerDisconnected(peer);
yield break;
}
if (nextLine.Length > 0)
{
DispatchNewMessage(peer, nextLine);
}
}
}
public static GitOutput Execute(GitInput input)
{
Verify.Argument.IsNotNull(input, "input");
var stdOutReader = new AsyncTextReader();
var stdErrReader = new AsyncTextReader();
var executor = new GitProcessExecutor(GitExePath);
var exitCode = executor.Execute(input, stdOutReader, stdErrReader);
return(new GitOutput(
stdOutReader.GetText(),
stdErrReader.GetText(),
exitCode));
}
internal TelnetClient(TelnetServer server, TcpClient client)
{
Server = server;
client.Client.NoDelay = true;
client.Client.Blocking = false;
Data = new SocketDataAdapter(client.Client, true);
Data.ThrowOnDisconnect = false;
Data.ThrowOnFullSendBuffer = false;
Encoding encoding = Encoding.ASCII;
Input = new AsyncTextReader(Data, encoding);
Output = new AsyncTextWriter(Data, encoding);
Output.AutoFlush = true;
_SendFuture = server._Scheduler.Start(SendMessagesTask(), TaskExecutionPolicy.RunWhileFutureLives);
}
public TOutput Invoke(TParameters parameters)
{
Verify.Argument.IsNotNull(parameters, "parameters");
var command = CreateCommand(parameters);
var parser = CreateParser();
var stdOutReceiver = new AsyncTextParser(parser);
var stdErrReceiver = new AsyncTextReader();
var exitCode = _commandExecutor.ExecuteCommand(
command, stdOutReceiver, stdErrReceiver, GetExecutionFlags());
if (exitCode != 0)
{
HandleNonZeroExitCode(stdErrReceiver, exitCode);
}
return(parser.GetResult());
}
public IEnumerator <object> ServeLoginPage(HttpListenerContext context)
{
context.Response.ContentType = "text/html";
var isPost = context.Request.HttpMethod == "POST";
var sauce = GetSauceForUser(context, !isPost);
if (isPost)
{
NameValueCollection requestBody = null;
yield return(Future.RunInThread(() => context.ParseRequestBody())
.Bind(() => requestBody));
var hmac = requestBody["hmac"];
var authLevel = CheckAuthLevel(context, hmac);
if (authLevel != AuthLevel.Unauthorized)
{
var authToken = GenAuthToken(context, hmac);
var cookie = new Cookie(
AuthTokenCookie, authToken
);
cookie.HttpOnly = true;
context.Response.Cookies.Add(cookie);
var redirectTo = "/eve/" + (context.Request.QueryString["redirect_to"] ?? "index");
context.Response.Redirect(redirectTo);
yield break;
}
}
using (var stream = GetResourceStream("login.html"))
using (var reader = new AsyncTextReader(new StreamDataAdapter(stream, false), Encoding.UTF8)) {
string loginHtml = null;
yield return(reader.ReadToEnd().Bind(() => loginHtml));
loginHtml = loginHtml.Replace("{sauce}", sauce);
using (var writer = context.GetResponseWriter(Encoding.UTF8))
yield return(writer.Write(loginHtml));
}
}
public async Task <TOutput> InvokeAsync(TParameters parameters, IProgress <OperationProgress> progress, CancellationToken cancellationToken)
{
Verify.Argument.IsNotNull(parameters, nameof(parameters));
var command = CreateCommand(parameters);
var parser = CreateParser();
var stdOutReceiver = new AsyncTextParser(parser);
var stdErrReceiver = new AsyncTextReader();
var processExitCode = await _commandExecutor
.ExecuteCommandAsync(command, stdOutReceiver, stdErrReceiver, GetExecutionFlags(), cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
if (processExitCode != 0)
{
HandleNonZeroExitCode(stdErrReceiver, processExitCode);
}
return(parser.GetResult());
}
public byte[] Invoke(TParameters parameters)
{
Verify.Argument.IsNotNull(parameters, nameof(parameters));
var command = _commandFactory(parameters);
var stdInReceiver = new AsyncBytesReader();
var stdErrReceiver = new AsyncTextReader();
var exitCode = _commandExecutor.ExecuteCommand(
command,
stdInReceiver,
stdErrReceiver,
CommandExecutionFlags.None);
if (exitCode != 0)
{
throw new GitException(stdErrReceiver.GetText());
}
return(stdInReceiver.GetBytes());
}
private async Task <GitOutput> ExecuteCommandAsyncCore(Command command, Encoding encoding, CommandExecutionFlags flags, CancellationToken cancellationToken)
{
OnCommandExecuting(command);
var stdOutReceiver = new AsyncTextReader();
var stdErrReceiver = new AsyncTextReader();
var input = PrepareInput(command, encoding);
var processExecutor = CreateProcessExecutor();
var cancellationMethod = GetCancellationMethod(flags);
var exitCode = await processExecutor
.ExecuteAsync(
input,
stdOutReceiver,
stdErrReceiver,
cancellationMethod,
cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
var stdOut = stdOutReceiver.GetText();
var stdErr = stdErrReceiver.GetText();
return(new GitOutput(stdOut, stdErr, exitCode));
}
protected virtual void HandleNonZeroExitCode(AsyncTextReader stdErrReceiver, int exitCode)
{
Assert.IsNotNull(stdErrReceiver);
throw new GitException(stdErrReceiver.GetText());
}
private IEnumerator <object> RequestTask(ListenerContext context, SocketDataAdapter adapter)
{
var startedWhen = DateTime.UtcNow;
bool successful = false;
try {
const int headerBufferSize = 1024 * 32;
const int bodyBufferSize = 1024 * 128;
const double requestLineTimeout = 5;
// RFC2616:
// Words of *TEXT MAY contain characters from character sets other than ISO-8859-1 [22]
// only when encoded according to the rules of RFC 2047 [14].
Encoding headerEncoding;
try {
headerEncoding = Encoding.GetEncoding("ISO-8859-1");
} catch {
headerEncoding = Encoding.ASCII;
}
Request request;
RequestBody body;
HeaderCollection headers;
long bodyBytesRead = 0;
long? expectedBodyLength = null;
var reader = new AsyncTextReader(adapter, headerEncoding, headerBufferSize, false);
string requestLineText;
while (true)
{
var fRequestLine = reader.ReadLine();
var fRequestOrTimeout = Scheduler.Start(new WaitWithTimeout(fRequestLine, requestLineTimeout));
yield return(fRequestOrTimeout);
if (fRequestOrTimeout.Failed)
{
if (!(fRequestOrTimeout.Error is TimeoutException))
{
OnRequestError(fRequestOrTimeout.Error);
}
yield break;
}
if (fRequestLine.Failed)
{
if (!(fRequestLine.Error is SocketDisconnectedException))
{
OnRequestError(fRequestLine.Error);
}
yield break;
}
requestLineText = fRequestLine.Result;
// RFC2616:
// In the interest of robustness, servers SHOULD ignore any empty line(s) received where a
// Request-Line is expected. In other words, if the server is reading the protocol stream
// at the beginning of a message and receives a CRLF first, it should ignore the CRLF.
if ((requestLineText != null) && (requestLineText.Trim().Length == 0))
{
continue;
}
break;
}
var requestLineParsed = DateTime.UtcNow;
headers = new HeaderCollection();
while (true)
{
var fHeaderLine = reader.ReadLine();
yield return(fHeaderLine);
if (String.IsNullOrWhiteSpace(fHeaderLine.Result))
{
break;
}
headers.Add(new Header(fHeaderLine.Result));
}
var headersParsed = DateTime.UtcNow;
var expectHeader = (headers.GetValue("Expect") ?? "").ToLowerInvariant();
var expectsContinue = expectHeader.Contains("100-continue");
string hostName;
if (headers.Contains("Host"))
{
hostName = String.Format("http://{0}", headers["Host"].Value);
}
else
{
var lep = (IPEndPoint)adapter.Socket.LocalEndPoint;
hostName = String.Format("http://{0}:{1}", lep.Address, lep.Port);
}
var requestLine = new RequestLine(hostName, requestLineText);
var remainingBytes = reader.DisposeAndGetRemainingBytes();
bodyBytesRead += remainingBytes.Count;
var connectionHeader = (headers.GetValue("Connection") ?? "").ToLowerInvariant();
var shouldKeepAlive =
((requestLine.Version == "1.1") || connectionHeader.Contains("keep-alive")) &&
!connectionHeader.Contains("close");
if (headers.Contains("Content-Length"))
{
expectedBodyLength = long.Parse(headers["Content-Length"].Value);
}
body = new RequestBody(remainingBytes, expectedBodyLength);
if (expectsContinue)
{
yield return(adapter.Write(Continue100, 0, Continue100.Length));
}
request = new Request(
this, adapter, shouldKeepAlive,
requestLine, headers, body
);
IncomingRequests.Enqueue(request);
var requestEnqueued = DateTime.UtcNow;
DateTime?requestBodyRead = null;
// FIXME: I think it's technically accepted to send a body without a content-length, but
// it seems to be impossible to make that work right.
if (expectedBodyLength.HasValue)
{
using (var bodyBuffer = BufferPool <byte> .Allocate(bodyBufferSize))
while (bodyBytesRead < expectedBodyLength.Value)
{
long bytesToRead = Math.Min(expectedBodyLength.Value - bodyBytesRead, bodyBufferSize);
if (bytesToRead <= 0)
{
break;
}
var fBytesRead = adapter.Read(bodyBuffer.Data, 0, (int)bytesToRead);
yield return(fBytesRead);
if (fBytesRead.Failed)
{
if (fBytesRead.Error is SocketDisconnectedException)
{
break;
}
body.Failed(fBytesRead.Error);
OnRequestError(fBytesRead.Error);
yield break;
}
var bytesRead = fBytesRead.Result;
bodyBytesRead += bytesRead;
body.Append(bodyBuffer.Data, 0, bytesRead);
}
requestBodyRead = DateTime.UtcNow;
}
body.Finish();
successful = true;
request.Timing = new Request.TimingData {
Line = (requestLineParsed - startedWhen),
Headers = (headersParsed - requestLineParsed),
Queue = (requestEnqueued - headersParsed),
Body = (requestBodyRead - requestEnqueued)
};
} finally {
if (!successful)
{
adapter.Dispose();
}
}
}
public static IEnumerator <object> IssueRequest(HttpWebRequest request)
{
var fResponse = new Future <HttpWebResponse>();
ThreadPool.QueueUserWorkItem(
(__) => {
try {
request.BeginGetResponse(
(ar) => {
try {
var _ = (HttpWebResponse)request.EndGetResponse(ar);
fResponse.SetResult(_, null);
} catch (Exception ex) {
fResponse.SetResult(null, ex);
}
}, null
);
} catch (Exception ex_) {
fResponse.SetResult(null, ex_);
}
}
);
yield return(fResponse);
if (fResponse.Failed)
{
throw new RequestFailedException(fResponse.Error);
}
using (var response = fResponse.Result) {
var fResponseStream = Future.RunInThread(
() => response.GetResponseStream()
);
yield return(fResponseStream);
Encoding encoding = AsyncTextReader.DefaultEncoding;
if (!string.IsNullOrEmpty(response.CharacterSet))
{
encoding = Encoding.GetEncoding(response.CharacterSet);
}
string responseText;
using (var stream = fResponseStream.Result)
using (var adapter = new AsyncTextReader(new StreamDataAdapter(stream, false), encoding)) {
var fText = adapter.ReadToEnd();
yield return(fText);
responseText = fText.Result;
}
var cookies = new Cookie[response.Cookies.Count];
response.Cookies.CopyTo(cookies, 0);
yield return(new Result(new Response {
Body = responseText,
ContentType = response.ContentType,
StatusCode = response.StatusCode,
StatusDescription = response.StatusDescription,
Cookies = cookies
}));
}
}
public static Version CheckVersion(string gitExe)
{
var stdErrReceiver = new AsyncTextReader();
var stdOutReceiver = new AsyncTextReader();
var executor = new GitProcessExecutor(gitExe);
var exitCode = executor.Execute(new GitInput(new Command("--version")), stdOutReceiver, stdErrReceiver);
var output = new GitOutput(stdOutReceiver.GetText(), stdErrReceiver.GetText(), exitCode);
output.ThrowOnBadReturnCode();
var parser = new GitParser(output.Output);
return parser.ReadVersion();
}
public static GitOutput Execute(GitInput input)
{
Verify.Argument.IsNotNull(input, "input");
var stdOutReader = new AsyncTextReader();
var stdErrReader = new AsyncTextReader();
var executor = new GitProcessExecutor(GitExePath);
var exitCode = executor.Execute(input, stdOutReader, stdErrReader);
return new GitOutput(
stdOutReader.GetText(),
stdErrReader.GetText(),
exitCode);
}
private Task<GitOutput> ExecuteCommandAsyncCore(Command command, Encoding encoding, CommandExecutionFlags flags, CancellationToken cancellationToken)
{
OnCommandExecuting(command);
var stdOutReceiver = new AsyncTextReader();
var stdErrReceiver = new AsyncTextReader();
var input = PrepareInput(command, encoding);
var processExecutor = CreateProcessExecutor();
var cancellationMethod = GetCancellationMethod(flags);
return processExecutor
.ExecuteAsync(
input,
stdOutReceiver,
stdErrReceiver,
cancellationMethod,
cancellationToken)
.ContinueWith(
task =>
{
int exitCode = TaskUtility.UnwrapResult(task);
var stdOut = stdOutReceiver.GetText();
var stdErr = stdErrReceiver.GetText();
return new GitOutput(stdOut, stdErr, exitCode);
},
cancellationToken,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default);
}
IEnumerator <object> SearchInFiles(SearchQuery search, BlockingQueue <string> filenames, IFuture completionFuture)
{
var searchedFiles = new HashSet <string>(StringComparer.Ordinal);
var buffer = new List <SearchResult>();
var sb = new StringBuilder();
int numFiles = 0;
using (Finally.Do(() => {
SetSearchResults(buffer);
lblStatus.Text = String.Format("{0} result(s) found.", buffer.Count);
pbProgress.Style = ProgressBarStyle.Continuous;
pbProgress.Value = 0;
}))
while (filenames.Count > 0 || !completionFuture.Completed)
{
var f = filenames.Dequeue();
yield return(f);
var filename = f.Result as string;
if (filename == null)
{
continue;
}
if (searchedFiles.Contains(filename))
{
continue;
}
if (PendingSearchQuery != null)
{
break;
}
searchedFiles.Add(filename);
int lineNumber = 0;
var lineBuffer = new LineEntry[3];
var insertResult = (Action)(() => {
var item = new SearchResult();
item.Filename = filename;
item.LineNumber = lineBuffer[1].LineNumber;
sb.Remove(0, sb.Length);
for (int i = 0; i < 3; i++)
{
if (lineBuffer[i].Text != null)
{
var line = lineBuffer[i].Text;
if (line.Length > 512)
{
line = line.Substring(0, 512);
}
sb.Append(line);
}
if (i < 2)
{
sb.Append("\r\n");
}
}
item.Context = sb.ToString();
buffer.Add(item);
if ((buffer.Count % 250 == 0) || ((buffer.Count < 50) && (buffer.Count % 5 == 1)))
{
SetSearchResults(buffer);
}
});
var stepSearch = (Action)(() => {
string currentLine = lineBuffer[1].Text;
if ((currentLine != null) && search.Regex.IsMatch(currentLine))
{
insertResult();
}
});
var insertLine = (Action <LineEntry>)((line) => {
lineBuffer[0] = lineBuffer[1];
lineBuffer[1] = lineBuffer[2];
lineBuffer[2] = line;
stepSearch();
});
numFiles += 1;
if (numFiles % 50 == 0)
{
lblStatus.Text = String.Format("Scanning '{0}'...", filename);
if (completionFuture.Completed)
{
int totalNumFiles = numFiles + filenames.Count;
int progress = (numFiles * 1000 / totalNumFiles);
if (pbProgress.Value != progress)
{
pbProgress.Value = progress;
}
if (pbProgress.Style != ProgressBarStyle.Continuous)
{
pbProgress.Style = ProgressBarStyle.Continuous;
}
}
}
// Opening files is slow over network shares.
FileDataAdapter adapter = null;
var fAdapter = Future.RunInThread(
() => new FileDataAdapter(filename, System.IO.FileMode.Open, System.IO.FileAccess.Read)
);
yield return(fAdapter);
if (fAdapter.Failed)
{
continue;
}
else
{
adapter = fAdapter.Result;
}
using (adapter) {
var fEncoding = Future.RunInThread(
() => DetectEncoding(adapter.BaseStream)
);
yield return(fEncoding);
Future <string> thisLine = null, nextLine = null;
using (var reader = new AsyncTextReader(adapter, fEncoding.Result, SearchBufferSize))
while (true)
{
thisLine = nextLine;
if (thisLine != null)
{
yield return(thisLine);
}
nextLine = reader.ReadLine();
if (thisLine == null)
{
continue;
}
lineNumber += 1;
string line = thisLine.Result;
insertLine(new LineEntry {
Text = line, LineNumber = lineNumber
});
if (line == null)
{
break;
}
if (PendingSearchQuery != null)
{
break;
}
if (lineNumber % 10000 == 5000)
{
var newStatus = String.Format("Scanning '{0}'... (line {1})", filename, lineNumber);
if (lblStatus.Text != newStatus)
{
lblStatus.Text = newStatus;
}
}
}
}
}
}
