mpdconsole.cpp

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

#include "mpdimpl.h"
#include "mpdutil.h"
#include <string.h>
#include <winsock2.h>
#include <windows.h>
#include "Service.h"
#include "database.h"
#include "GetStringOpt.h"
#include "Translate_Error.h"

#define TIMESTAMP_LENGTH 256

enum LaunchStatus
{
    LAUNCH_SUCCESS,
    LAUNCH_PENDING,
    LAUNCH_FAIL,
    LAUNCH_EXITED,
    LAUNCH_INVALID
};

struct LaunchStateStruct
{
    LaunchStateStruct();
    ~LaunchStateStruct();
    int nId;
    int nBfd;
    int nPid;
    LaunchStatus nStatus;
    char pszError[256];
    int nExitCode;
    bool bPidRequested;
    bool bExitStateRequested;
    char pszHost[MAX_HOST_LENGTH];
    char timestamp[TIMESTAMP_LENGTH];
    bool bMPIFinalized;
    HANDLE hMutex;
    LaunchStateStruct *pNext;
};

LaunchStateStruct::LaunchStateStruct()
{
    hMutex = CreateMutex(NULL, FALSE, NULL);
    nId = 0;
    nBfd = INVALID_SOCKET;
    nPid = -1;
    nStatus = LAUNCH_INVALID;
    pszError[0] = '\0';
    nExitCode = 0;
    bPidRequested = false;
    bExitStateRequested = false;
    pszHost[0] = '\0';
    timestamp[0] = '\0';
    bMPIFinalized = false;
    pNext = NULL;
}

LaunchStateStruct::~LaunchStateStruct()
{
    CloseHandle(hMutex);
}

int g_nCurrentLaunchId = 0;
LaunchStateStruct *g_pLaunchList = NULL;

static void LaunchToString(LaunchStateStruct *p, char *pszStr, int length)
{
    if (!snprintf_update(pszStr, length, "LAUNCH STRUCT:\n"))
	return;

    if (!snprintf_update(pszStr, length, " id: %d\n pid: %d\n host: %s\n sock: %d\n exitcode: %d\n status: ", 
	p->nId, p->nPid, p->pszHost, p->nBfd, p->nExitCode))
	return;
    switch (p->nStatus)
    {
    case LAUNCH_SUCCESS:
	if (!snprintf_update(pszStr, length, "LAUNCH_SUCCESS\n"))
	    return;
	break;
    case LAUNCH_PENDING:
	if (!snprintf_update(pszStr, length, "LAUNCH_PENDING\n"))
	    return;
	break;
    case LAUNCH_FAIL:
	if (!snprintf_update(pszStr, length, "LAUNCH_FAIL\n"))
	    return;
	break;
    case LAUNCH_EXITED:
	if (!snprintf_update(pszStr, length, "LAUNCH_EXITED\n"))
	    return;
	break;
    case LAUNCH_INVALID:
	if (!snprintf_update(pszStr, length, "LAUNCH_INVALID\n"))
	    return;
	break;
    default:
	if (!snprintf_update(pszStr, length, "unknown - %d\n", p->nStatus))
	    return;
	break;
    }
    if (p->bPidRequested)
    {
	if (!snprintf_update(pszStr, length, " bPidRequested = true\n"))
	    return;
    }
    if (p->bExitStateRequested)
    {
	if (!snprintf_update(pszStr, length, " bExitStateRequested = true\n"))
	    return;
    }
    if (strlen(p->pszError))
    {
	if (!snprintf_update(pszStr, length, " error: %s\n", p->pszError))
	    return;
    }
    if (strlen(p->timestamp))
    {
	if (!snprintf_update(pszStr, length, " timestamp: %s\n", p->timestamp))
	    return;
    }
}

void statLaunchList(char *pszOutput, int length)
{
    LaunchStateStruct *p;

    *pszOutput = '\0';
    length--; // leave room for the null character

    if (g_pLaunchList == NULL)
	return;

    p = g_pLaunchList;
    while (p)
    {
	LaunchToString(p, pszOutput, length);
	length = length - strlen(pszOutput);
	pszOutput = &pszOutput[strlen(pszOutput)];
	p = p->pNext;
    }
}

