protected static async Task BigFileAppendUploadDownLoad()
{
var temp = Enumerable.Repeat((byte)99, 1024 * 1024 * 100);
var testBytes = temp.ToArray();
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1", "default");
var filename = await FastDFSClient.UploadAppenderFileAsync(storageNode, testBytes.Take(1024 * 1024 * 2).ToArray(), "txt", "default");
for (int i = 0; i < 49; i++)
{
FDFSFileInfo fileInfo = await FastDFSClient.GetFileInfoAsync(storageNode, filename, "default");
var appendBytes = testBytes.Skip((int)fileInfo.FileSize).Take(1024 * 1024 * 2).ToArray();
await FastDFSClient.AppendFileAsync("group1", filename, appendBytes, "default");
}
using (var fileStream = File.OpenWrite("c:\\fastdfs_test.txt"))
{
for (int i = 0; i < 50; i++)
{
var buffer = await FastDFSClient.DownloadFileAsync(storageNode, filename, "default",
1024 * 1024 * 2 *i,
1024 * 1024 * 2);
fileStream.Write(buffer, 0, buffer.Length);
}
}
await FastDFSClient.RemoveFileAsync("group1", filename, "default");
temp = null;
testBytes = null;
}
/// <summary>
/// 存储文件
/// </summary>
/// <param name="objectStream">文件流</param>
/// <param name="objectName">对象名</param>
/// <returns>文件路径</returns>
public async Task <string> StoreObjectStreamAsync(Stream objectStream, string objectName)
{
StorageNode storageNode = FastDFSClient.GetStorageNodeAsync("group1").GetAwaiter().GetResult();
var filePath = await FastDFSClient.UploadFileAsync(storageNode, objectStream, Path.GetExtension(objectName));
return(StorageLink + storageNode.GroupName + "/" + filePath);
}
/// <summary>
/// 上传图片
/// </summary>
/// <param name="contentBytes">比特数组</param>
/// <param name="imageType">图片类型</param>
/// <returns>图片地址</returns>
public static async Task <string> FastDFSUploadFile(byte[] contentBytes, string imageType)
{
if (contentBytes == null || contentBytes.Length == 0)
{
throw new ArgumentNullException("contentBytes");
}
if (string.IsNullOrEmpty(imageType))
{
throw new ArgumentNullException("imageType");
}
var config = await GetFastDfsConfig();
EnsureConnectionInitialize(config);
var group = config.StorageGroup;
var storageNode = await FastDFSClient.GetStorageNodeAsync(group);
string paths = await FastDFSClient.UploadFileAsync(storageNode, contentBytes, imageType);
StringBuilder resultImageUrl = new StringBuilder();
var storageLink = config.StorageServerLink;
resultImageUrl.Append(storageLink);
resultImageUrl.Append(paths);
return(resultImageUrl.ToString());
}
/// <summary>
/// SyncTest
/// </summary>
/// <returns></returns>
private static void SyncTest()
{
StorageNode storageNode = FastDFSClient.GetStorageNodeAsync("group1", "server").GetAwaiter().GetResult();
string[] files = Directory.GetFiles("testimage", "*.jpg");
string[] strArrays = files;
for (int i = 0; i < strArrays.Length; i++)
{
string str1 = strArrays[i];
var fileStream = new FileStream(str1, FileMode.Open);
var binaryReader = new BinaryReader(fileStream);
byte[] numArray;
try
{
numArray = binaryReader.ReadBytes((int)fileStream.Length);
}
finally
{
binaryReader.Dispose();
}
var str = FastDFSClient.UploadFileAsync(storageNode, numArray, "jpg", "default").GetAwaiter().GetResult();
Console.WriteLine(StorageLink + str);
FastDFSClient.RemoveFileAsync("group1", str, "default").GetAwaiter().GetResult();;
Console.WriteLine("FastDFSClient.RemoveFile" + str);
}
}
private static async Task UploadAppendFile()
{
var testBytes = Encoding.UTF8.GetBytes("123456789");
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1", "server");
var filename = await FastDFSClient.UploadAppenderFileAsync(storageNode, testBytes.Take(6).ToArray(), "", "default");
FDFSFileInfo fileInfo = await FastDFSClient.GetFileInfoAsync(storageNode, filename, "default");
if (fileInfo == null)
{
Console.WriteLine($"GetFileInfoAsync Fail, path: {filename}");
return;
}
Console.WriteLine("FileName:{0}", filename);
Console.WriteLine("FileSize:{0}", fileInfo.FileSize);
Console.WriteLine("CreateTime:{0}", fileInfo.CreateTime);
Console.WriteLine("Crc32:{0}", fileInfo.Crc32);
var appendBytes = testBytes.Skip((int)fileInfo.FileSize).ToArray();
await FastDFSClient.AppendFileAsync("group1", filename, appendBytes, "default");
var test = await HttpClient.GetByteArrayAsync(StorageLink + filename);
if (Encoding.UTF8.GetString(test) == Encoding.UTF8.GetString(testBytes))
{
Console.WriteLine($"UploadAppendFile Success");
}
else
{
throw new ApplicationException($"UploadAppendFile Fail : Bytes Diff ");
}
await FastDFSClient.RemoveFileAsync("group1", filename, "default");
}
public async Task <string> UploadAsync(UploadFileModel model, CancellationToken token)
{
var storageNode = await FastDFSClient.GetStorageNodeAsync(model.GroupName);
token.ThrowIfCancellationRequested();
var fileId = await storageNode.UploadFileAsync(model.FileStream, model.Extension, token);
return(_option.FileUrlPrefix + '/' + storageNode.GroupName + '/' + fileId);
}
public async Task <IActionResult> GetFileAsync([FromRoute] string filename)
{
filename = HttpUtility.UrlDecode(filename);
//StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync(NodeGroup);
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync();
byte[] fileContent = await FastDFSClient.DownloadFileAsync(storageNode, filename);
return(File(fileContent, "application/octet-stream"));
}
private static void TestSlave()
{
StorageNode storageNode = FastDFSClient.GetStorageNodeAsync("group1").Result;
var str = "http://locahost/group1/M00/00/00/oYYBAFvcGZ2AGBAbAAAUa4KwmUU269.png";
var by = GetFileBytes("testimage/1.jpg");
var url = FastDFSClient.UploadSlaveFileAsync(storageNode, "M00/00/00/oYYBAFvcGZ2AGBAbAAAUa4KwmUU269.png",
"_10x10", by, "jpg", CancellationToken.None).GetAwaiter().GetResult();
Console.WriteLine(url);
}
public async Task <IActionResult> GetFileInfoAsync([FromRoute] string filename)
{
filename = HttpUtility.UrlDecode(filename);
//StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync(NodeGroup);
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync();
FDFSFileInfo fileInfo = await FastDFSClient.GetFileInfoAsync(storageNode, filename);
return(Ok(fileInfo));
}
public async Task <IActionResult> UploadFileAsync(/*[FromForm] IFormCollection formCollection*/ IFormFile file)
{
//IFormFile file = formCollection.Files["file"];
//IFormFile file = HttpContext.Request.Form.Files["file"];
//StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync(NodeGroup);
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync();
string filename = await FastDFSClient.UploadFileAsync(storageNode, file.OpenReadStream(), Path.GetExtension(file.FileName));
return(Ok(filename));
}
public static async Task <string> UpdateFile(Byte[] content, string fileExt = "jpg", string groupName = "group1")
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
var node = await FastDFSClient.GetStorageNodeAsync(groupName);
return(await FastDFSClient.UploadFileAsync(node, content, fileExt));
}
/// <summary>
/// UploadAsync2
/// </summary>
/// <param name="storageLink"></param>
/// <param name="fileBytes"></param>
/// <returns></returns>
private static async Task UploadAsync2(string storageLink, byte[] fileBytes)
{
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1", "default");
var str = await FastDFSClient.UploadFileAsync(storageNode, fileBytes, "jpg", "default");
Console.WriteLine(storageLink + str);
await FastDFSClient.RemoveFileAsync("group1", str, "default");
Console.WriteLine("FastDFSClient.RemoveFile" + str);
}
/// <summary>
/// UploadAsync2
/// </summary>
/// <param name="storageLink"></param>
/// <param name="fileBytes"></param>
/// <returns></returns>
private static async Task UploadAsync2(string storageLink, Stream stream)
{
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1");
var str = await FastDFSClient.UploadFileAsync(storageNode, stream, "jpg", CancellationToken.None);
Console.WriteLine(storageLink + str);
stream.Dispose();
await FastDFSClient.RemoveFileAsync("group1", str, CancellationToken.None);
Console.WriteLine("FastDFSClient.RemoveFile" + str);
}
protected static async Task BigFileUploadDownLoad()
{
var temp = Enumerable.Repeat((byte)99, 1024 * 1024 * 100);
var testBytes = temp.ToArray();
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1", "default");
var filename = await FastDFSClient.UploadFileAsync(storageNode, testBytes, "txt", "default");
using (var fileStream = File.OpenWrite("c:\\fastdfs_test.txt"))
{
await FastDFSClient.DownloadFileAsync(storageNode, filename, new StreamDownloadCallback(fileStream), "default");
}
await FastDFSClient.RemoveFileAsync("group1", filename, "default");
temp = null;
testBytes = null;
}
/// <summary>
/// UploadAsync
/// </summary>
/// <param name="storageLink"></param>
/// <returns></returns>
private static async Task UploadAsync(string storageLink)
{
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1", "server");
string[] files = Directory.GetFiles("testimage", "*.jpg");
string[] strArrays = files;
for (int i = 0; i < strArrays.Length; i++)
{
string str1 = strArrays[i];
var numArray = GetFileBytes(str1);
var str = await FastDFSClient.UploadFileAsync(storageNode, numArray, "jpg", "default");
Console.WriteLine(storageLink + str);
await FastDFSClient.RemoveFileAsync("group1", str, "default");
Console.WriteLine("FastDFSClient.RemoveFile" + str);
}
}
private static async Task <(string GroupName, string filename)> UploadAppenderFileAsync()
{
Console.WriteLine("UploadAppenderFile");
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync();
Console.WriteLine($"{nameof(storageNode.EndPoint)}: {storageNode.EndPoint}");
Console.WriteLine($"{nameof(storageNode.GroupName)}: {storageNode.GroupName}");
Console.WriteLine($"{nameof(storageNode.StorePathIndex)}: {storageNode.StorePathIndex}");
byte[] data = Encoding.UTF8.GetBytes(DateTime.Now.ToString());
string filename = await FastDFSClient.UploadAppenderFileAsync(storageNode, data, ".txt");
Console.WriteLine($"{filename}\n");
await GetFileInfoAsync(storageNode, filename);
return(storageNode.GroupName, filename);
}
public static async Task <string> UpdateFile(Stream fileStream, string fileExt = "jpg", string groupName = "group1")
{
if (fileStream == null)
{
throw new ArgumentNullException(nameof(fileStream));
}
byte[] content = new byte[fileStream.Length];
using (BinaryReader reader = new BinaryReader(fileStream))
{
content = reader.ReadBytes((int)fileStream.Length);
}
var node = await FastDFSClient.GetStorageNodeAsync(groupName);
return(await FastDFSClient.UploadFileAsync(node, content, fileExt));
}
/// <summary>
/// SyncTest
/// </summary>
/// <returns></returns>
private static void SyncTest()
{
StorageNode storageNode = FastDFSClient.GetStorageNodeAsync("group1").GetAwaiter().GetResult();
string[] files = Directory.GetFiles("testimage", "*.jpg");
string[] strArrays = files;
for (int i = 0; i < strArrays.Length; i++)
{
string str1 = strArrays[i];
var fileStream = new FileStream(str1, FileMode.Open, FileAccess.Read);
var str = FastDFSClient.UploadFileAsync(storageNode, fileStream, "jpg", CancellationToken.None
).GetAwaiter().GetResult();
fileStream.Dispose();
Console.WriteLine(StorageLink + str);
FastDFSClient.RemoveFileAsync("group1", str, CancellationToken.None).GetAwaiter().GetResult();;
Console.WriteLine("FastDFSClient.RemoveFile" + str);
}
}
/// <summary>
/// TestGetFileInfo
/// </summary>
private static async Task TestGetFileInfo()
{
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1");
var str = "http://locahost/group1/M00/00/00/oYYBAFvcGZ2AGBAbAAAUa4KwmUU269.png";
var fileInfo = await FastDFSClient.GetFileInfoAsync(str);
if (fileInfo == null)
{
Console.WriteLine("Not Exist");
return;
}
Console.WriteLine("FileName:{0}", str);
Console.WriteLine("FileSize:{0}", fileInfo.FileSize);
Console.WriteLine("CreateTime:{0}", fileInfo.CreateTime);
Console.WriteLine("Crc32:{0}", fileInfo.Crc32);
Console.WriteLine("Complete");
}
/// <summary>
/// TestGetFileInfo
/// </summary>
private static async Task TestGetFileInfo()
{
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1");
var str = "M00/0E/82/CgE-EFsTqKmAEHO7AADMG7XS9Fc7491.jpg";
FDFSFileInfo fileInfo = await FastDFSClient.GetFileInfoAsync(storageNode, str);
if (fileInfo == null)
{
Console.WriteLine("Not Exist");
return;
}
Console.WriteLine("FileName:{0}", str);
Console.WriteLine("FileSize:{0}", fileInfo.FileSize);
Console.WriteLine("CreateTime:{0}", fileInfo.CreateTime);
Console.WriteLine("Crc32:{0}", fileInfo.Crc32);
Console.WriteLine("Complete");
}
public async Task GetStorageNodeAsync_Test()
{
var mockExecuter = new Mock <IExecuter>();
var mockClusterFactory = new Mock <IClusterFactory>();
mockExecuter.Setup(x => x.Execute(It.IsAny <FastDFSReq <QueryStoreWithGroupResp> >(), It.IsAny <string>(), It.IsAny <ConnectionAddress>())).ReturnsAsync(new QueryStoreWithGroupResp()
{
GroupName = "group2",
IPAddress = "192.168.0.2",
Port = 23000,
StorePathIndex = 0
});
IFastDFSClient client = new FastDFSClient(mockExecuter.Object, mockClusterFactory.Object);
var node = await client.GetStorageNodeAsync("group1");
Assert.Equal("group2", node.GroupName);
Assert.Equal(new ConnectionAddress("192.168.0.2", 23000), node.ConnectionAddress);
mockExecuter.Verify(x => x.Execute(It.IsAny <FastDFSReq <QueryStoreWithGroupResp> >(), It.IsAny <string>(), It.IsAny <ConnectionAddress>()), Times.Once);
}
/// <summary>
/// UploadAsync
/// </summary>
/// <param name="storageLink"></param>
/// <returns></returns>
private static async Task UploadAsync(string storageLink)
{
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync(group);
string[] files = Directory.GetFiles(@"C:\Users\Administrator.DESKTOP-LOM86CH\Desktop\images");
string[] strArrays = files;
for (int i = 0; i < strArrays.Length; i++)
{
string str1 = strArrays[i];
var numArray = GetFileBytes(str1);
//务必保存此文件路径
var str = await FastDFSClient.UploadFileAsync(storageNode, numArray, "jpg");
Console.WriteLine(storageLink + str);
await FastDFSClient.RemoveFileAsync(group, str);
Console.WriteLine("FastDFSClient.RemoveFile" + str);
}
}
private static async Task DownLoadFile()
{
var testBytes = Encoding.UTF8.GetBytes("12345678911118888888888888888881111111111");
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync("group1", "default");
var filename = await FastDFSClient.UploadFileAsync(storageNode, testBytes, "txt", "default");
var bytes = await FastDFSClient.DownloadFileAsync(storageNode, filename, "default");
if (bytes == null)
{
Console.WriteLine($"DownLoadFile Fail : Bytes null ");
}
if (Encoding.UTF8.GetString(bytes) == Encoding.UTF8.GetString(testBytes))
{
Console.WriteLine($"DownLoadFile Success");
}
else
{
throw new ApplicationException("DownLoadFile Fail : Bytes Diff");
}
}
public static async Task <string> UploadAsync(byte[] fileBytes, string fileExt)
{
List <IPEndPoint> pEndPoints = new List <IPEndPoint>()
{
new IPEndPoint(IPAddress.Parse(ip), Convert.ToInt32(prot))
};
ConnectionManager.Initialize(pEndPoints);
StorageNode storageNode = await FastDFSClient.GetStorageNodeAsync(groupName);
string str = "";
try
{
str = domainName + '/' + groupName + '/' + await FastDFSClient.UploadFileAsync(storageNode, fileBytes, fileExt);
}catch (Exception e)
{
//失败则两秒后重试
await Task.Delay(2000);
try
{
str = domainName + '/' + groupName + '/' + await FastDFSClient.UploadFileAsync(storageNode, fileBytes, fileExt);
}
catch (Exception ex)
{
//失败则两秒后重试
await Task.Delay(2000);
str = domainName + '/' + groupName + '/' + await FastDFSClient.UploadFileAsync(storageNode, fileBytes, fileExt);
}
}
return(str);
}
/// <summary>
/// 上传图片
/// </summary>
/// <param name="contentBytes">比特数组</param>
/// <param name="imageType">图片类型</param>
/// <returns>图片地址</returns>
public static async Task <string> FastDFSUploadFile(Stream stream, string imageType)
{
if (string.IsNullOrEmpty(imageType))
{
throw new ArgumentNullException("imageType");
}
var config = await GetFastDfsConfig();
EnsureConnectionInitialize(config);
var group = config.StorageGroup;
var storageNode = await FastDFSClient.GetStorageNodeAsync(group);
string paths = await FastDFSClient.UploadFileAsync(storageNode, stream, imageType, CancellationToken.None);
StringBuilder resultImageUrl = new StringBuilder();
var storageLink = config.StorageServerLink;
resultImageUrl.Append(storageLink);
resultImageUrl.Append(paths);
return(resultImageUrl.ToString());
}
