コード例 #1
0
        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);
        }
コード例 #2
0
 public StorageNode(StorageNode node, string root = "/")
 {
     Name        = node.Name;
     IsDirectory = node.IsDirectory;
     Item        = node.Item;
     Path        = node.Path.Replace(root, "").Trim('/');
 }
コード例 #3
0
        /// <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);
        }
コード例 #4
0
 internal override void SetStorageNode(StorageNode node)
 {
     if (!connectionIsExternal)
     {
         driver.ApplyNodeConfiguration(connection, node.Configuration);
     }
 }
コード例 #5
0
    public ResourceReservation MakeReservation(StorageNode reserver, Resource resource)
    {
        ResourceReservation newReservation = new ResourceReservation(Take(resource), this);

        reservations.Add(newReservation);
        return(newReservation);
    }
コード例 #6
0
    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;
    }
コード例 #7
0
        /// <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));
        }
コード例 #8
0
        /// <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);
        }
コード例 #9
0
        /// <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);
        }
コード例 #10
0
        /// <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);
        }
コード例 #11
0
 /// <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;
 }
コード例 #12
0
ファイル: Program.cs プロジェクト: zz119/FastDFS.Net
        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);
        }
コード例 #13
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");
        }
コード例 #14
0
        /// <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);
            }
        }
コード例 #15
0
        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;
        }
コード例 #16
0
        /// <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);
            }
        }
コード例 #17
0
        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]);
        }
コード例 #18
0
    public void RemoveStorage(GameObject go)
    {
        StorageNode storage = FindStorageNodeFromPosition(go.transform.position);

        OnStorageDemolishListeners(storage);
        storageNodeList.Remove(storage);
    }
コード例 #19
0
ファイル: TileCanvas.cs プロジェクト: i-e-b/Slick
        /// <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();
        }
コード例 #20
0
        /// <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);
        }
コード例 #21
0
        /// <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);
        }
コード例 #22
0
        /// <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);
        }
コード例 #23
0
 protected override bool InternalIsExist(StorageNode path)
 {
     if (path.IsFile)
     {
         return(File.Exists(path.AbosolutePath));
     }
     return(Directory.Exists(path.AbosolutePath));
 }
コード例 #24
0
        /// <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);
        }
コード例 #25
0
        /// <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);
        }
コード例 #26
0
        /// <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);
        }
コード例 #27
0
        /// <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;
        }
コード例 #28
0
        /// <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);
        }
コード例 #29
0
        /// <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);
        }
コード例 #30
0
        /// <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);
        }
コード例 #31
0
        /// <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);
        }
コード例 #32
0
 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;
     }
 }
コード例 #33
0
 /// <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;
 }
コード例 #34
0
ファイル: Program.cs プロジェクト: HouZhiHouJue/FastDFS.Net
		protected static bool FileExistsOnStorageNode(StorageNode node, string fileName)
		{
			try
			{
				FastDFSClient.GetFileInfo(node, fileName);
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}
コード例 #35
0
 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;
 }
コード例 #36
0
ファイル: Program.cs プロジェクト: HouZhiHouJue/FastDFS.Net
		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;
		}
コード例 #37
0
        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();
        }
コード例 #38
0
ファイル: Program.cs プロジェクト: HouZhiHouJue/FastDFS.Net
		StorageNode SelectStorageNode(StorageNode[] nodes, string fileName, int timeoutSecs)
		{
			foreach (StorageNode node in nodes)
			{
				if (WaitForFileExists(node, fileName, TimeSpan.FromSeconds(timeoutSecs)))
					return node;
			}
			return null;
		}
コード例 #39
0
ファイル: Program.cs プロジェクト: HouZhiHouJue/FastDFS.Net
		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);
		}
コード例 #40
0
ファイル: Program.cs プロジェクト: HouZhiHouJue/FastDFS.Net
		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);
		}
コード例 #41
0
 /// <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;
 }
コード例 #42
0
 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;
 }
コード例 #43
0
 /// <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;
 }
コード例 #44
0
 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
 }
コード例 #45
0
 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;
 }