[疑问]StorageClient中，GetFileInfo方法，为什么文件类型为slave file或者appender file时返回的时候文件类型被配置为ileInfo.FILE_TYPE_NORMAL

```
 /**
     * get file info decoded from the filename, fetch from the storage if necessary
     *
     * @param group_name      the group name
     * @param remote_filename the filename
     * @return FileInfo object for success, return null for fail
     */
    public FileInfo get_file_info(String group_name, String remote_filename) throws IOException, MyException {
        if (remote_filename.length() < ProtoCommon.FDFS_FILE_PATH_LEN + ProtoCommon.FDFS_FILENAME_BASE64_LENGTH
                + ProtoCommon.FDFS_FILE_EXT_NAME_MAX_LEN + 1) {
            this.errno = ProtoCommon.ERR_NO_EINVAL;
            return null;
        }

byte[] buff = base64.decodeAuto(remote_filename.substring(ProtoCommon.FDFS_FILE_PATH_LEN,
                ProtoCommon.FDFS_FILE_PATH_LEN + ProtoCommon.FDFS_FILENAME_BASE64_LENGTH));

short file_type;
        long file_size = ProtoCommon.buff2long(buff, 4 * 2);
        if (((file_size & ProtoCommon.APPENDER_FILE_SIZE) != 0)) {
            file_type = FileInfo.FILE_TYPE_APPENDER;
        } else if ((remote_filename.length() > ProtoCommon.TRUNK_LOGIC_FILENAME_LENGTH) ||
                ((remote_filename.length() > ProtoCommon.NORMAL_LOGIC_FILENAME_LENGTH) &&
                        ((file_size & ProtoCommon.TRUNK_FILE_MARK_SIZE) == 0))) {
            file_type = FileInfo.FILE_TYPE_SLAVE;
        } else {
            file_type = FileInfo.FILE_TYPE_NORMAL;
        }

if (file_type == FileInfo.FILE_TYPE_SLAVE ||
                file_type == FileInfo.FILE_TYPE_APPENDER) { //slave file or appender file
            FileInfo fi = this.query_file_info(group_name, remote_filename);
            if (fi == null) {
                return null;
            }

fi.setFileType(file_type);
            return fi;
        }

int create_timestamp = ProtoCommon.buff2int(buff, 4);
        if ((file_size >> 63) != 0) {
            file_size &= 0xFFFFFFFFL;  //low 32 bits is file size
        }
        int crc32 = ProtoCommon.buff2int(buff, 4 * 4);

return new FileInfo(false, file_type, file_size, create_timestamp,
                crc32, ProtoCommon.getIpAddress(buff, 0));
    }

/**
     * get file info from storage server
     *
     * @param group_name      the group name of storage server
     * @param remote_filename filename on storage server
     * @return FileInfo object for success, return null for fail
     */
    public FileInfo query_file_info(String group_name, String remote_filename) throws IOException, MyException {
        boolean bNewStorageServer = this.newUpdatableStorageConnection(group_name, remote_filename);
        Connection connection = this.storageServer.getConnection();
        try {
            byte[] header;
            byte[] groupBytes;
            byte[] filenameBytes;
            byte[] bs;
            int groupLen;
            ProtoCommon.RecvPackageInfo pkgInfo;

filenameBytes = remote_filename.getBytes(ClientGlobal.g_charset);
            groupBytes = new byte[ProtoCommon.FDFS_GROUP_NAME_MAX_LEN];
            bs = group_name.getBytes(ClientGlobal.g_charset);

Arrays.fill(groupBytes, (byte) 0);
            if (bs.length <= groupBytes.length) {
                groupLen = bs.length;
            } else {
                groupLen = groupBytes.length;
            }
            System.arraycopy(bs, 0, groupBytes, 0, groupLen);

header = ProtoCommon.packHeader(ProtoCommon.STORAGE_PROTO_CMD_QUERY_FILE_INFO,
                    +groupBytes.length + filenameBytes.length, (byte) 0);
            OutputStream out = connection.getOutputStream();
            byte[] wholePkg = new byte[header.length + groupBytes.length + filenameBytes.length];
            System.arraycopy(header, 0, wholePkg, 0, header.length);
            System.arraycopy(groupBytes, 0, wholePkg, header.length, groupBytes.length);
            System.arraycopy(filenameBytes, 0, wholePkg, header.length + groupBytes.length, filenameBytes.length);
            out.write(wholePkg);

pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
                    ProtoCommon.STORAGE_PROTO_CMD_RESP, -1);

this.errno = pkgInfo.errno;
            if (pkgInfo.errno != 0) {
                return null;
            }

int front_len = 3 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
            int ip_size;
            if (pkgInfo.body.length == front_len + ProtoCommon.FDFS_IPV6_SIZE) { //IPv6
                ip_size = ProtoCommon.FDFS_IPV6_SIZE;
            } else if (pkgInfo.body.length == front_len + ProtoCommon.FDFS_IPV4_SIZE) { //IPv4
                ip_size = ProtoCommon.FDFS_IPV4_SIZE;
            } else {
                this.errno = ProtoCommon.ERR_NO_EINVAL;
                throw new IOException("Invalid body length: " + pkgInfo.body.length);
            }

long file_size = ProtoCommon.buff2long(pkgInfo.body, 0);
            int create_timestamp = (int) ProtoCommon.buff2long(pkgInfo.body, ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
            int crc32 = (int) ProtoCommon.buff2long(pkgInfo.body, 2 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
            String source_ip_addr = (new String(pkgInfo.body, front_len, ip_size)).trim();
            return new FileInfo(true, FileInfo.FILE_TYPE_NORMAL, file_size,
                    create_timestamp, crc32, source_ip_addr);
        } catch (IOException ex) {
            try {
                connection.close();
            } catch (IOException ex1) {
                ex1.printStackTrace();
            } finally {
                connection = null;
            }
            throw ex;
        } finally {
            releaseConnection(connection, bNewStorageServer);
        }
    }
```
在这两个方法中，为什么在GetFileInfo时，如果文件类型为slave file或者appender file时需要调用QueryFileInfo，但是返回的时候文件类型被配置为ileInfo.FILE_TYPE_NORMAL

happyfish100/fastdfs-client-java

内容风险标识

评论 (1)

happyfish100/fastdfs-client-java .gitee-modal { width: 500px !important; }

内容风险标识