| public Write ( byte buffer, int offset, int count ) : void | ||
| buffer | byte | An array of bytes. This method copies count bytes from buffer to the current stream. |
| offset | int | The zero-based byte offset in buffer at which to begin copying bytes to the current stream. |
| count | int | The number of bytes to be written to the current stream. |
| return | void | |
/// <summary>
/// Uploads the specified directory to the remote host.
/// </summary>
/// <param name="directoryInfo">The directory info.</param>
/// <param name="path">The path.</param>
/// <exception cref="ArgumentNullException">fileSystemInfo</exception>
/// <exception cref="ArgumentException"><paramref name="path"/> is null or empty.</exception>
public void Upload(DirectoryInfo directoryInfo, string path)
{
if (directoryInfo == null)
throw new ArgumentNullException("directoryInfo");
if (string.IsNullOrEmpty(path))
throw new ArgumentException("path");
using (var input = new PipeStream())
using (var channel = Session.CreateChannelSession())
{
channel.DataReceived += delegate(object sender, ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
// Send channel command request
channel.SendExecRequest(string.Format("scp -rt \"{0}\"", path));
CheckReturnCode(input);
InternalSetTimestamp(channel, input, directoryInfo.LastWriteTimeUtc, directoryInfo.LastAccessTimeUtc);
SendData(channel, string.Format("D0755 0 {0}\n", Path.GetFileName(path)));
CheckReturnCode(input);
InternalUpload(channel, input, directoryInfo);
SendData(channel, "E\n");
CheckReturnCode(input);
channel.Close();
}
}
/// <summary>
/// Downloads the specified directory from the remote host to local directory.
/// </summary>
/// <param name="directoryName">Remote host directory name.</param>
/// <param name="directoryInfo">Local directory information.</param>
/// <exception cref="ArgumentNullException"><paramref name="directoryInfo"/> or <paramref name="directoryName"/> is null.</exception>
public void Download(string directoryName, DirectoryInfo directoryInfo)
{
if (directoryInfo == null)
throw new ArgumentNullException("directoryInfo");
if (string.IsNullOrEmpty(directoryName))
throw new ArgumentException("directoryName");
using (var input = new PipeStream())
using (var channel = this.Session.CreateChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, Common.ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
// Send channel command request
channel.SendExecRequest(string.Format("scp -prf \"{0}\"", directoryName));
this.SendConfirmation(channel); // Send reply
this.InternalDownload(channel, input, directoryInfo);
channel.Close();
}
}
/// <summary>
/// Uploads the specified file to the remote host.
/// </summary>
/// <param name="fileInfo">The file system info.</param>
/// <param name="path">The path.</param>
/// <exception cref="ArgumentNullException"><paramref name="fileInfo" /> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="path"/> is null or empty.</exception>
public void Upload(FileInfo fileInfo, string path)
{
if (fileInfo == null)
throw new ArgumentNullException("fileInfo");
if (string.IsNullOrEmpty(path))
throw new ArgumentException("path");
using (var input = new PipeStream())
using (var channel = this.Session.CreateClientChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
// Send channel command request
channel.SendExecRequest(string.Format("scp -t \"{0}\"", path));
this.CheckReturnCode(input);
this.InternalUpload(channel, input, fileInfo, fileInfo.Name);
channel.Close();
}
}
/// <summary>
/// Downloads the specified file from the remote host to local file.
/// </summary>
/// <param name="filename">Remote host file name.</param>
/// <param name="fileInfo">Local file information.</param>
/// <exception cref="ArgumentNullException"><paramref name="fileInfo"/> or <paramref name="filename"/> is null.</exception>
public void Download(string filename, FileInfo fileInfo)
{
if (fileInfo == null)
throw new ArgumentNullException("fileInfo");
if (filename == null)
throw new ArgumentNullException("filename"); // TODO: Should add IsNullOrWhitespace for this filename parameter?
// UNDONE: EnsureConnection?
using (var input = new PipeStream())
using (var channel = this.Session.CreateChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, Common.ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
// Send channel command request
channel.SendExecRequest(string.Format("scp -qpf \"{0}\"", filename));
this.SendConfirmation(channel); // Send reply
this.InternalDownload(channel, input, fileInfo);
channel.Close();
}
}
public void Read()
{
const int sleepTime = 100;
var target = new PipeStream();
target.WriteByte(0x0a);
target.WriteByte(0x0d);
target.WriteByte(0x09);
var readBuffer = new byte[2];
var bytesRead = target.Read(readBuffer, 0, readBuffer.Length);
Assert.AreEqual(2, bytesRead);
Assert.AreEqual(0x0a, readBuffer[0]);
Assert.AreEqual(0x0d, readBuffer[1]);
var writeToStreamThread = new Thread(
() =>
{
Thread.Sleep(sleepTime);
var writeBuffer = new byte[] {0x05, 0x03};
target.Write(writeBuffer, 0, writeBuffer.Length);
});
writeToStreamThread.Start();
readBuffer = new byte[2];
bytesRead = target.Read(readBuffer, 0, readBuffer.Length);
Assert.AreEqual(2, bytesRead);
Assert.AreEqual(0x09, readBuffer[0]);
Assert.AreEqual(0x05, readBuffer[1]);
}
public void Test_PipeStream_Write_Read_Byte()
{
var testBuffer = new byte[1024];
new Random().NextBytes(testBuffer);
using (var stream = new PipeStream())
{
stream.Write(testBuffer, 0, testBuffer.Length);
Assert.AreEqual(stream.Length, testBuffer.Length);
stream.ReadByte();
Assert.AreEqual(stream.Length, testBuffer.Length - 1);
stream.ReadByte();
Assert.AreEqual(stream.Length, testBuffer.Length - 2);
}
}
public void Test_PipeStream_Write_Read_Buffer()
{
var testBuffer = new byte[1024];
new Random().NextBytes(testBuffer);
var outputBuffer = new byte[1024];
using (var stream = new PipeStream())
{
stream.Write(testBuffer, 0, testBuffer.Length);
Assert.AreEqual(stream.Length, testBuffer.Length);
stream.Read(outputBuffer, 0, outputBuffer.Length);
Assert.AreEqual(stream.Length, 0);
Assert.IsTrue(testBuffer.IsEqualTo(outputBuffer));
}
}
/// <summary>
/// Downloads the specified directory from the remote host to local directory.
/// </summary>
/// <param name="directoryName">Remote host directory name.</param>
/// <param name="directoryInfo">Local directory information.</param>
public void Download(string directoryName, DirectoryInfo directoryInfo)
{
using (var input = new PipeStream())
using (var channel = this.Session.CreateChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, Common.ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
// Send channel command request
channel.SendExecRequest(string.Format("scp -qprf {0}", directoryName));
this.SendConfirmation(channel); // Send reply
this.InternalDownload(channel, input, directoryInfo);
channel.Close();
}
}
/// <summary>
/// Uploads the specified file or directory to the remote host.
/// </summary>
/// <param name="fileInfo">Local file to upload.</param>
/// <param name="filename">Remote host file name.</param>
/// <exception cref="ArgumentNullException"><paramref name="fileInfo"/> or <paramref name="filename"/> is null.</exception>
public void Upload(FileSystemInfo fileSystemInfo, string path)
{
if (fileSystemInfo == null)
throw new ArgumentNullException("fileSystemInfo");
if (string.IsNullOrEmpty(path))
throw new ArgumentException("path");
using (var input = new PipeStream())
using (var channel = this.Session.CreateChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, Common.ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
var pathParts = path.Split('\\', '/');
// Send channel command request
channel.SendExecRequest(string.Format("scp -rt \"{0}\"", pathParts[0]));
this.CheckReturnCode(input);
// Prepare directory structure
for (int i = 0; i < pathParts.Length - 1; i++)
{
this.InternalSetTimestamp(channel, input, fileSystemInfo.LastWriteTimeUtc, fileSystemInfo.LastAccessTimeUtc);
this.SendData(channel, string.Format("D0755 0 {0}\n", pathParts[i]));
this.CheckReturnCode(input);
}
if (fileSystemInfo is FileInfo)
{
this.InternalUpload(channel, input, fileSystemInfo as FileInfo, pathParts.Last());
}
else if (fileSystemInfo is DirectoryInfo)
{
this.InternalUpload(channel, input, fileSystemInfo as DirectoryInfo, pathParts.Last());
}
else
{
throw new NotSupportedException(string.Format("Type '{0}' is not supported.", fileSystemInfo.GetType().FullName));
}
// Finish directory structure
for (int i = 0; i < pathParts.Length - 1; i++)
{
this.SendData(channel, "E\n");
this.CheckReturnCode(input);
}
channel.Close();
}
}
/// <summary>
/// Uploads the specified stream to the remote host.
/// </summary>
/// <param name="source">Stream to upload.</param>
/// <param name="filename">Remote host file name.</param>
public void Upload(Stream source, string path)
{
using (var input = new PipeStream())
using (var channel = this.Session.CreateChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, Common.ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
var pathParts = path.Split('\\', '/');
// Send channel command request
channel.SendExecRequest(string.Format("scp -rt \"{0}\"", pathParts[0]));
this.CheckReturnCode(input);
// Prepare directory structure
for (int i = 0; i < pathParts.Length - 1; i++)
{
this.InternalSetTimestamp(channel, input, DateTime.UtcNow, DateTime.UtcNow);
this.SendData(channel, string.Format("D0755 0 {0}\n", pathParts[i]));
this.CheckReturnCode(input);
}
this.InternalUpload(channel, input, source, pathParts.Last());
// Finish directory structure
for (int i = 0; i < pathParts.Length - 1; i++)
{
this.SendData(channel, "E\n");
this.CheckReturnCode(input);
}
channel.Close();
}
}
/// <summary>
/// Downloads the specified file from the remote host to the stream.
/// </summary>
/// <param name="filename">Remote host file name.</param>
/// <param name="destination">The stream where to download remote file.</param>
/// <exception cref="ArgumentException"><paramref name="filename"/> is null or contains whitespace characters.</exception>
/// <exception cref="ArgumentNullException"><paramref name="destination"/> is null.</exception>
/// <remarks>Method calls made by this method to <paramref name="destination"/>, may under certain conditions result in exceptions thrown by the stream.</remarks>
public void Download(string filename, Stream destination)
{
if (filename.IsNullOrWhiteSpace())
throw new ArgumentException("filename");
if (destination == null)
throw new ArgumentNullException("destination");
using (var input = new PipeStream())
using (var channel = this.Session.CreateChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, Common.ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
// Send channel command request
channel.SendExecRequest(string.Format("scp -f \"{0}\"", filename));
this.SendConfirmation(channel); // Send reply
var message = ReadString(input);
var match = _fileInfoRe.Match(message);
if (match.Success)
{
// Read file
this.SendConfirmation(channel); // Send reply
var mode = match.Result("${mode}");
var length = long.Parse(match.Result("${length}"));
var fileName = match.Result("${filename}");
this.InternalDownload(channel, input, destination, fileName, length);
}
else
{
this.SendConfirmation(channel, 1, string.Format("\"{0}\" is not valid protocol message.", message));
}
channel.Close();
}
}
/// <summary>
/// Uploads the specified stream to the remote host.
/// </summary>
/// <param name="source">Stream to upload.</param>
/// <param name="filename">Remote host file name.</param>
public void Upload(Stream source, string filename)
{
using (var input = new PipeStream())
using (var channel = this.Session.CreateChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, Common.ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
// Send channel command request
channel.SendExecRequest(string.Format("scp -qt \"{0}\"", filename));
this.CheckReturnCode(input);
this.InternalFileUpload(channel, input, source, filename);
channel.Close();
}
}
public void WriteTest()
{
PipeStream target = new PipeStream(); // TODO: Initialize to an appropriate value
byte[] buffer = null; // TODO: Initialize to an appropriate value
int offset = 0; // TODO: Initialize to an appropriate value
int count = 0; // TODO: Initialize to an appropriate value
target.Write(buffer, offset, count);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
/// <summary>
/// Uploads the specified stream to the remote host.
/// </summary>
/// <param name="source">Stream to upload.</param>
/// <param name="path">Remote host file name.</param>
public void Upload(Stream source, string path)
{
using (var input = new PipeStream())
using (var channel = this.Session.CreateClientChannel<ChannelSession>())
{
channel.DataReceived += delegate(object sender, ChannelDataEventArgs e)
{
input.Write(e.Data, 0, e.Data.Length);
input.Flush();
};
channel.Open();
int pathEnd = path.LastIndexOfAny(new[] { '\\', '/' });
if (pathEnd != -1)
{
// split the path from the file
string pathOnly = path.Substring(0, pathEnd);
string fileOnly = path.Substring(pathEnd + 1);
// Send channel command request
channel.SendExecRequest(string.Format("scp -t \"{0}\"", pathOnly));
this.CheckReturnCode(input);
path = fileOnly;
}
this.InternalUpload(channel, input, source, path);
channel.Close();
}
}
public void LengthTest()
{
var target = new PipeStream();
Assert.AreEqual(0L, target.Length);
target.Write(new byte[] { 0x0a, 0x05, 0x0d }, 0, 2);
Assert.AreEqual(2L, target.Length);
target.WriteByte(0x0a);
Assert.AreEqual(3L, target.Length);
target.Read(new byte[2], 0, 2);
Assert.AreEqual(1L, target.Length);
target.ReadByte();
Assert.AreEqual(0L, target.Length);
}
public void WriteTest()
{
var target = new PipeStream();
var writeBuffer = new byte[] {0x0a, 0x05, 0x0d};
target.Write(writeBuffer, 0, 2);
writeBuffer = new byte[] { 0x02, 0x04, 0x03, 0x06, 0x09 };
target.Write(writeBuffer, 1, 2);
var readBuffer = new byte[6];
var bytesRead = target.Read(readBuffer, 0, 4);
Assert.AreEqual(4, bytesRead);
Assert.AreEqual(0x0a, readBuffer[0]);
Assert.AreEqual(0x05, readBuffer[1]);
Assert.AreEqual(0x04, readBuffer[2]);
Assert.AreEqual(0x03, readBuffer[3]);
Assert.AreEqual(0x00, readBuffer[4]);
Assert.AreEqual(0x00, readBuffer[5]);
}
