java客户端如何获取storage http端口进行文件下载

eighteencold

两台同组的storage server：

第1台storage web server(nginx)  192.168.1.100 端口(storage.conf配置文件的http.server_port)：80

第2台storage web server(nginx)  192.168.1.101 端口(storage.conf配置文件的http.server_port)：82

假设我保存一个文件进了第1台storage，那么我的下载地址为http://192.168.1.100/remote_filename
假设我保存一个文件进了第2台storage，那么我的下载地址为http://192.168.1.101:82/remote_filename

问题是在java客户端中如何获取这个端口。

API有如下代码：
storageServers.getInetSocketAddress().getPort()
但这个端口获取的是storage.conf配置文件中的port端口值，并非http.server_port

kyon_lonely

storage机器上直接搭个nginx，把鱼大提供的nginx module编进去，然后就可以直接提供文件下载了。

eighteencold

回复 2# kyon_lonely

我的也能下载，但问题是URL怎么获取

kyon_lonely

回复 3# eighteencold


    FastDFS不是给生成了么？前面再加上storage的ip就可以了。

eighteencold

自带的test_upload中应该是有的，但在java客户端中应该是获取不到的，如果可以的话，麻烦给我发段获取代码，谢谢啦回复 4# kyon_lonely


   

eighteencold

等不及了，准备自己通过配置文件维护了，通过获取storage的IP来映射它的下载路径的前半段如：

192.168.1.100=http://down.xxxx.com
192.168.1.101=http://192.168.1.100:82

eighteencold

发下代码吧，有遇到相同问题的可以参考一下：

重写StorageClient的query_file_info方法，在storageServer 置空之前， 获取它的InetSocketAddress拿到storageServer 的ip;新增getHttpURI
这们我就能在调用get_file_info方法之后再调用getHttpURI获取httpURL。

1. import java.io.IOException;
   
2. import java.io.InputStream;
   
3. import java.io.OutputStream;
   
4. import java.net.Socket;
   
5. import java.util.Arrays;
   
6. import java.util.Properties;
   
7. 
   
8. import org.csource.common.MyException;
   
9. import org.csource.fastdfs.ClientGlobal;
   
10. import org.csource.fastdfs.FileInfo;
    
11. import org.csource.fastdfs.ProtoCommon;
    
12. import org.csource.fastdfs.StorageServer;
    
13. import org.csource.fastdfs.TrackerServer;
    
14. 
    
