Ejemplo n.º 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="paramList">
        /// 1,IPEndPoint    IPEndPoint-->the storage IPEndPoint
        /// 2,string        FileName
        /// 3,byte[]        File bytes
        /// </param>
        /// <returns></returns>
        public override FDFSRequest GetRequest(params object[] paramList)
        {
            if (paramList.Length != 3)
            {
                throw new FDFSException("param count is wrong");
            }
            IPEndPoint endPoint = (IPEndPoint)paramList[0];

            string fileName = (string)paramList[1];

            byte[] contentBuffer = (byte[])paramList[2];

            APPEND_FILE result = new APPEND_FILE();

            result.Connection = ConnectionManager.GetStorageConnection(endPoint);

            long length = Consts.FDFS_PROTO_PKG_LEN_SIZE + Consts.FDFS_PROTO_PKG_LEN_SIZE + fileName.Length + contentBuffer.Length;

            byte[] bodyBuffer = new byte[length];

            byte[] fileNameLenBuffer = FDFSUtil.LongToBuffer(fileName.Length);
            Array.Copy(fileNameLenBuffer, 0, bodyBuffer, 0, fileNameLenBuffer.Length);

            byte[] fileSizeBuffer = FDFSUtil.LongToBuffer(contentBuffer.Length);
            Array.Copy(fileSizeBuffer, 0, bodyBuffer, Consts.FDFS_PROTO_PKG_LEN_SIZE, fileSizeBuffer.Length);

            byte[] fileNameBuffer = FDFSUtil.StringToByte(fileName);
            Array.Copy(fileNameBuffer, 0, bodyBuffer, Consts.FDFS_PROTO_PKG_LEN_SIZE + Consts.FDFS_PROTO_PKG_LEN_SIZE, fileNameBuffer.Length);

            Array.Copy(contentBuffer, 0, bodyBuffer, Consts.FDFS_PROTO_PKG_LEN_SIZE + Consts.FDFS_PROTO_PKG_LEN_SIZE + fileNameBuffer.Length, contentBuffer.Length);

            result.Body   = bodyBuffer;
            result.Header = new FDFSHeader(length, Consts.STORAGE_PROTO_CMD_APPEND_FILE, 0);
            return(result);
        }
Ejemplo n.º 2
0
 public byte[] ToByte()
 {
     byte[] result = new byte[Consts.FDFS_PROTO_PKG_LEN_SIZE + 2];
     byte[] pkglen = FDFSUtil.LongToBuffer(this._length);
     Array.Copy(pkglen, 0, result, 0, pkglen.Length);
     result[Consts.FDFS_PROTO_PKG_LEN_SIZE]     = this._command;
     result[Consts.FDFS_PROTO_PKG_LEN_SIZE + 1] = this._status;
     return(result);
 }
Ejemplo n.º 3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="paramList">
        /// 1,IPEndPoint    IPEndPoint-->the storage IPEndPoint
        /// 2,Byte          StorePathIndex
        /// 3,long          FileSize
        /// 4,string        File Ext
        /// 5,byte[FileSize]    File Content
        /// </param>
        /// <returns></returns>
        public override FDFSRequest GetRequest(params object[] paramList)
        {
            if (paramList.Length != 5)
            {
                throw new FDFSException("param count is wrong");
            }
            IPEndPoint endPoint = (IPEndPoint)paramList[0];

            byte   storePathIndex = (byte)paramList[1];
            int    fileSize       = (int)paramList[2];
            string ext            = (string)paramList[3];

            byte[] contentBuffer = (byte[])paramList[4];

            #region 拷贝后缀扩展名值
            byte[] extBuffer    = new byte[Consts.FDFS_FILE_EXT_NAME_MAX_LEN];
            byte[] bse          = FDFSUtil.StringToByte(ext);
            int    ext_name_len = bse.Length;
            if (ext_name_len > Consts.FDFS_FILE_EXT_NAME_MAX_LEN)
            {
                ext_name_len = Consts.FDFS_FILE_EXT_NAME_MAX_LEN;
            }
            Array.Copy(bse, 0, extBuffer, 0, ext_name_len);
            #endregion

            UPLOAD_FILE result = new UPLOAD_FILE();
            result.Connection = ConnectionManager.GetStorageConnection(endPoint);
            if (ext.Length > Consts.FDFS_FILE_EXT_NAME_MAX_LEN)
            {
                throw new FDFSException("file ext is too long");
            }

            long   length     = 1 + Consts.FDFS_PROTO_PKG_LEN_SIZE + Consts.FDFS_FILE_EXT_NAME_MAX_LEN + contentBuffer.Length;
            byte[] bodyBuffer = new byte[length];
            bodyBuffer[0] = storePathIndex;

            byte[] fileSizeBuffer = FDFSUtil.LongToBuffer(fileSize);
            Array.Copy(fileSizeBuffer, 0, bodyBuffer, 1, fileSizeBuffer.Length);

            //byte[] extBuffer = Util.StringToByte(ext);
            Array.Copy(extBuffer, 0, bodyBuffer, 1 + Consts.FDFS_PROTO_PKG_LEN_SIZE, extBuffer.Length);

            Array.Copy(contentBuffer, 0, bodyBuffer, 1 + Consts.FDFS_PROTO_PKG_LEN_SIZE + Consts.FDFS_FILE_EXT_NAME_MAX_LEN, contentBuffer.Length);

            result.Body   = bodyBuffer;
            result.Header = new FDFSHeader(length, Consts.STORAGE_PROTO_CMD_UPLOAD_FILE, 0);
            return(result);
        }
