fdfs_monitor support delete empty group

HISTORY

@@ -6,6 +6,7 @@ Version 5.04  2014-08-24
    online / active and the storage status is wait_sync or syncing,
    the tracker adjust storage status to newer, and the storage rejoin
    to the tracker server
+ * fdfs_monitor support delete empty group
 
 Version 5.03  2014-08-10
  * network send and recv retry when error EINTR happen

client/fdfs_monitor.c

@@ -175,15 +175,26 @@ int main(int argc, char *argv[])
 	}
 	else if (strcmp(op_type, "delete") == 0)
 	{
-		char *storage_id;
 		if (arg_index >= argc)
 		{
-			usage(argv);
+		if ((result=tracker_delete_group(&g_tracker_group, \
-			return 1;
+				group_name)) == 0)
+		{
+			printf("delete group: %s success\n", \
+				group_name);
 		}
+		else
+		{
+			printf("delete group: %s fail, " \
+				"error no: %d, error info: %s\n", \
+				group_name, result, STRERROR(result));
+		}
+		}
+        else
+        {
+		char *storage_id;
 
 		storage_id = argv[arg_index++];
-
 		if ((result=tracker_delete_storage(&g_tracker_group, \
 				group_name, storage_id)) == 0)
 		{
@@ -198,6 +209,7 @@ int main(int argc, char *argv[])
 				result, STRERROR(result));
 		}
         }
