protected override Task<HttpResponseMessage> CreateDirectoryGetResponse(DirectoryInfo info, string localFilePath)
{
HttpResponseMessage response = Request.CreateResponse();
using (var ms = new MemoryStream())
{
using (var zip = new ZipArchive(ms, ZipArchiveMode.Create, leaveOpen: true))
{
foreach (FileSystemInfo fileSysInfo in info.EnumerateFileSystemInfos())
{
DirectoryInfo directoryInfo = fileSysInfo as DirectoryInfo;
if (directoryInfo != null)
{
zip.AddDirectory(new DirectoryInfoWrapper(directoryInfo), fileSysInfo.Name);
}
else
{
// Add it at the root of the zip
zip.AddFile(fileSysInfo.FullName, String.Empty);
}
}
}
response.Content = ms.AsContent();
}
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
// Name the zip after the folder. e.g. "c:\foo\bar\" --> "bar"
response.Content.Headers.ContentDisposition.FileName = Path.GetFileName(Path.GetDirectoryName(localFilePath)) + ".zip";
return Task.FromResult(response);
}
protected override Task<HttpResponseMessage> CreateDirectoryGetResponse(DirectoryInfo info, string localFilePath)
{
HttpResponseMessage response = Request.CreateResponse();
using (var zip = new ZipFile())
{
foreach (FileSystemInfo fileSysInfo in info.EnumerateFileSystemInfos())
{
bool isDirectory = (fileSysInfo.Attributes & FileAttributes.Directory) != 0;
if (isDirectory)
{
zip.AddDirectory(fileSysInfo.FullName, fileSysInfo.Name);
}
else
{
// Add it at the root of the zip
zip.AddFile(fileSysInfo.FullName, "/");
}
}
using (var ms = new MemoryStream())
{
zip.Save(ms);
response.Content = ms.AsContent();
}
}
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
// Name the zip after the folder. e.g. "c:\foo\bar\" --> "bar"
response.Content.Headers.ContentDisposition.FileName = Path.GetFileName(Path.GetDirectoryName(localFilePath)) + ".zip";
return Task.FromResult(response);
}
public HttpResponseMessage GetDiagnostics()
{
lock (_lockObj)
{
var response = new HttpResponseMessage();
using (var zip = new ZipFile())
{
foreach (var path in _paths)
{
if (Directory.Exists(path))
{
zip.AddDirectory(path, Path.GetFileName(path));
}
}
var ms = new MemoryStream();
zip.Save(ms);
response.Content = ms.AsContent();
}
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
response.Content.Headers.ContentDisposition.FileName = String.Format("dump-{0:MM-dd-H:mm:ss}.zip", DateTime.UtcNow);
return response;
}
}
private HttpResponseMessage CreateResponse(MemoryStream stream, string mediaType)
{
_tracer.Trace("Writing {0} bytes", stream.Length);
HttpContent content = stream.AsContent();
content.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
// REVIEW: Why is it that we do not write an empty Content-Type here, like for InfoRefsController?
var response = new HttpResponseMessage();
response.Content = content;
response.WriteNoCache();
return response;
}
public HttpResponseMessage GetLog()
{
lock (_lockObj)
{
HttpResponseMessage response = Request.CreateResponse();
using (var stream = new MemoryStream())
{
using (var zip = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
AddFilesToZip(zip);
}
response.Content = stream.AsContent();
}
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
response.Content.Headers.ContentDisposition.FileName = String.Format("dump-{0:MM-dd-H:mm:ss}.zip", DateTime.UtcNow);
return response;
}
}
private HttpResponseMessage SmartInfoRefs(string service)
{
using (_tracer.Step("InfoRefsService.SmartInfoRefs"))
{
var memoryStream = new MemoryStream();
memoryStream.PktWrite("# service=git-{0}\n", service);
memoryStream.PktFlush();
if (service == "upload-pack")
{
//// Initialize the repository from the deployment files (if this is the first commit)
//ChangeSet changeSet = _gitServer.Initialize(_configuration, _webRootPath);
//_gitServer.AdvertiseUploadPack(memoryStream);
//// If we just created the repo, make a 'pseudo' deployment for the initial commit
//if (changeSet != null)
//{
// _deploymentManager.CreateExistingDeployment(changeSet.Id, _configuration.Username);
//}
_gitServer.Initialize();
_gitServer.AdvertiseUploadPack(memoryStream);
}
else if (service == "receive-pack")
{
_gitServer.Initialize();
_gitServer.AdvertiseReceivePack(memoryStream);
}
_tracer.Trace("Writing {0} bytes", memoryStream.Length);
HttpContent content = memoryStream.AsContent();
content.Headers.ContentType =
new MediaTypeHeaderValue("application/x-git-{0}-advertisement".With(service));
// Explicitly set the charset to empty string
// We do this as certain git clients (jgit) require it to be empty.
// If we don't set it, then it defaults to utf-8, which breaks jgit's logic for detecting smart http
content.Headers.ContentType.CharSet = "";
var responseMessage = new HttpResponseMessage();
responseMessage.Content = content;
responseMessage.WriteNoCache();
return responseMessage;
}
}
private HttpResponseMessage SmartInfoRefs(string service)
{
using (_tracer.Step("InfoRefsService.SmartInfoRefs"))
{
var memoryStream = new MemoryStream();
memoryStream.PktWrite("# service=git-{0}\n", service);
memoryStream.PktFlush();
if (service == "upload-pack")
{
// Initialize the repository from the deployment files (if this is the first commit)
_gitServer.Initialize(_configuration, _deploymentTargetPath);
_gitServer.AdvertiseUploadPack(memoryStream);
}
else if (service == "receive-pack")
{
_gitServer.Initialize(_configuration);
_gitServer.AdvertiseReceivePack(memoryStream);
}
if (memoryStream.Length < 100)
{
_tracer.TraceWarning("Unexpected number of bytes written. {0} bytes", memoryStream.Length);
}
else
{
_tracer.Trace("Writing {0} bytes", memoryStream.Length);
}
// TODO: Should we only do this in debug mode?
_tracer.Trace("Git stream", new Dictionary<string, string>
{
{ "type", "gitStream" },
{ "output", Encoding.UTF8.GetString(memoryStream.ToArray()) }
});
HttpContent content = memoryStream.AsContent();
content.Headers.ContentType =
new MediaTypeHeaderValue("application/x-git-{0}-advertisement".With(service));
// Explicitly set the charset to empty string
// We do this as certain git clients (jgit) require it to be empty.
// If we don't set it, then it defaults to utf-8, which breaks jgit's logic for detecting smart http
content.Headers.ContentType.CharSet = "";
var responseMessage = new HttpResponseMessage();
responseMessage.Content = content;
responseMessage.WriteNoCache();
return responseMessage;
}
}
private HttpResponseMessage CreateResponse(MemoryStream stream, string mediaType)
{
_tracer.Trace("Writing {0} bytes", stream.Length);
// TODO: Should we only do this in debug mode?
_tracer.Trace("Git stream", new Dictionary<string, string>
{
{ "type", "gitStream" },
{ "output", Encoding.UTF8.GetString(stream.ToArray()) }
});
HttpContent content = stream.AsContent();
content.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
// REVIEW: Why is it that we do not write an empty Content-Type here, like for InfoRefsController?
var response = new HttpResponseMessage();
response.Content = content;
response.WriteNoCache();
return response;
}
public HttpResponseMessage GetLog()
{
lock (_lockObj)
{
HttpResponseMessage response = Request.CreateResponse();
using (var zip = new ZipFile())
{
foreach (var path in _paths)
{
if (Directory.Exists(path))
{
if (path.EndsWith(Constants.LogFilesPath))
{
var dir = new DirectoryInfo(path);
foreach (var info in dir.GetFileSystemInfos())
{
if (info is DirectoryInfo)
{
// excluding FREB as it contains user sensitive data such as authorization header
if (!info.Name.StartsWith("W3SVC", StringComparison.OrdinalIgnoreCase))
{
zip.AddDirectory(info.FullName, Path.Combine(dir.Name, info.Name));
}
}
else
{
zip.AddFile(info.FullName, dir.Name);
}
}
}
else
{
zip.AddDirectory(path, Path.GetFileName(path));
}
}
else if (File.Exists(path))
{
zip.AddFile(path, String.Empty);
}
}
var ms = new MemoryStream();
zip.Save(ms);
response.Content = ms.AsContent();
}
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
response.Content.Headers.ContentDisposition.FileName = String.Format("dump-{0:MM-dd-H:mm:ss}.zip", DateTime.UtcNow);
return response;
}
}
private HttpResponseMessage SmartInfoRefs(string service)
{
using (_tracer.Step("InfoRefsService.SmartInfoRefs"))
{
using (var memoryStream = new MemoryStream())
{
memoryStream.PktWrite("# service=git-{0}\n", service);
memoryStream.PktFlush();
if (service == "upload-pack")
{
_gitServer.AdvertiseUploadPack(memoryStream);
}
else if (service == "receive-pack")
{
_gitServer.AdvertiseReceivePack(memoryStream);
}
_tracer.Trace("Writing {0} bytes", memoryStream.Length);
HttpContent content = memoryStream.AsContent();
content.Headers.ContentType =
new MediaTypeHeaderValue("application/x-git-{0}-advertisement".With(service));
// Explicitly set the charset to empty string
// We do this as certain git clients (jgit) require it to be empty.
// If we don't set it, then it defaults to utf-8, which breaks jgit's logic for detecting smart http
content.Headers.ContentType.CharSet = "";
var responseMessage = new HttpResponseMessage();
responseMessage.Content = content;
responseMessage.WriteNoCache();
return responseMessage;
}
}
}