private async Task <List <StorageNode> > GetNodesAsync(string root) { var paths = await _dbContext.StorageItems.Where(s => s.Path.StartsWith(root)).Select(s => s.Path) .Distinct().ToArrayAsync(); var rootNode = new StorageNode(root, root); foreach (var item in paths.OrderBy(s => s)) { var parts = item.Split('/').Where(p => !string.IsNullOrEmpty(p)).ToArray(); var currentRootNode = rootNode; foreach (var part in parts) { if (part == parts.Last()) { currentRootNode.Items.Add(new StorageNode(part, item)); } else { var node = currentRootNode.Items.FirstOrDefault(i => i.Name == part); if (node == null) { node = new StorageNode(part, Path.Combine(currentRootNode.Path, part).Replace("\\", "/")); currentRootNode.Items.Add(node); } currentRootNode = node; } } } return(rootNode.Items); }
public StorageNode(StorageNode node, string root = "/") { Name = node.Name; IsDirectory = node.IsDirectory; Item = node.Item; Path = node.Path.Replace(root, "").Trim('/'); }
/// <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); }
internal override void SetStorageNode(StorageNode node) { if (!connectionIsExternal) { driver.ApplyNodeConfiguration(connection, node.Configuration); } }
public ResourceReservation MakeReservation(StorageNode reserver, Resource resource) { ResourceReservation newReservation = new ResourceReservation(Take(resource), this); reservations.Add(newReservation); return(newReservation); }
public void Start() { state = ShipState.Idle; currentSystem = FindObjectOfType <Star>(); //TODO: when additional starsystems are implemented this will not work. _rb = GetComponent <Rigidbody2D>(); _steeringBasics = GetComponent <SteeringBasics>(); cargoHold = GetComponentInChildren <StorageNode>(); _infoPanel = GameObject.FindGameObjectWithTag("Infopanel"); employmentData = GetComponent <Employee>(); // Update components based on JSON input _steeringBasics.maxVelocity = maxSpeed; _rb.mass = mass; _steeringBasics.maxAcceleration = maxAcceleration; _steeringBasics.turnSpeed = maneuverability; cargoHold.maxUnits = cargoCapacity; GetComponent <SpriteRenderer>().sprite = FindObjectOfType <AssetLoader>().shipSprites[spriteName]; // TODO: clean up this abomination. Maybe have a spriteassigner class of some sort? // Change the size of the box collider based on the sprite. Vector2 spriteSize = GetComponent <SpriteRenderer>().sprite.bounds.size; BoxCollider2D collider = gameObject.GetComponent <BoxCollider2D>(); collider.size = spriteSize; collider.offset = Vector2.zero; }
/// <summary> /// 获取文件信息 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileId">文件名</param> /// <param name="clusterName">集群名称</param> /// <returns></returns> public async ValueTask <FastDFSFileInfo> GetFileInfo(StorageNode storageNode, string fileId, string clusterName = "") { var request = new QueryFileInfo(storageNode.GroupName, fileId); var response = await _executer.Execute(request, clusterName, storageNode.ConnectionAddress); return(new FastDFSFileInfo(response.FileSize, response.CreateTime, response.Crc32)); }
/// <summary> /// 获取文件媒体信息 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileId">文件名</param> /// <param name="clusterName">集群名称</param> /// <returns></returns> public async ValueTask <IDictionary <string, string> > GetMetaData(StorageNode storageNode, string fileId, string clusterName = "") { var request = new GetMetaData(storageNode.GroupName, fileId); var response = await _executer.Execute(request, clusterName, storageNode.ConnectionAddress); return(response.MetaData); }
/// <summary> /// 增量下载文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileId">文件名</param> /// <param name="offset">从文件起始点的偏移量</param> /// <param name="length">要读取的字节数</param> /// <param name="clusterName">集群名称</param> /// <returns>文件内容</returns> public async ValueTask <byte[]> DownloadFileAsync(StorageNode storageNode, string fileId, long offset, long length, string clusterName = "") { var request = new DownloadFile(offset, length, storageNode.GroupName, fileId); var response = await _executer.Execute(request, clusterName, storageNode.ConnectionAddress); return(response.Content); }
/// <summary> /// 下载文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileId">文件名</param> /// <returns>文件内容</returns> public async Task <byte[]> DownloadFileAsync(StorageNode storageNode, string fileId) { var request = new DownloadFile(0L, 0L, storageNode.GroupName, fileId); var response = await _executer.Execute(request, storageNode.ConnectionAddress); return(response.Content); }
/// <summary> /// 上传文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="contentByte">文件内容</param> /// <param name="fileExt">文件扩展名(注意:不包含".")</param> /// <returns>文件名</returns> public static string UploadFile(StorageNode storageNode, byte[] contentByte, string fileExt) { FDFSRequest storageRequest = UPLOAD_FILE.Instance.GetRequest(storageNode.EndPoint, storageNode.StorePathIndex, contentByte.Length, fileExt, contentByte); UPLOAD_FILE.Response storageResponse = new UPLOAD_FILE.Response(); storageRequest.GetResponse(storageResponse); return storageResponse.FileName; }
public override int Run(string[] remainingArguments) { string file_id = remainingArguments [0]; if (_dryrun) { Console.WriteLine("fdfsclient download {0} --output {1} {2}", OptionsToString(), _destFileName, file_id); return(0); } ConnectionManager.Initialize(_trackers); string groupName = null; string fileName = null; SplitGroupNameAndFileName(file_id, out groupName, out fileName); StorageNode[] nodes = FastDFSClient.QueryStorageNodesForFile(groupName, fileName); if (nodes == null) { throw new FDFSException(string.Format("Group {0} not found.", groupName)); } StorageNode node = SelectStorageNode(nodes, fileName, _timeout); if (node == null) { throw new FDFSException("node not available"); } DoDownload(node, fileName, _destFileName); return(0); }
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"); }
/// <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); } }
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> /// 注意静态构造函数不允许有访问修饰符 /// 默认都是Public的? /// /// </summary> static MyFastDFSClient() { List <IPEndPoint> trackerIPs = new List <IPEndPoint>(); //从配置文件中读取Common/Config/Fdfs/TrackerSection相关对象中对应的配置 #region 从配置文件中读取Common/Config/Fdfs/TrackerSection相关对象中对应的配置 //TrackerSection trackersSection = ConfigurationManager.GetSection("TrackerSection") as TrackerSection; //foreach (MyTracker item in trackersSection.Trackers) //{ // trackerIPs.Add(new IPEndPoint(IPAddress.Parse(item.Host), item.Port)); //} #endregion /* * 读取fastdfs配置节下的配置文件 * 以FastDFS.Client.Config 中FastDFSConfig 对象的方式读取出来 */ var config = FastDfsManager.GetConfigSection(); try { //根据指定群组名称获取存储节点 DefaultGroup = GetStorageNode(config.GroupName); foreach (var item in config.FastDfsServer) { trackerIPs.Add(new IPEndPoint(IPAddress.Parse(item.IpAddress), item.Port)); } //初始化 ConnectionManager.Initialize(trackerIPs); } catch (Exception ex) { //Logger.LoggerFactory.Instance.Logger_Error(ex); } }
protected override async Task <IEnumerable <StorageNode> > DoGetDirectoryContentsAsync(string path, CancellationToken?cancellationToken = null) { await using var dbContext = GetDbContext(); if (path.StartsWith("/")) { path = path.Substring(1); } var records = await dbContext.Records .Where(r => r.Storage == StorageOptions.Name && r.Path.StartsWith(path)) .ToListAsync(cancellationToken ?? CancellationToken.None); var root = StorageNode.CreateDirectory("/", "/"); foreach (var itemRecord in records) { var item = new StorageItem( itemRecord.FilePath, itemRecord.LastModified, itemRecord.FileSize, null, itemRecord.Metadata); root.AddItem(item); } var parts = PreparePath(path.Trim('/')) !.Split("/"); var current = root; foreach (var part in parts) { current = current?.Children.Where(n => n.Type == StorageNodeType.Directory) .FirstOrDefault(f => f.Name == part); } return(current?.Children ?? new StorageNode[0]); }
public void RemoveStorage(GameObject go) { StorageNode storage = FindStorageNodeFromPosition(go.transform.position); OnStorageDemolishListeners(storage); storageNodeList.Remove(storage); }
/// <summary> /// Roll back the versions of the last changed tiles /// </summary> public void Undo() { // for multi-undo, we could store prev. changed tiles set in the metadata store, or stack up change sets in ram. var changed = _lastChangedTiles.ToArray(); var changesMade = false; foreach (var tile in changed) { // if tiles exist for version-1: // - roll the version back in meta // - reload tile (purge from cache and flip the reload trigger) var path = tile.ToString(); var node = _tileStore.Exists(path); if (node.IsFailure) { continue; } if (node.ResultData == null) { continue; } var prevVersion = node.ResultData.CurrentVersion - 1; if (prevVersion < 1) { // undoing the first stroke. Mark it deleted. var deadNode = new StorageNode { CurrentVersion = node.ResultData.CurrentVersion, Id = node.ResultData.Id, IsDeleted = true }; _tileStore.UpdateNode(path, deadNode); changesMade = true; } else { var ok = _tileStore.Read(path, "img", prevVersion); if (ok.IsFailure) { continue; } var newNode = new StorageNode { CurrentVersion = prevVersion, Id = node.ResultData.Id, IsDeleted = false }; _tileStore.UpdateNode(path, newNode); changesMade = true; } } if (changesMade) { ResetCache(); } // Reset the last update set // For multi-undo, we should roll back to a previous undo set. _lastChangedTiles.Clear(); }
/// <summary> /// 上传可以Append的文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="contentByte">文件内容</param> /// <param name="fileExt">文件扩展名(注意:不包含".")</param> /// <returns>文件名</returns> public static string UploadAppenderFile(StorageNode storageNode, byte[] contentByte, string fileExt) { var storageReqeust = UPLOAD_APPEND_FILE.Instance.GetRequest(storageNode.EndPoint, storageNode.StorePathIndex, contentByte.Length, fileExt, contentByte); var storageResponse = new UPLOAD_APPEND_FILE.Response(storageReqeust.GetResponse()); return(storageResponse.FileName); }
/// <summary> /// 上传可以Append的文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="content">文件内容</param> /// <param name="fileExt">文件扩展名(注意:不包含".")</param> /// <param name="clusterName">集群名称</param> /// <returns>文件名</returns> public async ValueTask <string> UploadAppenderFileAsync(StorageNode storageNode, byte[] content, string fileExt, string clusterName = "") { fileExt = fileExt.TrimStart('.'); var request = new UploadAppendFile(storageNode.StorePathIndex, fileExt, content); var response = await _executer.Execute(request, clusterName, storageNode.ConnectionAddress); return(response.FileId); }
/// <summary> /// 上传文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="stream">文件流</param> /// <param name="fileExt">文件扩展名(注意:不包含".")</param> /// <returns>文件名</returns> public async Task <string> UploadFileAsync(StorageNode storageNode, Stream stream, string fileExt) { fileExt = fileExt.TrimStart('.'); var request = new UploadFile(storageNode.StorePathIndex, fileExt, stream); var response = await _executer.Execute(request, storageNode.ConnectionAddress); return(response.FileId); }
protected override bool InternalIsExist(StorageNode path) { if (path.IsFile) { return(File.Exists(path.AbosolutePath)); } return(Directory.Exists(path.AbosolutePath)); }
/// <summary> /// 增量下载文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileName">文件名</param> /// <param name="offset">从文件起始点的偏移量</param> /// <param name="length">要读取的字节数</param> /// <returns>文件内容</returns> public static byte[] DownloadFile(StorageNode storageNode, string fileName, long offset, long length) { var storageReqeust = DOWNLOAD_FILE.Instance.GetRequest(storageNode.EndPoint, offset, length, storageNode.GroupName, fileName); var storageResponse = new DOWNLOAD_FILE.Response(storageReqeust.GetResponse()); return(storageResponse.Content); }
/// <summary> /// 获取文件信息 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileName">文件名</param> /// <returns></returns> public static FDFSFileInfo GetFileInfo(StorageNode storageNode, string fileName) { var storageReqeust = QUERY_FILE_INFO.Instance.GetRequest(storageNode.EndPoint, storageNode.GroupName, fileName); var result = new FDFSFileInfo(storageReqeust.GetResponse()); return(result); }
/// <summary> /// 获取存储节点 /// </summary> /// <param name="groupName">组名</param> /// <param name="clusterName">集群名称</param> /// <returns>存储节点实体类</returns> public async ValueTask <StorageNode> GetStorageNodeAsync(string groupName, string clusterName = "") { var request = new QueryStoreWithGroupOne(groupName); var response = await _executer.Execute(request, clusterName); var storageNode = new StorageNode(response.GroupName, response.IPAddress, response.Port, response.StorePathIndex); return(storageNode); }
/// <summary> /// 增量下载文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileName">文件名</param> /// <param name="offset">从文件起始点的偏移量</param> /// <param name="length">要读取的字节数</param> /// <returns>文件内容</returns> public byte[] DownloadFile(StorageNode storageNode, string fileName, long offset, long length) { var storageRequest = Storage.DownloadFile.Instance.GetRequest(storageNode.EndPoint, offset, length, storageNode.GroupName, fileName); var storageResponse = new DownloadFile.Response(storageRequest.GetResponse()); return storageResponse.Content; }
/// <summary> /// 上传可以Append的文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="filename">本地文件名</param> /// <param name="clusterName">集群名称</param> /// <returns>文件名</returns> public async ValueTask <string> UploadAppenderFileAsync(StorageNode storageNode, string filename, string clusterName = "") { string extension = Path.GetExtension(filename).TrimStart('.'); var fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read); var request = new UploadAppendFile(storageNode.StorePathIndex, extension, fs); var response = await _executer.Execute(request, clusterName, storageNode.ConnectionAddress); return(response.FileId); }
/// <summary> /// 查询文件存储的节点 /// </summary> /// <param name="groupName">组名</param> /// <param name="fileId">文件名</param> /// <param name="clusterName">集群名称</param> /// <returns>存储节点实体类</returns> public async ValueTask <StorageNode> QueryStorageNodeForFileAsync(string groupName, string fileId, string clusterName = "") { var request = new QueryFetchOne(groupName, fileId); var response = await _executer.Execute(request, clusterName); var storageNode = new StorageNode(response.GroupName, response.IPAddress, response.Port, 0); return(storageNode); }
/// <summary> /// 上传文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="contentByte">文件内容</param> /// <param name="fileExt">文件扩展名(注意:不包含".")</param> /// <returns>文件名</returns> public string UploadFile(StorageNode storageNode, byte[] contentByte, string fileExt) { var storageReqeust = Storage.UploadFile.Instance.GetRequest(storageNode.EndPoint, storageNode.StorePathIndex, contentByte.Length, fileExt, contentByte); var storageResponse = new UploadFile.Response(storageReqeust.GetResponse()); return(storageResponse.FileName); }
/// <summary> /// 获取文件信息 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileName">文件名</param> /// <returns></returns> public FdfsFileInfo GetFileInfo(StorageNode storageNode, string fileName) { var storageReqeust = QueryFileInfo.Instance.GetRequest(storageNode.EndPoint, storageNode.GroupName, fileName); var result = new FdfsFileInfo(storageReqeust.GetResponse()); return(result); }
public static string UploadFileByName(StorageNode storageNode, string filename) { using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read)) { string extension = Path.GetExtension(filename).Substring(1); FDFSRequest storageRequest = UPLOAD_FILE.Instance.GetRequest(storageNode.EndPoint, storageNode.StorePathIndex, fs.Length, extension, fs); UPLOAD_FILE.Response storageResponse = new UPLOAD_FILE.Response(); storageRequest.GetResponse(storageResponse); return storageResponse.FileName; } }
/// <summary> /// 获取存储节点 /// </summary> /// <param name="groupName">组名</param> /// <returns>存储节点实体类</returns> /// 07-09 更改代码以支持不再需要传入groupName来做存储 public static StorageNode GetStorageNode(string groupName = null) { FDFSRequest trackerRequest = string.IsNullOrEmpty(groupName) ? QUERY_STORE_WITH_GROUP_ONE.Instance.GetRequest() : QUERY_STORE_WITH_GROUP_ONE.Instance.GetRequest(groupName); QUERY_STORE_WITH_GROUP_ONE.Response trackerResponse = new QUERY_STORE_WITH_GROUP_ONE.Response(); trackerRequest.GetResponse(trackerResponse); IPEndPoint storeEndPoint = new IPEndPoint(IPAddress.Parse(trackerResponse.IPStr), trackerResponse.Port); StorageNode result = new StorageNode(); result.GroupName = trackerResponse.GroupName; result.EndPoint = storeEndPoint; result.StorePathIndex = trackerResponse.StorePathIndex; return result; }
protected static bool FileExistsOnStorageNode(StorageNode node, string fileName) { try { FastDFSClient.GetFileInfo(node, fileName); return true; } catch (Exception) { return false; } }
public static StorageNode QueryStorageNodeForFile(string groupName, string fileid) { FDFSRequest trackerRequest = QUERY_FETCH_ONE.Instance.GetRequest(groupName, fileid); QUERY_FETCH_ONE.Response trackerResponse = new QUERY_FETCH_ONE.Response(); trackerRequest.GetResponse(trackerResponse); IPEndPoint storeEndPoint = new IPEndPoint(IPAddress.Parse(trackerResponse.IPStr), trackerResponse.Port); StorageNode result = new StorageNode(); result.GroupName = trackerResponse.GroupName; result.EndPoint = storeEndPoint; result.StorePathIndex = 0; return result; }
protected static bool WaitForFileExists(StorageNode node, string fileName, TimeSpan timeSpan) { DateTime begin = DateTime.Now; bool fileExists = false; TimeSpan sleepTime = TimeSpan.FromSeconds(5); do { fileExists = FileExistsOnStorageNode(node, fileName); if (fileExists) return true; Thread.Sleep(sleepTime); } while (!fileExists && DateTime.Now - begin < timeSpan); return false; }
public static StorageNode[] QueryStorageNodesForFile(string groupName, string fileid) { FDFSRequest trackerRequest = QUERY_FETCH_ALL.Instance.GetRequest(groupName, fileid); QUERY_FETCH_ALL.Response trackerResponse = new QUERY_FETCH_ALL.Response(); trackerRequest.GetResponse(trackerResponse); List<StorageNode> storageNodes = new List<StorageNode>(); foreach (string IPStr in trackerResponse.IPStrs) { StorageNode storage = new StorageNode(); storage.GroupName = trackerResponse.GroupName; storage.EndPoint = new IPEndPoint(IPAddress.Parse(IPStr), trackerResponse.Port); storage.StorePathIndex = 0; storageNodes.Add(storage); } return storageNodes.ToArray(); }
StorageNode SelectStorageNode(StorageNode[] nodes, string fileName, int timeoutSecs) { foreach (StorageNode node in nodes) { if (WaitForFileExists(node, fileName, TimeSpan.FromSeconds(timeoutSecs))) return node; } return null; }
void DoDownload(StorageNode node, string fileId, string destFileName) { //get metadata IDictionary<string, string> metaData = FastDFSClient.GetMetaData(node, fileId); //download file string destDir = Environment.CurrentDirectory; string destName = metaData["filename"] + Path.GetExtension(fileId); if (!string.IsNullOrEmpty(destFileName)) { string dir = Path.GetDirectoryName(destFileName); if (!string.IsNullOrEmpty(dir)) destDir = dir; destName = Path.GetFileName(destFileName); } string fullName = FastDFSClient.DownloadFileEx(node, fileId, destDir, destName); Console.WriteLine("{0}", fullName); }
string DoUpload(StorageNode node, string fileName) { // upload file string id = FastDFSClient.UploadFileByName(node, fileName); // set name as metadata Dictionary<string, string> metaData = new Dictionary<string, string>(); metaData["filename"] = Path.GetFileNameWithoutExtension(fileName); FastDFSClient.SetMetaData(node, id, metaData); return string.Format("{0}/{1}", node.GroupName, id); }
/// <summary> /// 增量下载文件 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileName">文件名</param> /// <param name="offset">从文件起始点的偏移量</param> /// <param name="length">要读取的字节数</param> /// <returns>文件内容</returns> public static byte[] DownloadFile(StorageNode storageNode, string fileName, long offset, long length) { FDFSRequest storageRequest = DOWNLOAD_FILE.Instance.GetRequest(storageNode.EndPoint, offset, length, storageNode.GroupName, fileName); DOWNLOAD_FILE.Response storageResponse = new DOWNLOAD_FILE.Response(); storageRequest.GetResponse(storageResponse); return storageResponse.Content; }
public static string DownloadFileEx(StorageNode storageNode, string filename, string destDir, string destFileName = null) { string fullPath = null; if (destFileName == null) { IDictionary<string, string> metaData = GetMetaData(storageNode, filename); destFileName = metaData["Name"] + Path.GetExtension(filename); } fullPath = Path.Combine(destDir, destFileName); FDFSRequest storageRequest = DOWNLOAD_FILE.Instance.GetRequest(storageNode.EndPoint, 0L, 0L, storageNode.GroupName, filename); DOWNLOAD_FILE.ResponseEx storageResponse = new DOWNLOAD_FILE.ResponseEx(fullPath); storageRequest.GetResponse(storageResponse); return storageResponse.FullPath; }
/// <summary> /// 获取文件信息 /// </summary> /// <param name="storageNode">GetStorageNode方法返回的存储节点</param> /// <param name="fileName">文件名</param> /// <returns></returns> public static FDFSFileInfo GetFileInfo(StorageNode storageNode, string fileName) { FDFSRequest storageRequest = QUERY_FILE_INFO.Instance.GetRequest(storageNode.EndPoint, storageNode.GroupName, fileName); FDFSFileInfo result = new FDFSFileInfo(); storageRequest.GetResponse(result); return result; }
public static void SetMetaData(StorageNode storageNode, string fileName, IDictionary<string, string> metadata, MetaDataOption option = MetaDataOption.Overwrite) { FDFSRequest storageRequest = SET_METADATA.Instance.GetRequest(storageNode.EndPoint, storageNode.GroupName, fileName, metadata, option); storageRequest.GetResponse(); // no response body }
public static IDictionary<string, string> GetMetaData(StorageNode storageNode, string fileName) { FDFSRequest storageRequest = GET_METADATA.Instance.GetRequest(storageNode.EndPoint, storageNode.GroupName, fileName); GET_METADATA.Response storageResponse = new GET_METADATA.Response(); storageRequest.GetResponse(storageResponse); return storageResponse.MetaData; }