LaunchStateStruct* GetLaunchStruct(int nId)
{
    LaunchStateStruct *p = g_pLaunchList;
    while (p)
    {
	if (p->nId == nId)
	    return p;
	p = p->pNext;
    }
    return NULL;
}

int ConsoleGetExitCode(int nPid)
{
    LaunchStateStruct *pLS = GetLaunchStruct(nPid);
    if (pLS != NULL)
    {
	if (pLS->nStatus == LAUNCH_EXITED)
	{
	    return pLS->nExitCode;
	}
	return -1;
    }
    return -2;
}

bool RemoveStateStruct(LaunchStateStruct *p)
{
    bool bReturn;
    LaunchStateStruct *pTrailer = g_pLaunchList;

    // Remove p from the list
    if (p == NULL)
	return true;

    if (p == g_pLaunchList)
    {
	g_pLaunchList = g_pLaunchList->pNext;
	bReturn = true;
    }
    else
    {
	while (pTrailer && pTrailer->pNext != p)
	    pTrailer = pTrailer->pNext;
	if (pTrailer)
	{
	    pTrailer->pNext = p->pNext;
	    bReturn = true;
	}
	else
	{
	    bReturn = false;
	}
    }

    //dbg_printf("removing LaunchStateStruct[%d]\n", p->nId);
    // free the structure
    delete p;
    return bReturn;
}

void SavePid(int nId, int nPid)
{
    LaunchStateStruct *p;
    
    p = GetLaunchStruct(nId);

    if (p != NULL)
    {
	WaitForSingleObject(p->hMutex, INFINITE);
	p->nStatus = LAUNCH_SUCCESS;
	p->nPid = nPid;
	strcpy(p->pszError, "ERROR_SUCCESS");
	ReleaseMutex(p->hMutex);
	if (p->bPidRequested)
	{
	    char pszStr[20];
	    _snprintf(pszStr, 20, "%d", p->nPid);
	    easy_send(p->nBfd, pszStr, strlen(pszStr)+1);
	    p->bPidRequested = false;
	}
    }
}

void SaveError(int nId, char *pszError)
{
    LaunchStateStruct *p;
    
    p = GetLaunchStruct(nId);
    if (p != NULL)
    {
	WaitForSingleObject(p->hMutex, INFINITE);
	p->nStatus = LAUNCH_FAIL;
	strncpy(p->pszError, pszError, 256);
	ReleaseMutex(p->hMutex);
	if (p->bPidRequested)
	{
	    easy_send(p->nBfd, "-1", strlen("-1")+1);
	    p->bPidRequested = false;
	}
	if (p->bExitStateRequested)
	{
	    InformBarriers(nId, p->nExitCode);
	    easy_send(p->nBfd, "FAIL", strlen("FAIL")+1);
	    p->bExitStateRequested = false;
	}
    }
}

void SaveTimestamp(int nId, char *timestamp)
{
    LaunchStateStruct *p;
    
    p = GetLaunchStruct(nId);
    if (p != NULL)
    {
	WaitForSingleObject(p->hMutex, INFINITE);
	strncpy(p->timestamp, timestamp, TIMESTAMP_LENGTH);
	p->timestamp[TIMESTAMP_LENGTH-1] = '\0';
	ReleaseMutex(p->hMutex);
    }
}

bool SaveMPIFinalized(int nId)
{
    LaunchStateStruct *p;

    p = GetLaunchStruct(nId);
    if (p != NULL)
    {
	dbg_printf("setting mpifinalized for launchid %d\n", nId);
	p->bMPIFinalized = true;
	return true;
    }
    return false;
}

