/// <summary>
/// get storage servers to download file
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="file_id">the file id(including group name and filename)</param>
/// <returns> storage servers, return null if fail</returns>
public ServerInfo[] getFetchStorages1(TrackerServer trackerServer, string file_id)
{
string[] parts = new string[2];
this.errno = StorageClient1.split_file_id(file_id, parts);
if (this.errno != 0)
{
return(null);
}
return(this.getFetchStorages(trackerServer, parts[0], parts[1]));
}
public void initStorageClient()
{
ClientGlobal.init(CONF_NAME);
Log.Information("network_timeout=" + ClientGlobal.g_network_timeout + "ms");
Log.Information("charset=" + ClientGlobal.g_charset);
TrackerClient tracker = new TrackerClient();
trackerServer = tracker.getTrackerServer();
StorageServer storageServer = null;
storageClient = new StorageClient(trackerServer, storageServer);
}
/// <summary>
/// query storage server to update file (delete file or set meta data)
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="groupName">the group name of storage server</param>
/// <param name="filename">filename on storage server</param>
/// <returns> storage server JavaSocket object, return null if fail</returns>
public StorageServer getUpdateStorage(TrackerServer trackerServer,
string groupName, string filename)
{
ServerInfo[] servers = this.getStorages(trackerServer, ProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_UPDATE,
groupName, filename);
if (servers == null)
{
return(null);
}
else
{
return(new StorageServer(servers[0].getIpAddr(), servers[0].getPort(), 0));
}
}
/// <summary>
/// return connected tracker server
/// </summary>
/// <returns> connected tracker server, null for fail</returns>
public TrackerServer getTrackerServer()
{
int current_index;
lock (this.locker)
{
tracker_server_index++;
if (tracker_server_index >= tracker_servers.Length)
{
tracker_server_index = 0;
}
current_index = this.tracker_server_index;
}
try
{
return(getTrackerServer(current_index));
}
catch
{
Console.WriteLine("connect to server " + this.tracker_servers[current_index].Address + ":" + this.tracker_servers[current_index].Port + " fail");
}
for (int i = 0; i < this.tracker_servers.Length; i++)
{
if (i == current_index)
{
continue;
}
try
{
TrackerServer trackerServer = getTrackerServer(i);
lock (this.locker)
{
if (this.tracker_server_index == current_index)
{
this.tracker_server_index = i;
}
}
return(trackerServer);
}
catch
{
Console.WriteLine("connect to server " + this.tracker_servers[i].Address + ":" + this.tracker_servers[i].Port + " fail");
}
}
return(null);
}
public void main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Error: Must have 2 parameters, one is config filename, "
+ "the other is the local filename to upload");
return;
}
string conf_filename = args[0];
string local_filename = args[1];
try
{
ClientGlobal.init(conf_filename);
Console.WriteLine("network_timeout=" + ClientGlobal.g_network_timeout + "ms");
Console.WriteLine("charset=" + ClientGlobal.g_charset);
TrackerClient tracker = new TrackerClient();
TrackerServer trackerServer = tracker.getTrackerServer();
StorageServer storageServer = null;
StorageClient1 client = new StorageClient1(trackerServer, storageServer);
NameValuePair[] metaList = new NameValuePair[1];
metaList[0] = new NameValuePair("fileName", local_filename);
string fileId = client.upload_file1(local_filename, null, metaList);
Console.WriteLine("upload success. file id is: " + fileId);
int i = 0;
while (i++ < 10)
{
byte[] result = client.download_file1(fileId);
Console.WriteLine(i + ", download result is: " + result.Length);
}
}
catch (Exception ex)
{
Log.Error(ex.Message + ex.StackTrace);
}
}
/**
* entry point
*
* @param args comand arguments
* <ul><li>args[0]: config filename</li></ul>
*/
public static void main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("Error: Must have 1 parameter: config filename");
return;
}
try
{
ClientGlobal.init(args[0]);
Console.WriteLine("network_timeout=" + ClientGlobal.g_network_timeout + "ms");
Console.WriteLine("charset=" + ClientGlobal.g_charset);
TrackerClient tracker = new TrackerClient();
/*
* Console.WriteLine("delete storage return: " + tracker.deleteStorage("group1", "192.168.0.192"));
* Console.WriteLine("delete storage errno: " + tracker.getErrorCode());
*/
TrackerServer trackerServer = tracker.getTrackerServer();
if (trackerServer == null)
{
return;
}
int count;
StructGroupStat[] groupStats = tracker.listGroups(trackerServer);
if (groupStats == null)
{
Console.WriteLine("");
Console.WriteLine("ERROR! list groups error, error no: " + tracker.getErrorCode());
Console.WriteLine("");
return;
}
Console.WriteLine("group count: " + groupStats.Length);
count = 0;
foreach (StructGroupStat groupStat in groupStats)
{
count++;
Console.WriteLine("Group " + count + ":");
Console.WriteLine("group name = " + groupStat.getGroupName());
Console.WriteLine("disk total space = " + groupStat.getTotalMB() + "MB");
Console.WriteLine("disk free space = " + groupStat.getFreeMB() + " MB");
Console.WriteLine("trunk free space = " + groupStat.getTrunkFreeMB() + " MB");
Console.WriteLine("storage server count = " + groupStat.getStorageCount());
Console.WriteLine("active server count = " + groupStat.getActiveCount());
Console.WriteLine("storage server port = " + groupStat.getStoragePort());
Console.WriteLine("storage HTTP port = " + groupStat.getStorageHttpPort());
Console.WriteLine("store path count = " + groupStat.getStorePathCount());
Console.WriteLine("subdir count per path = " + groupStat.getSubdirCountPerPath());
Console.WriteLine("current write server index = " + groupStat.getCurrentWriteServer());
Console.WriteLine("current trunk file id = " + groupStat.getCurrentTrunkFileId());
StructStorageStat[] storageStats = tracker.listStorages(trackerServer, groupStat.getGroupName());
if (storageStats == null)
{
Console.WriteLine("");
Console.WriteLine("ERROR! list storage error, error no: " + tracker.getErrorCode());
Console.WriteLine("");
break;
}
var format = "yyyy-MM-dd HH:mm:ss";
int stroageCount = 0;
foreach (var storageStat in storageStats)
{
stroageCount++;
Console.WriteLine("\tStorage " + stroageCount + ":");
Console.WriteLine("\t\tstorage id = " + storageStat.getId());
Console.WriteLine("\t\tip_addr = " + storageStat.getIpAddr() + " " + ProtoCommon.getStorageStatusCaption(storageStat.getStatus()));
Console.WriteLine("\t\thttp domain = " + storageStat.getDomainName());
Console.WriteLine("\t\tversion = " + storageStat.getVersion());
Console.WriteLine("\t\tjoin time = " + storageStat.getJoinTime().ToString(format));
Console.WriteLine("\t\tup time = " + (storageStat.getUpTime().Ticks == 0 ? "" : storageStat.getUpTime().ToString(format)));
Console.WriteLine("\t\ttotal storage = " + storageStat.getTotalMB() + "MB");
Console.WriteLine("\t\tfree storage = " + storageStat.getFreeMB() + "MB");
Console.WriteLine("\t\tupload priority = " + storageStat.getUploadPriority());
Console.WriteLine("\t\tstore_path_count = " + storageStat.getStorePathCount());
Console.WriteLine("\t\tsubdir_count_per_path = " + storageStat.getSubdirCountPerPath());
Console.WriteLine("\t\tstorage_port = " + storageStat.getStoragePort());
Console.WriteLine("\t\tstorage_http_port = " + storageStat.getStorageHttpPort());
Console.WriteLine("\t\tcurrent_write_path = " + storageStat.getCurrentWritePath());
Console.WriteLine("\t\tsource ip_addr = " + storageStat.getSrcIpAddr());
Console.WriteLine("\t\tif_trunk_server = " + storageStat.isTrunkServer());
Console.WriteLine("\t\tconntion.alloc_count = " + storageStat.getConnectionAllocCount());
Console.WriteLine("\t\tconntion.current_count = " + storageStat.getConnectionCurrentCount());
Console.WriteLine("\t\tconntion.max_count = " + storageStat.getConnectionMaxCount());
Console.WriteLine("\t\ttotal_upload_count = " + storageStat.getTotalUploadCount());
Console.WriteLine("\t\tsuccess_upload_count = " + storageStat.getSuccessUploadCount());
Console.WriteLine("\t\ttotal_append_count = " + storageStat.getTotalAppendCount());
Console.WriteLine("\t\tsuccess_append_count = " + storageStat.getSuccessAppendCount());
Console.WriteLine("\t\ttotal_modify_count = " + storageStat.getTotalModifyCount());
Console.WriteLine("\t\tsuccess_modify_count = " + storageStat.getSuccessModifyCount());
Console.WriteLine("\t\ttotal_truncate_count = " + storageStat.getTotalTruncateCount());
Console.WriteLine("\t\tsuccess_truncate_count = " + storageStat.getSuccessTruncateCount());
Console.WriteLine("\t\ttotal_set_meta_count = " + storageStat.getTotalSetMetaCount());
Console.WriteLine("\t\tsuccess_set_meta_count = " + storageStat.getSuccessSetMetaCount());
Console.WriteLine("\t\ttotal_delete_count = " + storageStat.getTotalDeleteCount());
Console.WriteLine("\t\tsuccess_delete_count = " + storageStat.getSuccessDeleteCount());
Console.WriteLine("\t\ttotal_download_count = " + storageStat.getTotalDownloadCount());
Console.WriteLine("\t\tsuccess_download_count = " + storageStat.getSuccessDownloadCount());
Console.WriteLine("\t\ttotal_get_meta_count = " + storageStat.getTotalGetMetaCount());
Console.WriteLine("\t\tsuccess_get_meta_count = " + storageStat.getSuccessGetMetaCount());
Console.WriteLine("\t\ttotal_create_link_count = " + storageStat.getTotalCreateLinkCount());
Console.WriteLine("\t\tsuccess_create_link_count = " + storageStat.getSuccessCreateLinkCount());
Console.WriteLine("\t\ttotal_delete_link_count = " + storageStat.getTotalDeleteLinkCount());
Console.WriteLine("\t\tsuccess_delete_link_count = " + storageStat.getSuccessDeleteLinkCount());
Console.WriteLine("\t\ttotal_upload_bytes = " + storageStat.getTotalUploadBytes());
Console.WriteLine("\t\tsuccess_upload_bytes = " + storageStat.getSuccessUploadBytes());
Console.WriteLine("\t\ttotal_append_bytes = " + storageStat.getTotalAppendBytes());
Console.WriteLine("\t\tsuccess_append_bytes = " + storageStat.getSuccessAppendBytes());
Console.WriteLine("\t\ttotal_modify_bytes = " + storageStat.getTotalModifyBytes());
Console.WriteLine("\t\tsuccess_modify_bytes = " + storageStat.getSuccessModifyBytes());
Console.WriteLine("\t\ttotal_download_bytes = " + storageStat.getTotalDownloadloadBytes());
Console.WriteLine("\t\tsuccess_download_bytes = " + storageStat.getSuccessDownloadloadBytes());
Console.WriteLine("\t\ttotal_sync_in_bytes = " + storageStat.getTotalSyncInBytes());
Console.WriteLine("\t\tsuccess_sync_in_bytes = " + storageStat.getSuccessSyncInBytes());
Console.WriteLine("\t\ttotal_sync_out_bytes = " + storageStat.getTotalSyncOutBytes());
Console.WriteLine("\t\tsuccess_sync_out_bytes = " + storageStat.getSuccessSyncOutBytes());
Console.WriteLine("\t\ttotal_file_open_count = " + storageStat.getTotalFileOpenCount());
Console.WriteLine("\t\tsuccess_file_open_count = " + storageStat.getSuccessFileOpenCount());
Console.WriteLine("\t\ttotal_file_read_count = " + storageStat.getTotalFileReadCount());
Console.WriteLine("\t\tsuccess_file_read_count = " + storageStat.getSuccessFileReadCount());
Console.WriteLine("\t\ttotal_file_write_count = " + storageStat.getTotalFileWriteCount());
Console.WriteLine("\t\tsuccess_file_write_count = " + storageStat.getSuccessFileWriteCount());
Console.WriteLine("\t\tlast_heart_beat_time = " + storageStat.getLastHeartBeatTime().ToString(format));
Console.WriteLine("\t\tlast_source_update = " + storageStat.getLastSourceUpdate().ToString(format));
Console.WriteLine("\t\tlast_sync_update = " + storageStat.getLastSyncUpdate().ToString(format));
Console.WriteLine("\t\tlast_synced_timestamp = " + storageStat.getLastSyncedTimestamp().ToString(format) + getSyncedDelayString(storageStats, storageStat));
}
}
}
catch (Exception ex)
{
Log.Error(ex.Message + ex.StackTrace);
}
}
public static void main(string[] args)
{
try
{
if (args.Length < 1)
{
Console.WriteLine("Usage: 2 parameters, one is config filename, "
+ "the other is the local filename to upload");
return;
}
string conf_filename = args[0];
string local_filename;
string ext_name;
if (args.Length > 1)
{
local_filename = args[1];
ext_name = null;
}
else if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
local_filename = "c:/windows/system32/notepad.exe";
ext_name = "exe";
}
else
{
local_filename = "/etc/hosts";
ext_name = "";
}
ClientGlobal.init(conf_filename);
Console.WriteLine("network_timeout=" + ClientGlobal.g_network_timeout + "ms");
Console.WriteLine("charset=" + ClientGlobal.g_charset);
TrackerGroup tg = new TrackerGroup(new InetSocketAddress[] { new InetSocketAddress("47.95.221.159", 22122) });
TrackerClient tc = new TrackerClient(tg);
TrackerServer ts = tc.getTrackerServer();
if (ts == null)
{
Console.WriteLine("getTrackerServer return null");
return;
}
StorageServer ss = tc.getStoreStorage(ts);
if (ss == null)
{
Console.WriteLine("getStoreStorage return null");
}
StorageClient1 sc1 = new StorageClient1(ts, ss);
NameValuePair[] meta_list = null; //new NameValuePair[0];
string fileid = sc1.upload_file1(local_filename, ext_name, meta_list);
Console.WriteLine("Upload local file " + local_filename + " ok, fileid: " + fileid);
}
catch (Exception ex)
{
Log.Error(ex.Message + ex.StackTrace);
}
}
public Downloader()
{
this.tracker = new TrackerClient();
this.trackerServer = tracker.getTrackerServer();
this.callback = new DownloadFileDiscard();
}
public Uploader()
{
this.tracker = new TrackerClient();
this.trackerServer = tracker.getTrackerServer();
}
/// <summary>
/// query storage server stat info of the group
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="groupName">the group name of storage server</param>
/// <param name="storageIpAddr">the storage server ip address, can be null or empty</param>
/// <returns> storage server stat array, return null if fail</returns>
public StructStorageStat[] listStorages(TrackerServer trackerServer,
string groupName, string storageIpAddr)
{
byte[] header;
byte[] bGroupName;
byte[] bs;
int len;
Connection connection;
if (trackerServer == null)
{
trackerServer = getTrackerServer();
if (trackerServer == null)
{
return(null);
}
}
connection = trackerServer.getConnection();
Stream outStream = connection.getOutputStream();
try
{
bs = ClientGlobal.g_charset.GetBytes(groupName);
bGroupName = new byte[ProtoCommon.FDFS_GROUP_NAME_MAX_LEN];
if (bs.Length <= ProtoCommon.FDFS_GROUP_NAME_MAX_LEN)
{
len = bs.Length;
}
else
{
len = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
}
Arrays.fill(bGroupName, (byte)0);
Array.Copy(bs, 0, bGroupName, 0, len);
int ipAddrLen;
byte[] bIpAddr;
if (storageIpAddr != null && storageIpAddr.Length > 0)
{
bIpAddr = ClientGlobal.g_charset.GetBytes(storageIpAddr);
if (bIpAddr.Length < ProtoCommon.FDFS_IPADDR_SIZE)
{
ipAddrLen = bIpAddr.Length;
}
else
{
ipAddrLen = ProtoCommon.FDFS_IPADDR_SIZE - 1;
}
}
else
{
bIpAddr = null;
ipAddrLen = 0;
}
header = ProtoCommon.packHeader(ProtoCommon.TRACKER_PROTO_CMD_SERVER_LIST_STORAGE, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ipAddrLen, (byte)0);
byte[] wholePkg = new byte[header.Length + bGroupName.Length + ipAddrLen];
Array.Copy(header, 0, wholePkg, 0, header.Length);
Array.Copy(bGroupName, 0, wholePkg, header.Length, bGroupName.Length);
if (ipAddrLen > 0)
{
Array.Copy(bIpAddr, 0, wholePkg, header.Length + bGroupName.Length, ipAddrLen);
}
outStream.Write(wholePkg, 0, wholePkg.Length);
ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
ProtoCommon.TRACKER_PROTO_CMD_RESP, -1);
this.errno = pkgInfo.errno;
if (pkgInfo.errno != 0)
{
return(null);
}
ProtoStructDecoder <StructStorageStat> decoder = new ProtoStructDecoder <StructStorageStat>();
return(decoder.decode(pkgInfo.body, StructStorageStat.getFieldsTotalSize()));
}
catch (IOException ex)
{
try
{
connection.close();
}
catch (IOException ex1)
{
throw ex1;
}
throw ex;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
this.errno = ProtoCommon.ERR_NO_EINVAL;
return(null);
}
finally
{
if (connection != null)
{
try
{
connection.release();
}
catch
{
}
}
}
}
/// <summary>
/// query storage server stat info of the group
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="groupName">the group name of storage server</param>
/// <returns> storage server stat array, return null if fail</returns>
public StructStorageStat[] listStorages(TrackerServer trackerServer, string groupName)
{
const string storageIpAddr = null;
return(this.listStorages(trackerServer, groupName, storageIpAddr));
}
/// <summary>
/// query storage server to upload file
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <returns> storage server JavaSocket object, return null if fail</returns>
public StorageServer getStoreStorage(TrackerServer trackerServer)
{
const string groupName = null;
return(this.getStoreStorage(trackerServer, groupName));
}
/// <summary>
/// list groups
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <returns> group stat array, return null if fail</returns>
public StructGroupStat[] listGroups(TrackerServer trackerServer)
{
byte[] header;
//string ip_addr;
//int port;
//byte cmd;
//int out_len;
//byte store_path;
Connection connection;
if (trackerServer == null)
{
trackerServer = getTrackerServer();
if (trackerServer == null)
{
return(null);
}
}
connection = trackerServer.getConnection();
Stream outStream = connection.getOutputStream();
try
{
header = ProtoCommon.packHeader(ProtoCommon.TRACKER_PROTO_CMD_SERVER_LIST_GROUP, 0, (byte)0);
outStream.Write(header, 0, header.Length);
ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
ProtoCommon.TRACKER_PROTO_CMD_RESP, -1);
this.errno = pkgInfo.errno;
if (pkgInfo.errno != 0)
{
return(null);
}
ProtoStructDecoder <StructGroupStat> decoder = new ProtoStructDecoder <StructGroupStat>();
return(decoder.decode(pkgInfo.body, StructGroupStat.getFieldsTotalSize()));
}
catch (IOException ex)
{
try
{
connection.close();
}
catch (IOException ex1)
{
throw ex1;
}
finally
{
connection = null;
}
throw ex;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
this.errno = ProtoCommon.ERR_NO_EINVAL;
return(null);
}
finally
{
if (connection != null)
{
try
{
connection.release();
}
catch
{
}
}
}
}
/// <summary>
/// query storage server to download file
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="cmd">command code, ProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_FETCH_ONE orProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_UPDATE</param>
/// <param name="groupName">the group name of storage server</param>
/// <param name="filename">filename on storage server</param>
/// <returns> storage server JavaSocket object, return null if fail</returns>
protected ServerInfo[] getStorages(TrackerServer trackerServer,
byte cmd, string groupName, string filename)
{
byte[] header;
byte[] bFileName;
byte[] bGroupName;
byte[] bs;
int len;
string ip_addr;
int port;
Connection connection;
if (trackerServer == null)
{
trackerServer = getTrackerServer();
if (trackerServer == null)
{
return(null);
}
}
connection = trackerServer.getConnection();
Stream outStream = connection.getOutputStream();
try
{
bs = ClientGlobal.g_charset.GetBytes(groupName);
bGroupName = new byte[ProtoCommon.FDFS_GROUP_NAME_MAX_LEN];
bFileName = ClientGlobal.g_charset.GetBytes(filename);
if (bs.Length <= ProtoCommon.FDFS_GROUP_NAME_MAX_LEN)
{
len = bs.Length;
}
else
{
len = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
}
Arrays.fill(bGroupName, (byte)0);
Array.Copy(bs, 0, bGroupName, 0, len);
header = ProtoCommon.packHeader(cmd, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + bFileName.Length, (byte)0);
byte[] wholePkg = new byte[header.Length + bGroupName.Length + bFileName.Length];
Array.Copy(header, 0, wholePkg, 0, header.Length);
Array.Copy(bGroupName, 0, wholePkg, header.Length, bGroupName.Length);
Array.Copy(bFileName, 0, wholePkg, header.Length + bGroupName.Length, bFileName.Length);
outStream.Write(wholePkg, 0, wholePkg.Length);
ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
ProtoCommon.TRACKER_PROTO_CMD_RESP, -1);
this.errno = pkgInfo.errno;
if (pkgInfo.errno != 0)
{
return(null);
}
if (pkgInfo.body.Length < ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN)
{
throw new IOException("Invalid body length: " + pkgInfo.body.Length);
}
if ((pkgInfo.body.Length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) % (ProtoCommon.FDFS_IPADDR_SIZE - 1) != 0)
{
throw new IOException("Invalid body length: " + pkgInfo.body.Length);
}
int server_count = 1 + (pkgInfo.body.Length - ProtoCommon.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) / (ProtoCommon.FDFS_IPADDR_SIZE - 1);
ip_addr = Strings.Get(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN, ProtoCommon.FDFS_IPADDR_SIZE - 1).Trim();
int offset = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ProtoCommon.FDFS_IPADDR_SIZE - 1;
port = (int)ProtoCommon.buff2long(pkgInfo.body, offset);
offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
ServerInfo[] servers = new ServerInfo[server_count];
servers[0] = new ServerInfo(ip_addr, port);
for (int i = 1; i < server_count; i++)
{
servers[i] = new ServerInfo(Strings.Get(pkgInfo.body, offset, ProtoCommon.FDFS_IPADDR_SIZE - 1).Trim(), port);
offset += ProtoCommon.FDFS_IPADDR_SIZE - 1;
}
return(servers);
}
catch (IOException ex)
{
try
{
connection.close();
}
catch (IOException ex1)
{
throw ex1;
}
finally
{
connection = null;
}
throw ex;
}
finally
{
if (connection != null)
{
try
{
connection.release();
}
catch
{
}
}
}
}
/// <summary>
/// get storage servers to download file
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="groupName">the group name of storage server</param>
/// <param name="filename">filename on storage server</param>
/// <returns> storage servers, return null if fail</returns>
public ServerInfo[] getFetchStorages(TrackerServer trackerServer,
string groupName, string filename)
{
return(this.getStorages(trackerServer, ProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_FETCH_ALL,
groupName, filename));
}
/// <summary>
/// delete a storage server from the tracker server
/// </summary>
/// <param name="trackerServer">the connected tracker server</param>
/// <param name="groupName">the group name of storage server</param>
/// <param name="storageIpAddr">the storage server ip address</param>
/// <returns> true for success, false for fail</returns>
private bool deleteStorage(TrackerServer trackerServer,
string groupName, string storageIpAddr)
{
byte[] header;
byte[] bGroupName;
byte[] bs;
int len;
Connection connection = null;
try
{
connection = trackerServer.getConnection();
Stream outStream = connection.getOutputStream();
bs = ClientGlobal.g_charset.GetBytes(groupName);
bGroupName = new byte[ProtoCommon.FDFS_GROUP_NAME_MAX_LEN];
if (bs.Length <= ProtoCommon.FDFS_GROUP_NAME_MAX_LEN)
{
len = bs.Length;
}
else
{
len = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
}
Arrays.fill(bGroupName, (byte)0);
Array.Copy(bs, 0, bGroupName, 0, len);
int ipAddrLen;
byte[] bIpAddr = ClientGlobal.g_charset.GetBytes(storageIpAddr);
if (bIpAddr.Length < ProtoCommon.FDFS_IPADDR_SIZE)
{
ipAddrLen = bIpAddr.Length;
}
else
{
ipAddrLen = ProtoCommon.FDFS_IPADDR_SIZE - 1;
}
header = ProtoCommon.packHeader(ProtoCommon.TRACKER_PROTO_CMD_SERVER_DELETE_STORAGE, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + ipAddrLen, (byte)0);
byte[] wholePkg = new byte[header.Length + bGroupName.Length + ipAddrLen];
Array.Copy(header, 0, wholePkg, 0, header.Length);
Array.Copy(bGroupName, 0, wholePkg, header.Length, bGroupName.Length);
Array.Copy(bIpAddr, 0, wholePkg, header.Length + bGroupName.Length, ipAddrLen);
outStream.Write(wholePkg, 0, wholePkg.Length);
ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
ProtoCommon.TRACKER_PROTO_CMD_RESP, 0);
this.errno = pkgInfo.errno;
return(pkgInfo.errno == 0);
}
catch (IOException e)
{
try
{
connection.close();
}
finally
{
connection = null;
}
throw e;
}
finally
{
if (connection != null)
{
connection.release();
}
}
}
/// <summary>
/// constructor with trackerServer and storageServer
/// NOTE: if not necessary, do NOT set storage server instance
/// </summary>
/// <param name="trackerServer">the tracker server, can be null</param>
/// <param name="storageServer">the storage server, can be null</param>
public StorageClient1(TrackerServer trackerServer, StorageServer storageServer) : base(trackerServer, storageServer)
{
}
/// <summary>
/// query storage server to upload file
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="groupName">the group name to upload file to, can be empty</param>
/// <returns> storage server object, return null if fail</returns>
public StorageServer getStoreStorage(TrackerServer trackerServer, string groupName)
{
byte[] header;
string ip_addr;
int port;
byte cmd;
int out_len;
byte store_path;
Connection connection;
if (trackerServer == null)
{
trackerServer = getTrackerServer();
}
connection = trackerServer.getConnection();
var outStream = connection.getOutputStream();
try
{
if (groupName == null || groupName.Length == 0)
{
cmd = ProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ONE;
out_len = 0;
}
else
{
cmd = ProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ONE;
out_len = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
}
header = ProtoCommon.packHeader(cmd, out_len, (byte)0);
outStream.Write(header, 0, header.Length);
if (groupName != null && groupName.Length > 0)
{
byte[] bGroupName;
byte[] bs;
int group_len;
bs = ClientGlobal.g_charset.GetBytes(groupName);
bGroupName = new byte[ProtoCommon.FDFS_GROUP_NAME_MAX_LEN];
if (bs.Length <= ProtoCommon.FDFS_GROUP_NAME_MAX_LEN)
{
group_len = bs.Length;
}
else
{
group_len = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
}
Arrays.fill(bGroupName, (byte)0);
Array.Copy(bs, 0, bGroupName, 0, group_len);
outStream.Write(bGroupName, 0, bGroupName.Length);
}
ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
ProtoCommon.TRACKER_PROTO_CMD_RESP,
ProtoCommon.TRACKER_QUERY_STORAGE_STORE_BODY_LEN);
this.errno = pkgInfo.errno;
if (pkgInfo.errno != 0)
{
return(null);
}
ip_addr = Strings.Get(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN, ProtoCommon.FDFS_IPADDR_SIZE - 1).Trim();
port = (int)ProtoCommon.buff2long(pkgInfo.body, ProtoCommon.FDFS_GROUP_NAME_MAX_LEN
+ ProtoCommon.FDFS_IPADDR_SIZE - 1);
store_path = pkgInfo.body[ProtoCommon.TRACKER_QUERY_STORAGE_STORE_BODY_LEN - 1];
return(new StorageServer(ip_addr, port, store_path));
}
catch (IOException ex)
{
try
{
connection.close();
}
catch (IOException ex1)
{
throw ex1;
}
finally
{
connection = null;
}
throw ex;
}
finally
{
if (connection != null)
{
try
{
connection.release();
}
catch
{
}
}
}
}
/**
* entry point
*
* @param args comand arguments
* <ul><li>args[0]: config filename</li></ul>
* <ul><li>args[1]: local filename to upload</li></ul>
*/
public static void main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Error: Must have 2 parameters, one is config filename, "
+ "the other is the local filename to upload");
return;
}
Console.WriteLine("dotnetcore.version=" + typeof(object).GetTypeInfo().Assembly.GetName().Version.ToString());
string conf_filename = args[0];
string local_filename = args[1];
try
{
ClientGlobal.init(conf_filename);
Console.WriteLine("network_timeout=" + ClientGlobal.g_network_timeout + "ms");
Console.WriteLine("charset=" + ClientGlobal.g_charset);
long startTime;
string group_name;
string remote_filename;
ServerInfo[] servers;
TrackerClient tracker = new TrackerClient();
TrackerServer trackerServer = tracker.getTrackerServer();
StorageServer storageServer = null;
/*
* storageServer = tracker.getStoreStorage(trackerServer);
* if (storageServer == null)
* {
* Console.WriteLine("getStoreStorage fail, error code: " + tracker.getErrorCode());
* return;
* }
*/
StorageClient client = new StorageClient(trackerServer, storageServer);
byte[] file_buff;
NameValuePair[] meta_list;
string[] results;
string master_filename;
string prefix_name;
string file_ext_name;
string generated_slave_filename;
int errno;
meta_list = new NameValuePair[4];
meta_list[0] = new NameValuePair("width", "800");
meta_list[1] = new NameValuePair("heigth", "600");
meta_list[2] = new NameValuePair("bgcolor", "#FFFFFF");
meta_list[3] = new NameValuePair("author", "Mike");
file_buff = ClientGlobal.g_charset.GetBytes("this is a test");
Console.WriteLine("file Length: " + file_buff.Length);
group_name = null;
StorageServer[] storageServers = tracker.getStoreStorages(trackerServer, group_name);
if (storageServers == null)
{
Log.Error("get store storage servers fail, error code: " + tracker.getErrorCode());
}
else
{
Log.Error("store storage servers count: " + storageServers.Length);
for (int k = 0; k < storageServers.Length; k++)
{
Log.Error((k + 1) + ". " + storageServers[k].getInetSocketAddress().Address + ":" + storageServers[k].getInetSocketAddress().Port);
}
Log.Error("");
}
startTime = DateTime.Now.Ticks;
results = client.upload_file(file_buff, "txt", meta_list);
Console.WriteLine("upload_file time used: " + (DateTime.Now.Ticks - startTime) + " ms");
/*
* group_name = "";
* results = client.upload_file(group_name, file_buff, "txt", meta_list);
*/
if (results == null)
{
Log.Error("upload file fail, error code: " + client.getErrorCode());
return;
}
else
{
group_name = results[0];
remote_filename = results[1];
Log.Error("group_name: " + group_name + ", remote_filename: " + remote_filename);
Log.Error(client.get_file_info(group_name, remote_filename).ToString());
servers = tracker.getFetchStorages(trackerServer, group_name, remote_filename);
if (servers == null)
{
Log.Error("get storage servers fail, error code: " + tracker.getErrorCode());
}
else
{
Log.Error("storage servers count: " + servers.Length);
for (int k = 0; k < servers.Length; k++)
{
Log.Error((k + 1) + ". " + servers[k].getIpAddr() + ":" + servers[k].getPort());
}
Log.Error("");
}
meta_list = new NameValuePair[4];
meta_list[0] = new NameValuePair("width", "1024");
meta_list[1] = new NameValuePair("heigth", "768");
meta_list[2] = new NameValuePair("bgcolor", "#000000");
meta_list[3] = new NameValuePair("title", "Untitle");
startTime = DateTime.Now.Ticks;
errno = client.set_metadata(group_name, remote_filename, meta_list, (byte)ProtoCommon.STORAGE_SET_METADATA_FLAG_MERGE);
Console.WriteLine("set_metadata time used: " + (DateTime.Now.Ticks - startTime) + " ms");
if (errno == 0)
{
Log.Error("set_metadata success");
}
else
{
Log.Error("set_metadata fail, error no: " + errno);
}
meta_list = client.get_metadata(group_name, remote_filename);
if (meta_list != null)
{
for (int i = 0; i < meta_list.Length; i++)
{
Console.WriteLine(meta_list[i].getName() + " " + meta_list[i].getValue());
}
}
//Thread.sleep(30000);
startTime = DateTime.Now.Ticks;
file_buff = client.download_file(group_name, remote_filename);
Console.WriteLine("download_file time used: " + (DateTime.Now.Ticks - startTime) + " ms");
if (file_buff != null)
{
Console.WriteLine("file Length:" + file_buff.Length);
Console.WriteLine(ClientGlobal.g_charset.GetString(file_buff));
}
file_buff = ClientGlobal.g_charset.GetBytes("this is a slave buff");
master_filename = remote_filename;
prefix_name = "-part1";
file_ext_name = "txt";
startTime = DateTime.Now.Ticks;
results = client.upload_file(group_name, master_filename, prefix_name, file_buff, file_ext_name, meta_list);
Console.WriteLine("upload_file time used: " + (DateTime.Now.Ticks - startTime) + " ms");
if (results != null)
{
Log.Error("slave file group_name: " + results[0] + ", remote_filename: " + results[1]);
generated_slave_filename = ProtoCommon.genSlaveFilename(master_filename, prefix_name, file_ext_name);
if (generated_slave_filename != results[1])
{
Log.Error("generated slave file: " + generated_slave_filename + "\n != returned slave file: " + results[1]);
}
Log.Error(client.get_file_info(results[0], results[1]).ToString());
}
startTime = DateTime.Now.Ticks;
errno = client.delete_file(group_name, remote_filename);
Console.WriteLine("delete_file time used: " + (DateTime.Now.Ticks - startTime) + " ms");
if (errno == 0)
{
Log.Error("Delete file success");
}
else
{
Log.Error("Delete file fail, error no: " + errno);
}
}
results = client.upload_file(local_filename, null, meta_list);
if (results != null)
{
string file_id;
int ts;
string token;
string file_url;
InetSocketAddress inetSockAddr;
group_name = results[0];
remote_filename = results[1];
file_id = group_name + StorageClient1.SPLIT_GROUP_NAME_AND_FILENAME_SEPERATOR + remote_filename;
inetSockAddr = trackerServer.getInetSocketAddress();
file_url = "http://" + inetSockAddr.Address;
if (ClientGlobal.g_tracker_http_port != 80)
{
file_url += ":" + ClientGlobal.g_tracker_http_port;
}
file_url += "/" + file_id;
if (ClientGlobal.g_anti_steal_token)
{
ts = (int)(DateTime.Now.Ticks / 1000);
token = ProtoCommon.getToken(file_id, ts, ClientGlobal.g_secret_key);
file_url += "?token=" + token + "&ts=" + ts;
}
Log.Error("group_name: " + group_name + ", remote_filename: " + remote_filename);
Log.Error(client.get_file_info(group_name, remote_filename).ToString());
Log.Error("file url: " + file_url);
errno = client.download_file(group_name, remote_filename, 0, 0, "c:\\" + remote_filename.Replace("/", "_"));
if (errno == 0)
{
Log.Error("Download file success");
}
else
{
Log.Error("Download file fail, error no: " + errno);
}
errno = client.download_file(group_name, remote_filename, 0, 0, new DownloadFileWriter("c:\\" + remote_filename.Replace("/", "-")));
if (errno == 0)
{
Log.Error("Download file success");
}
else
{
Log.Error("Download file fail, error no: " + errno);
}
master_filename = remote_filename;
prefix_name = "-part2";
file_ext_name = null;
startTime = DateTime.Now.Ticks;
results = client.upload_file(group_name, master_filename, prefix_name, local_filename, null, meta_list);
Console.WriteLine("upload_file time used: " + (DateTime.Now.Ticks - startTime) + " ms");
if (results != null)
{
Log.Error("slave file group_name: " + results[0] + ", remote_filename: " + results[1]);
generated_slave_filename = ProtoCommon.genSlaveFilename(master_filename, prefix_name, file_ext_name);
if (generated_slave_filename != results[1])
{
Log.Error("generated slave file: " + generated_slave_filename + "\n != returned slave file: " + results[1]);
}
Log.Error(client.get_file_info(results[0], results[1]).ToString());
}
}
System.IO.FileInfo f;
f = new System.IO.FileInfo(local_filename);
int nPos = local_filename.LastIndexOf('.');
if (nPos > 0 && local_filename.Length - nPos <= ProtoCommon.FDFS_FILE_EXT_NAME_MAX_LEN + 1)
{
file_ext_name = local_filename.Substring(nPos + 1);
}
else
{
file_ext_name = null;
}
results = client.upload_file(null, f.Length,
new UploadLocalFileSender(local_filename), file_ext_name, meta_list);
if (results != null)
{
group_name = results[0];
remote_filename = results[1];
Console.WriteLine("group name: " + group_name + ", remote filename: " + remote_filename);
Console.WriteLine(client.get_file_info(group_name, remote_filename));
master_filename = remote_filename;
prefix_name = "-part3";
startTime = DateTime.Now.Ticks;
results = client.upload_file(group_name, master_filename, prefix_name, f.Length, new UploadLocalFileSender(local_filename), file_ext_name, meta_list);
Console.WriteLine("upload_file time used: " + (DateTime.Now.Ticks - startTime) + " ms");
if (results != null)
{
Log.Error("slave file group_name: " + results[0] + ", remote_filename: " + results[1]);
generated_slave_filename = ProtoCommon.genSlaveFilename(master_filename, prefix_name, file_ext_name);
if (generated_slave_filename != results[1])
{
Log.Error("generated slave file: " + generated_slave_filename + "\n != returned slave file: " + results[1]);
}
Log.Error(client.get_file_info(results[0], results[1]).ToString());
}
}
else
{
Log.Error("Upload file fail, error no: " + errno);
}
storageServer = tracker.getFetchStorage(trackerServer, group_name, remote_filename);
if (storageServer == null)
{
Console.WriteLine("getFetchStorage fail, errno code: " + tracker.getErrorCode());
return;
}
/* for test only */
Console.WriteLine("active test to storage server: " + storageServer.getConnection().activeTest());
/* for test only */
Console.WriteLine("active test to tracker server: " + trackerServer.getConnection().activeTest());
}
catch (Exception ex)
{
Log.Error(ex.Message + ex.StackTrace);
}
}
/// <summary>
/// query storage servers to upload file
/// </summary>
/// <param name="trackerServer">the tracker server</param>
/// <param name="groupName">the group name to upload file to, can be empty</param>
/// <returns> storage servers, return null if fail</returns>
public StorageServer[] getStoreStorages(TrackerServer trackerServer, string groupName)
{
byte[] header;
string ip_addr;
int port;
byte cmd;
int out_len;
Connection connection;
if (trackerServer == null)
{
trackerServer = getTrackerServer();
if (trackerServer == null)
{
return(null);
}
}
connection = trackerServer.getConnection();
Stream outStream = connection.getOutputStream();
try
{
if (groupName == null || groupName.Length == 0)
{
cmd = ProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ALL;
out_len = 0;
}
else
{
cmd = ProtoCommon.TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ALL;
out_len = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
}
header = ProtoCommon.packHeader(cmd, out_len, (byte)0);
outStream.Write(header, 0, header.Length);
if (groupName != null && groupName.Length > 0)
{
byte[] bGroupName;
byte[] bs;
int group_len;
bs = ClientGlobal.g_charset.GetBytes(groupName);
bGroupName = new byte[ProtoCommon.FDFS_GROUP_NAME_MAX_LEN];
if (bs.Length <= ProtoCommon.FDFS_GROUP_NAME_MAX_LEN)
{
group_len = bs.Length;
}
else
{
group_len = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
}
Arrays.fill(bGroupName, (byte)0);
Array.Copy(bs, 0, bGroupName, 0, group_len);
outStream.Write(bGroupName, 0, bGroupName.Length);
}
ProtoCommon.RecvPackageInfo pkgInfo = ProtoCommon.recvPackage(connection.getInputStream(),
ProtoCommon.TRACKER_PROTO_CMD_RESP, -1);
this.errno = pkgInfo.errno;
if (pkgInfo.errno != 0)
{
return(null);
}
if (pkgInfo.body.Length < ProtoCommon.TRACKER_QUERY_STORAGE_STORE_BODY_LEN)
{
this.errno = ProtoCommon.ERR_NO_EINVAL;
return(null);
}
int ipPortLen = pkgInfo.body.Length - (ProtoCommon.FDFS_GROUP_NAME_MAX_LEN + 1);
const int recordLength = ProtoCommon.FDFS_IPADDR_SIZE - 1 + ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
if (ipPortLen % recordLength != 0)
{
this.errno = ProtoCommon.ERR_NO_EINVAL;
return(null);
}
int serverCount = ipPortLen / recordLength;
if (serverCount > 16)
{
this.errno = ProtoCommon.ERR_NO_ENOSPC;
return(null);
}
StorageServer[] results = new StorageServer[serverCount];
byte store_path = pkgInfo.body[pkgInfo.body.Length - 1];
int offset = ProtoCommon.FDFS_GROUP_NAME_MAX_LEN;
for (int i = 0; i < serverCount; i++)
{
ip_addr = Strings.Get(pkgInfo.body, offset, ProtoCommon.FDFS_IPADDR_SIZE - 1).Trim();
offset += ProtoCommon.FDFS_IPADDR_SIZE - 1;
port = (int)ProtoCommon.buff2long(pkgInfo.body, offset);
offset += ProtoCommon.FDFS_PROTO_PKG_LEN_SIZE;
results[i] = new StorageServer(ip_addr, port, store_path);
}
return(results);
}
catch (IOException ex)
{
try
{
connection.close();
}
catch (IOException ex1)
{
throw ex1;
}
finally
{
connection = null;
}
throw ex;
}
finally
{
if (connection != null)
{
try
{
connection.release();
}
catch
{
}
}
}
}