Ejemplo n.º 4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="paramList">
        /// 1,IPEndPoint    IPEndPoint-->the storage IPEndPoint
        /// 2,long offset-->file offset
        /// 3,long byteSize -->download file bytes
        /// 4,string groupName
        /// 5,string fileName
        /// </param>
        /// <returns></returns>
        public override FDFSRequest GetRequest(params object[] paramList)
        {
            if (paramList.Length != 5)
            {
                throw new FDFSException("param count is wrong");
            }
            IPEndPoint endPoint  = (IPEndPoint)paramList[0];
            long       offset    = (long)paramList[1];
            long       byteSize  = (long)paramList[2];
            string     groupName = (string)paramList[3];
            string     fileName  = (string)paramList[4];

            DOWNLOAD_FILE result = new DOWNLOAD_FILE();

            result.Connection = ConnectionManager.GetStorageConnection(endPoint);

            if (groupName.Length > Consts.FDFS_GROUP_NAME_MAX_LEN)
            {
                throw new FDFSException("groupName is too long");
            }

            long length = Consts.FDFS_PROTO_PKG_LEN_SIZE +
                          Consts.FDFS_PROTO_PKG_LEN_SIZE +
                          Consts.FDFS_GROUP_NAME_MAX_LEN +
                          fileName.Length;

            byte[] bodyBuffer      = new byte[length];
            byte[] offsetBuffer    = FDFSUtil.LongToBuffer(offset);
            byte[] byteSizeBuffer  = FDFSUtil.LongToBuffer(byteSize);
            byte[] groupNameBuffer = FDFSUtil.StringToByte(groupName);
            byte[] fileNameBuffer  = FDFSUtil.StringToByte(fileName);
            Array.Copy(offsetBuffer, 0, bodyBuffer, 0, offsetBuffer.Length);
            Array.Copy(byteSizeBuffer, 0, bodyBuffer, Consts.FDFS_PROTO_PKG_LEN_SIZE, byteSizeBuffer.Length);
            Array.Copy(groupNameBuffer, 0, bodyBuffer, Consts.FDFS_PROTO_PKG_LEN_SIZE +
                       Consts.FDFS_PROTO_PKG_LEN_SIZE, groupNameBuffer.Length);
            Array.Copy(fileNameBuffer, 0, bodyBuffer, Consts.FDFS_PROTO_PKG_LEN_SIZE +
                       Consts.FDFS_PROTO_PKG_LEN_SIZE + Consts.FDFS_GROUP_NAME_MAX_LEN, fileNameBuffer.Length);

            result.Body   = bodyBuffer;
            result.Header = new FDFSHeader(length, Consts.STORAGE_PROTO_CMD_DOWNLOAD_FILE, 0);
            return(result);
        }