void SaveExitCode(int nId, int nExitCode)
{
    char pszStr[30];
    LaunchStateStruct *p;
    
    p = GetLaunchStruct(nId);
    if (p != NULL)
    {
	WaitForSingleObject(p->hMutex, INFINITE);
	p->nStatus = LAUNCH_EXITED;
	p->nExitCode = nExitCode;
	ReleaseMutex(p->hMutex);
	InformBarriers(nId, nExitCode);
	if (p->bExitStateRequested)
	{
	    _snprintf(pszStr, 30, "%d:%d", nExitCode, p->nPid);
	    easy_send(p->nBfd, pszStr, strlen(pszStr)+1);
	    p->bExitStateRequested = false;
	    dbg_printf("SaveExitCode:Sending exit code %d:%d:%s\n", nId, nExitCode, p->timestamp);
	}
    }
    else
    {
	err_printf("ERROR: Saving exit code for launchid %d failed\n", nId);
    }
}

void GetNameKeyValue(char *str, char *name, char *key, char *value)
{
    bool bName = false;
    bool bKey = false;
    bool bValue = false;

    //dbg_printf("GetNameKeyValue(");

    if ((name != NULL) && (!GetStringOpt(str, "name", name)))
    {
	bName = true;
    }
    /*
    else
    {
	if (name != NULL)
	{
	    dbg_printf("name='%s' ", name);
	}
    }
    */
    if ((key != NULL) && (!GetStringOpt(str, "key", key)))
    {
	bKey = true;
    }
    /*
    else
    {
	if (key != NULL)
	{
	    dbg_printf("key='%s' ", key);
	}
    }
    */
    if ((value != NULL) && (!GetStringOpt(str, "value", value)))
    {
	bValue = true;
    }
    /*
    else
    {
	if (value != NULL)
	{
	    dbg_printf("value='%s'", value);
	}
    }
    */

    char str2[MAX_CMD_LENGTH];
    char *token;
    if (bName)
    {
	strncpy(str2, str, MAX_CMD_LENGTH);
	str2[MAX_CMD_LENGTH-1] = '\0';
	token = strtok(str2, ":");
	if (token != NULL)
	{
	    strcpy(name, token);
	    //dbg_printf("name='%s' ", name);
	    if (bKey)
	    {
		token = strtok(NULL, ":");
		if (token != NULL)
		{
		    strcpy(key, token);
		    //dbg_printf("key='%s' ", key);
		    if (bValue)
		    {
			token = strtok(NULL, ":");
			if (token != NULL)
			{
			    strcpy(value, token);
			    //dbg_printf("value='%s'", value);
			}
		    }
		}
	    }
	}
    }
    else if (bKey)
    {
	strncpy(str2, str, MAX_CMD_LENGTH);
	str2[MAX_CMD_LENGTH-1] = '\0';
	token = strtok(str2, ":");
	if (token != NULL)
	{
	    strcpy(key, token);
	    //dbg_printf("key='%s' ", key);
	    if (bValue)
	    {
		token = strtok(NULL, ":");
		if (token != NULL)
		{
		    strcpy(value, token);
		    //dbg_printf("value='%s'", value);
		}
	    }
	}
    }
    else if (bValue)
    {
	strcpy(value, str);
	//dbg_printf("value='%s'", value);
    }

    //dbg_printf(")\n");

    //dbg_printf("GetNameKeyValue('%s' '%s' '%s')\n", name ? name : "NULL", key ? key : "NULL", value ? value : "NULL");
}

static void ParseAccountDomain(char *DomainAccount, char *tAccount, char *tDomain)
{
    char *pCh, *pCh2;
    
    pCh = DomainAccount;
    pCh2 = tDomain;
    while ((*pCh != '\\') && (*pCh != '\0'))
    {
	*pCh2 = *pCh;
	pCh++;
	pCh2++;
    }
    if (*pCh == '\\')
    {
	pCh++;
	strcpy(tAccount, pCh);
	*pCh2 = '\0';
    }
    else
    {
	strcpy(tAccount, DomainAccount);
	tDomain[0] = '\0';
    }
}