+	}
 	else if (strcmp(op_type, "set_trunk_server") == 0)
 	{
 		char *storage_id;

client/tracker_client.c

@@ -1218,6 +1218,63 @@ int tracker_delete_storage(TrackerServerGroup *pTrackerGroup, \
 	return result == ENOENT ? 0 : result;
 }
 
+int tracker_delete_group(TrackerServerGroup *pTrackerGroup, \
+		const char *group_name)
+{
+	ConnectionInfo *conn;
+	TrackerHeader *pHeader;
+	ConnectionInfo tracker_server;
+	ConnectionInfo *pServer;
+	ConnectionInfo *pEnd;
+	char out_buff[sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN]; 
+	char in_buff[1];
+	char *pInBuff;
+	int64_t in_bytes;
+	int result;
+
+	memset(out_buff, 0, sizeof(out_buff));
+	pHeader = (TrackerHeader *)out_buff;
+	snprintf(out_buff + sizeof(TrackerHeader), sizeof(out_buff) - \
+			sizeof(TrackerHeader),  "%s", group_name);
+	
+	long2buff(FDFS_GROUP_NAME_MAX_LEN, pHeader->pkg_len);
+	pHeader->cmd = TRACKER_PROTO_CMD_SERVER_DELETE_GROUP;
+
+	result = 0;
+	pEnd = pTrackerGroup->servers + pTrackerGroup->server_count;
+	for (pServer=pTrackerGroup->servers; pServer<pEnd; pServer++)
+	{
+		memcpy(&tracker_server, pServer, sizeof(ConnectionInfo));
+		tracker_server.sock = -1;
+		if ((conn=tracker_connect_server(&tracker_server, &result)) == NULL)
+		{
+			return result;
+		}
+
+		if ((result=tcpsenddata_nb(conn->sock, out_buff, \
+			sizeof(TrackerHeader) + FDFS_GROUP_NAME_MAX_LEN,
+            g_fdfs_network_timeout)) != 0)
+		{
+			logError("file: "__FILE__", line: %d, " \
+				"send data to tracker server %s:%d fail, " \
+				"errno: %d, error info: %s", __LINE__, \
+				tracker_server.ip_addr, tracker_server.port, \
+				result, STRERROR(result));
+            break;
+		}
+
+        pInBuff = in_buff;
+        result = fdfs_recv_response(conn, &pInBuff, 0, &in_bytes);
+		tracker_disconnect_server_ex(conn, result != 0 && result != ENOENT);
+		if (result != 0)
+		{
+            break;
+		}
+	}
+
+	return result;
+}
+
 int tracker_set_trunk_server(TrackerServerGroup *pTrackerGroup, \
 		const char *group_name, const char *storage_id, \
 		char *new_trunk_server_id)

client/tracker_client.h

@@ -291,6 +291,16 @@ int tracker_delete_storage(TrackerServerGroup *pTrackerGroup, \
 		const char *group_name, const char *storage_id);
 
 
+/**
+* delete a group from cluster
+* params:
+*	pTrackerGroup: the tracker group
+*	group_name: the group name to delete
+* return: 0 success, !=0 fail, return the error code
+**/
+int tracker_delete_group(TrackerServerGroup *pTrackerGroup, \
+		const char *group_name);
+
 /**
 * set trunk server of the specified group
 * params:

tracker/tracker_mem.c

@@ -3373,6 +3373,87 @@ static void tracker_mem_clear_storage_fields(FDFSStorageDetail *pStorageServer)
 	memset(&(pStorageServer->stat), 0, sizeof(FDFSStorageStat));
 }
 
+static int tracker_mem_remove_group(FDFSGroupInfo **groups, FDFSGroupInfo *pGroup)
+{
+	FDFSGroupInfo **ppGroup;
+	FDFSGroupInfo **ppEnd;
+	FDFSGroupInfo **pp;
+
+    ppEnd = groups + g_groups.count;
+    for (ppGroup=groups; ppGroup<ppEnd; ppGroup++)
+    {
+        if (*ppGroup == pGroup)
+        {
+            break;
+        }
+    }
+
+    if (ppGroup == ppEnd)
+    {
+        return ENOENT;
+    }
+
+    for (pp=ppGroup + 1; pp<ppEnd; pp++)
+    {
+        *(pp - 1) = *pp;
+    }
+
+    return 0;
+}
+
+int tracker_mem_delete_group(const char *group_name)
+{
+    FDFSGroupInfo *pGroup;
+    int result;
+
+    pGroup = tracker_mem_get_group(group_name);
+    if (pGroup == NULL)
+    {
+        return ENOENT;
+    }
+
+    if (pGroup->count != 0)
+    {
+        return EBUSY;
+    }
+
+	pthread_mutex_lock(&mem_thread_lock);
+    if (pGroup->count != 0)
+    {
+        result = EBUSY;
+    }
+    else
+    {
+    result = tracker_mem_remove_group(g_groups.groups, pGroup);
+    if (result == 0)
+    {
+        result = tracker_mem_remove_group(g_groups.sorted_groups, pGroup);
+    }
+    }
+    if (result == 0)
+    {
+        if (g_groups.pStoreGroup == pGroup)
+        {
+            g_groups.pStoreGroup = NULL;
+        }
+        g_groups.count--;
+    }
+	pthread_mutex_unlock(&mem_thread_lock);
+
+    if (result != 0)
+    {
+        return result;
+    }
+
+    logDebug("file: "__FILE__", line: %d, " \
+            "delete empty group: %s", \
+            __LINE__, group_name);
+    sleep(1);
+    free(pGroup);
+
+    return tracker_save_groups();
+}
+
 int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
 {
 	FDFSStorageDetail *pStorageServer;
@@ -3408,6 +3489,11 @@ int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id)
 		}
 	}
 
+    logDebug("file: "__FILE__", line: %d, " \
+            "delete storage server: %s:%d, group: %s", \
+            __LINE__, pStorageServer->ip_addr,
+            pStorageServer->storage_port, pGroup->group_name);
+
 	tracker_mem_clear_storage_fields(pStorageServer);
 
 	pStorageServer->status = FDFS_STORAGE_STATUS_DELETED;

tracker/tracker_mem.h

@@ -68,6 +68,7 @@ FDFSStorageDetail *tracker_mem_get_storage_by_ip(FDFSGroupInfo *pGroup, \
 
 const FDFSStorageDetail *tracker_mem_set_trunk_server( \
 	FDFSGroupInfo *pGroup, const char *pStroageId, int *result);
+int tracker_mem_delete_group(const char *group_name);
 int tracker_mem_delete_storage(FDFSGroupInfo *pGroup, const char *id);
 
 int tracker_mem_storage_ip_changed(FDFSGroupInfo *pGroup, \

tracker/tracker_proto.h

@@ -56,6 +56,8 @@
 #define TRACKER_PROTO_CMD_SERVICE_QUERY_FETCH_ALL		105
 #define TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITHOUT_GROUP_ALL	106
 #define TRACKER_PROTO_CMD_SERVICE_QUERY_STORE_WITH_GROUP_ALL	107
+#define TRACKER_PROTO_CMD_SERVER_DELETE_GROUP			108
+
 #define TRACKER_PROTO_CMD_RESP					100
 #define FDFS_PROTO_CMD_ACTIVE_TEST				111  //active test, tracker and storage both support since V1.28
 

tracker/tracker_service.c

@@ -1395,6 +1395,30 @@ static int tracker_deal_storage_join(struct fast_task_info *pTask)
 	return 0;
 }
 
+static int tracker_deal_server_delete_group(struct fast_task_info *pTask)
+{
+	char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
+	int nPkgLen;
+
+	nPkgLen = pTask->length - sizeof(TrackerHeader);
+	pTask->length = sizeof(TrackerHeader);
+	if (nPkgLen != FDFS_GROUP_NAME_MAX_LEN)
+	{
+		logError("file: "__FILE__", line: %d, " \
+			"cmd=%d, client ip: %s, package size " \
+			PKG_LEN_PRINTF_FORMAT" is not correct, " \
+			"expect length: %d", __LINE__, \
+			TRACKER_PROTO_CMD_SERVER_DELETE_GROUP, \
+			pTask->client_ip, nPkgLen, FDFS_GROUP_NAME_MAX_LEN);
+		return EINVAL;
+	}
+
+	memcpy(group_name, pTask->data + sizeof(TrackerHeader), \
+			FDFS_GROUP_NAME_MAX_LEN);
+	group_name[FDFS_GROUP_NAME_MAX_LEN] = '\0';
+	return tracker_mem_delete_group(group_name);
+}
+
 static int tracker_deal_server_delete_storage(struct fast_task_info *pTask)
 {
 	char group_name[FDFS_GROUP_NAME_MAX_LEN + 1];
@@ -3649,6 +3673,9 @@ int tracker_deal_task(struct fast_task_info *pTask)
 		case TRACKER_PROTO_CMD_STORAGE_SYNC_DEST_QUERY:
 			result = tracker_deal_storage_sync_dest_query(pTask);
 			break;
+		case TRACKER_PROTO_CMD_SERVER_DELETE_GROUP:
+			result = tracker_deal_server_delete_group(pTask);
+			break;
 		case TRACKER_PROTO_CMD_SERVER_DELETE_STORAGE:
 			result = tracker_deal_server_delete_storage(pTask);
 			break;