15. public class StorageClient extends org.csource.fastdfs.StorageClient {
    
16. 
    
17.         public final static String confPath = "FileServer_client.conf";
    
18.        
    
19.         private static Properties prop = new Properties();
    
20.        
    
21.         private static boolean isInit=false;
    
22.        
    
23.         protected String uri;
    
24. 
    
25.         public StorageClient(TrackerServer trackerServer, StorageServer storageServer) {
    
26.                 super(trackerServer, storageServer);
    
27.                 init();
    
28.         }
    
29. 
    
30.         public StorageClient() {
    
31.                 super();
    
32.                 init();
    
33.         }
    
34. 
    
35.         public void init(){
    
36.                 if(isInit){
    
37.                         return;
    
38.                 }
    
39.                 ClassLoader cl = Thread.currentThread().getContextClassLoader();
    
40.                 InputStream in = cl.getResourceAsStream(confPath);
    
41.                 try {
    
42.                         prop.load(in);
    
43.                         in.close();
    
44.                         isInit=true;
    
45.                 } catch (IOException e) {
    
46.                         e.printStackTrace();
    
47.                 }
    
48. 
    
49.         }
    
50.        
    
51.         public String getHttpURI() {
    
52.                 return uri;
    
53.         }
    
54. 
    
55.         @Override
    
56.         public FileInfo query_file_info(String group_name, String remote_filename)
    
57.                         throws IOException, MyException {
    
58.                 boolean bNewConnection = this.newUpdatableStorageConnection(group_name,
    
59.                                 remote_filename);
    
60.                 Socket storageSocket = this.storageServer.getSocket();
    
61. 
    
62.                 try {
    
63.                         byte[] header;
    
64.                         byte[] groupBytes;
    
65.                         byte[] filenameBytes;
    
66.                         byte[] bs;
    
67.                         int groupLen;
    
68.                         ProtoCommon.RecvPackageInfo pkgInfo;
    
69. 
    
70.                         filenameBytes = remote_filename.getBytes(ClientGlobal.g_charset);
    
71.                         groupBytes = new byte[ProtoCommon.FDFS_GROUP_NAME_MAX_LEN];
    
72.                         bs = group_name.getBytes(ClientGlobal.g_charset);
    
73. 
    
74.                         Arrays.fill(groupBytes, (byte) 0);
    
75.                         if (bs.length <= groupBytes.length) {
    
76.                                 groupLen = bs.length;
    
77.                         } else {
    
78.                                 groupLen = groupBytes.length;
    
79.                         }
    
80.                         System.arraycopy(bs, 0, groupBytes, 0, groupLen);
    
81. 
    
82.                         header = ProtoCommon.packHeader(
    
83.                                         ProtoCommon.STORAGE_PROTO_CMD_QUERY_FILE_INFO,
    
84.                                         +groupBytes.length + filenameBytes.length, (byte) 0);
    
85.                         OutputStream out = storageSocket.getOutputStream();
    
86.                         byte[] wholePkg = new byte[header.length + groupBytes.length
    
87.                                         + filenameBytes.length];
    
88.                         System.arraycopy(header, 0, wholePkg, 0, header.length);
    
89.                         System.arraycopy(groupBytes, 0, wholePkg, header.length,
    
90.                                         groupBytes.length);
    
91.                         System.arraycopy(filenameBytes, 0, wholePkg, header.length
    
92.                                         + groupBytes.length, filenameBytes.length);
    
93.                         out.write(wholePkg);
    
94. 
    
95.                         pkgInfo = ProtoCommon.recvPackage(storageSocket.getInputStream(),
    
96.                                         ProtoCommon.STORAGE_PROTO_CMD_RESP, 3
    
97.                                                         * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE
    
98.                                                         + ProtoCommon.FDFS_IPADDR_SIZE);
    
99. 
    
100.                         this.errno = pkgInfo.errno;
     
101.                         if (pkgInfo.errno != 0) {
     
102.                                 return null;
     
103.                         }
     
104. 
     
105.                         long file_size = ProtoCommon.buff2long(pkgInfo.body, 0);
     
106.                         int create_timestamp = (int) ProtoCommon.buff2long(pkgInfo.body,
     
107.                                         ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     
108.                         int crc32 = (int) ProtoCommon.buff2long(pkgInfo.body,
     
109.                                         2 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE);
     
110.                         String source_ip_addr = (new String(pkgInfo.body,
     
111.                                         3 * ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE,
     
112.                                         ProtoCommon.FDFS_IPADDR_SIZE)).trim();
     
113.                         return new FileInfo(file_size, create_timestamp, crc32,
     
114.                                         source_ip_addr);
     
115.                 } catch (IOException ex) {
     
116.                         if (!bNewConnection) {
     
117.                                 try {
     
118.                                         this.storageServer.close();
     
119.                                 } catch (IOException ex1) {
     
120.                                         ex1.printStackTrace();
     
121.                                 } finally {
     
122.                                         this.storageServer = null;
     
123.                                 }
     
124.                         }
     
125. 
     
126.                         throw ex;
     
127.                 } finally {
     
128.                         if (bNewConnection) {
     
129.                                 try {
     
130.                                         this.storageServer.close();
     
131.                                 } catch (IOException ex1) {
     
132.                                         ex1.printStackTrace();
     
133.                                 } finally {
     
134.                                         String ip = super.storageServer.getInetSocketAddress().getHostName();
     
135.                                         uri=prop.getProperty("httpURI."+ip);
     
136.                                         if(!uri.endsWith("/")){
     
137.                                                 uri=uri+"/";
     
138.                                         }
     
139.                                         this.storageServer = null;
     
140.                                 }
     
141.                         }
     
142.                 }
     
143.         }
     
144. }

复制代码

配置文件：

1. connect_timeout = 2
   
2. network_timeout = 30
   
3. charset = UTF-8
   
4. http.tracker_http_port = 80
   
5. http.anti_steal_token = no
   
6. http.secret_key = FastDFS1234567890
   
7. 
   
8. tracker_server = 192.168.15.201:22122
   
9. 
   
10. httpURI.192.168.15.201=http://192.168.15.201

复制代码

kyon_lonely

回复 5# eighteencold


看一下FastDFS如何与nginx进行整合吧。楼主没必要整那么复杂，拿到FastDFS生成的文件名之后，加上前缀域名。storage机器配置好nginx rewrite，下载文件时通过域名解析到具体机器，剩下的就是nginx自己处理了，不需要自己写代码。

http://blog.sina.com.cn/s/blog_6c9683650101e00g.html

eighteencold

刚开始想复杂了，就想着怎么获取ip了，其实ip已经在get_file_info返回的FileInfo中已经存在了（source_ip_addr）

故修改代码为提供工具类获取如下：

1. public class FileServerUtil {
   
2. 
   
3.         private IFileService fileService;
   
4. 
   
5.         private static FileServerUtil instance;
   
6.        
   
7.         public final static String confPath = "FileServer_client.conf";
   
8.        
   
9.         private static Properties prop = new Properties();
   
10. 
    
11.         public void setFileService(IFileService fileService) {
    
12.                 this.fileService = fileService;
    
13.         }
    
14. 
    
15.         public static IFileService getFileService() {
    
16.                 return instance.fileService;
    
17.         }
    
18. 
    
19.         public void init(){
    
20.                 instance=this;
    
21.                 instance.setFileService(fileService);
    
22.                 initProp();
    
23.         }
    
24. 
    
25.         public static void initProp(){
    
26.                 ClassLoader cl = Thread.currentThread().getContextClassLoader();
    
27.                 InputStream in = cl.getResourceAsStream(confPath);
    
28.                 try {
    
29.                         prop.load(in);
    
30.                         in.close();
    
31.                 } catch (IOException e) {
    
32.                         e.printStackTrace();
    
33.                 }
    
34.         }
    
35.        
    
36.         public static String getHttpURI(String ip) {
    
37.                 String uri=prop.getProperty("httpURI."+ip);
    
38.         if(!uri.endsWith("/")){
    
39.                 uri=uri+"/";
    
40.         }
    
41.                 return uri;
    
42.         }
    
43. }

复制代码

eighteencold

回复 8# kyon_lonely


应该我这里说的问题跟你说的不是同一个问题，你再好好看看