HANDLE BecomeUser(char *domainaccount, char *password, int *pnError)
{
    HANDLE hUser;
    char account[50], domain[50], *pszDomain;
    ParseAccountDomain(domainaccount, account, domain);
    if (strlen(domain) < 1)
	pszDomain = NULL;
    else
	pszDomain = domain;

    WaitForSingleObject(g_hLaunchMutex, 10000);

    if (!LogonUser(
	account,
	pszDomain, 
	password,
	LOGON32_LOGON_INTERACTIVE, 
	//LOGON32_LOGON_BATCH,  // quicker?
	LOGON32_PROVIDER_DEFAULT, 
	&hUser))
    {
	*pnError = GetLastError();
	ReleaseMutex(g_hLaunchMutex);
	return (HANDLE)-1;
    }

    if (!ImpersonateLoggedOnUser(hUser))
    {
	*pnError = GetLastError();
	CloseHandle(hUser);
	ReleaseMutex(g_hLaunchMutex);
	if (!g_bSingleUser)
	    RevertToSelf();
	return (HANDLE)-1;
    }

    ReleaseMutex(g_hLaunchMutex);

    return hUser;
}

FILE* CreateCheckFile(char *pszFullFileName, bool bReplace, bool bCreateDir, char *pszError)
{
    char pszPath[MAX_PATH];
    char *pszFileName, *p1, *p2;
    FILE *fout;

    if (bCreateDir)
    {
	if (!TryCreateDir(pszFullFileName, pszError))
	    return NULL;
    }
    strncpy(pszPath, pszFullFileName, MAX_PATH);
    p1 = strrchr(pszPath, '\\');
    p2 = strrchr(pszPath, '/');
    pszFileName = max(p1, p2);
    *pszFileName = '\0';
    pszFileName++;
    //dbg_printf("pszPath: '%s', pszFileName: '%s'\n", pszPath, pszFileName);
    if (!SetCurrentDirectory(pszPath))
    {
	sprintf(pszError, "SetCurrentDirectory(%s) failed, error %d", pszPath, GetLastError());
	return NULL;
    }

    if (bReplace)
    {
	fout = fopen(pszFileName, "wb");
    }
    else
    {
	fout = fopen(pszFileName, "r");
	if (fout != NULL)
	{
	    sprintf(pszError, "file exists");
	    fclose(fout);
	    return NULL;
	}
	fclose(fout);
	fout = fopen(pszFileName, "wb");
    }
    if (fout == NULL)
    {
	sprintf(pszError, "fopen failed, error %d", GetLastError());
	return NULL;
    }

    return fout;
}

HANDLE ParseBecomeUser(MPD_Context *p, char *pszInputStr, bool bMinusOneOnError)
{
    int nError;
    HANDLE hUser = NULL;

    if (!g_bSingleUser)
    {
	if (!p->bFileInitCalled)
	{
	    if (bMinusOneOnError)
		WriteString(p->sock, "-1");
	    WriteString(p->sock, "ERROR - no account and password provided");
	    return (HANDLE)-1;
	}
	hUser = BecomeUser(p->pszFileAccount, p->pszFilePassword, &nError);
	if (hUser == (HANDLE)-1)
	{
	    char pszStr[256];
	    Translate_Error(nError, pszStr, "ERROR - ");
	    if (bMinusOneOnError)
		WriteString(p->sock, "-1");
	    WriteString(p->sock, pszStr);
	    return (HANDLE)-1;
	}
    }
    return hUser;
}

void LoseTheUser(HANDLE hUser)
{
    if (!g_bSingleUser)
    {
	RevertToSelf();
	if (hUser != NULL)
	    CloseHandle(hUser);
    }
}

static void ConsolePutFile(SOCKET sock, char *pszInputStr)
{
    char pszFileName[MAX_PATH];
    int nLength;
    int nNumRead;
    FILE *fin;
    char pBuffer[TRANSFER_BUFFER_SIZE];
    char pszStr[256];
    int nError;

    // Get the file name
    if (!GetStringOpt(pszInputStr, "name", pszFileName))
    {
	WriteString(sock, "-1");