Ejemplo n.º 5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="paramList">
        /// 1,IPEndPoint    IPEndPoint-->the storage IPEndPoint
        /// 2,Byte          StorePathIndex
        /// 3,long          FileSize
        /// 4,string        File Ext
        /// 5,byte[FileSize]    File Content
        /// </param>
        /// <returns></returns>
        public override FDFSRequest GetRequest(params object[] paramList)
        {
            if (paramList.Length != 6)
            {
                throw new FDFSException("param count is wrong");
            }
            IPEndPoint endPoint = (IPEndPoint)paramList[0];

            int    fileSize       = (int)paramList[1];
            string masterFilename = paramList[2].ToString();
            string prefix_name    = (string)paramList[3];
            string ext            = (string)paramList[4];

            byte[] contentBuffer = (byte[])paramList[5];
            byte[] sizeBytes;
            byte[] hexLenBytes;
            byte[] masterFilenameBytes = FDFSUtil.StringToByte(masterFilename);
            int    offset;

            #region 拷贝后缀扩展名值
            byte[] extBuffer    = new byte[Consts.FDFS_FILE_EXT_NAME_MAX_LEN];
            byte[] bse          = FDFSUtil.StringToByte(ext);
            int    ext_name_len = bse.Length;
            if (ext_name_len > Consts.FDFS_FILE_EXT_NAME_MAX_LEN)
            {
                ext_name_len = Consts.FDFS_FILE_EXT_NAME_MAX_LEN;
            }
            Array.Copy(bse, 0, extBuffer, 0, ext_name_len);
            #endregion

            UPLOAD_SLAVE_FILE result = new UPLOAD_SLAVE_FILE();
            result.Connection = ConnectionManager.GetStorageConnection(endPoint);
            if (ext.Length > Consts.FDFS_FILE_EXT_NAME_MAX_LEN)
            {
                throw new FDFSException("file ext is too long");
            }

            sizeBytes = new byte[2 * Consts.FDFS_PROTO_PKG_LEN_SIZE];
            //long length = 1 + Consts.FDFS_PROTO_PKG_LEN_SIZE + Consts.FDFS_FILE_EXT_NAME_MAX_LEN + contentBuffer.Length;
            long length = sizeBytes.Length + +Consts.FDFS_FILE_PREFIX_MAX_LEN + Consts.FDFS_FILE_EXT_NAME_MAX_LEN + masterFilenameBytes.Length + contentBuffer.Length;
            //body_len = sizeBytes.length + ProtoCommon.FDFS_FILE_PREFIX_MAX_LEN + ProtoCommon.FDFS_FILE_EXT_NAME_MAX_LEN
            //             + masterFilenameBytes.length + file_size;
            byte[] bodyBuffer = new byte[length];
            hexLenBytes = FDFSUtil.LongToBuffer(masterFilename.Length);
            offset      = hexLenBytes.Length;

            //Array.Copy(hexLenBytes, 0, sizeBytes, 0, hexLenBytes.Length);

            Array.Copy(hexLenBytes, 0, bodyBuffer, 0, hexLenBytes.Length);
            //System.arraycopy(sizeBytes, 0, wholePkg, header.length, sizeBytes.length);

            byte[] fileSizeBuffer = FDFSUtil.LongToBuffer(fileSize);
            Array.Copy(fileSizeBuffer, 0, bodyBuffer, offset, fileSizeBuffer.Length);

            offset = sizeBytes.Length;

            byte[] prefix_name_bs  = new byte[Consts.FDFS_FILE_PREFIX_MAX_LEN];
            byte[] bs              = FDFSUtil.StringToByte(prefix_name);
            int    prefix_name_len = bs.Length;
            if (prefix_name_len > Consts.FDFS_FILE_PREFIX_MAX_LEN)
            {
                prefix_name_len = Consts.FDFS_FILE_PREFIX_MAX_LEN;
            }
            if (prefix_name_len > 0)
            {
                Array.Copy(bs, 0, prefix_name_bs, 0, prefix_name_len);
            }
            Array.Copy(prefix_name_bs, 0, bodyBuffer, offset, prefix_name_bs.Length);

            offset += prefix_name_bs.Length;

            Array.Copy(extBuffer, 0, bodyBuffer, offset, extBuffer.Length);

            offset += extBuffer.Length;

            Array.Copy(masterFilenameBytes, 0, bodyBuffer, offset, masterFilenameBytes.Length);
            offset += masterFilenameBytes.Length;

            Array.Copy(contentBuffer, 0, bodyBuffer, offset, contentBuffer.Length);

            result.Body   = bodyBuffer;
            result.Header = new FDFSHeader(length, Consts.STORAGE_PROTO_CMD_UPLOAD_SLAVE_FILE, 0);
            return(result);
        }