1272 lines
41 KiB
C
1272 lines
41 KiB
C
/*
|
||
* Copyright (c) 2018 Savens Liu
|
||
*
|
||
* The original has been patented, Open source is not equal to open rights.
|
||
* Anyone can clone, download, learn and discuss for free. Without the permission
|
||
* of the copyright owner or author, it shall not be merged, published, licensed or sold.
|
||
* The copyright owner or author has the right to pursue his responsibility.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
* POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
#include "tvm.h"
|
||
#include "tmain.h"
|
||
|
||
/*************************************************************************************************
|
||
global
|
||
*************************************************************************************************/
|
||
TBoot g_stBoot = {0};
|
||
|
||
/*************************************************************************************************
|
||
description：get the config of boot
|
||
parameters:
|
||
return:
|
||
void*
|
||
*************************************************************************************************/
|
||
void* pGetBoot()
|
||
{
|
||
return &g_stBoot;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：get log file
|
||
parameters:
|
||
return:
|
||
void*
|
||
*************************************************************************************************/
|
||
char* pGetLog()
|
||
{
|
||
return g_stBoot.m_szLog;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：Get the current node
|
||
parameters:
|
||
return:
|
||
void*
|
||
*************************************************************************************************/
|
||
char* sGetNode()
|
||
{
|
||
return g_stBoot.m_szNode;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：Set the current node
|
||
parameters:
|
||
return:
|
||
*************************************************************************************************/
|
||
void vSetNode(char *s)
|
||
{
|
||
if(!s) return ;
|
||
strncpy(g_stBoot.m_szNode, s, sizeof(g_stBoot.m_szNode));
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：Set STVM boot type
|
||
parameters:
|
||
return:
|
||
*************************************************************************************************/
|
||
void vSetBootType(long lType)
|
||
{
|
||
g_stBoot.m_lBootType = lType;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：Get current type of boot
|
||
parameters:
|
||
return:
|
||
lBootType
|
||
*************************************************************************************************/
|
||
long lGetBootType()
|
||
{
|
||
return g_stBoot.m_lBootType;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
函数说明：获取配置日志名称
|
||
参数说明：
|
||
返回值：
|
||
void --日志名
|
||
*************************************************************************************************/
|
||
char* sGetLog()
|
||
{
|
||
return g_stBoot.m_szLog;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：create default config
|
||
parameters:
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lDefaultBoot()
|
||
{
|
||
FILE *fp = NULL;
|
||
char szPath[512];
|
||
TBoot *pstBoot = (TBoot *)pGetBoot();
|
||
|
||
memset(szPath, 0, sizeof(szPath));
|
||
memset(pstBoot, 0, sizeof(TBoot));
|
||
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
|
||
|
||
pstBoot->m_lMaxTable = 255;
|
||
pstBoot->m_lMaxField = 3000;
|
||
pstBoot->m_lMaxDomain = 1024;
|
||
pstBoot->m_lMaxSeque = 1024;
|
||
pstBoot->m_lBootExec = get_nprocs();
|
||
pstBoot->m_lBootPort = 2000;
|
||
pstBoot->m_lBootType = TVM_BOOT_SIMPLE;
|
||
strcpy(pstBoot->m_szNode, "STVM");
|
||
strcpy(pstBoot->m_szLog, "stvm.log");
|
||
|
||
if(NULL == (fp = fopen(szPath, "wb")))
|
||
{
|
||
fprintf(stderr, "create default param failed, %s\n", strerror(errno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fwrite(TVM_RUNCFG_TAG, 4, 1, fp);
|
||
fwrite(pstBoot, sizeof(TBoot), 1, fp);
|
||
fclose(fp);
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：from the config to boot system
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
pstBoot --boot paramer
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lGetBootConfig(SATvm *pstSavm, TBoot *pstBoot)
|
||
{
|
||
FILE *fp = NULL;
|
||
char szPath[512], szVersion[10];
|
||
|
||
if(!pstSavm || !pstBoot)
|
||
{
|
||
pstSavm->m_lErrno = CONDIT_IS_NIL;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
memset(szPath, 0, sizeof(szPath));
|
||
memset(szVersion, 0, sizeof(szVersion));
|
||
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
|
||
if(NULL == (fp = fopen(szPath, "rb")))
|
||
{
|
||
pstSavm->m_lErrno = FILE_NOTFOUND;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(szVersion, 4, 1, fp);
|
||
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
|
||
{
|
||
fclose(fp);
|
||
pstSavm->m_lErrno = BOOT_VER_ICMP;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(pstBoot, sizeof(TBoot), 1, fp);
|
||
fclose(fp);
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description： Startup initialization
|
||
parameters:
|
||
return:
|
||
void *
|
||
*************************************************************************************************/
|
||
TBoot* pBootInitial()
|
||
{
|
||
static int i = 0;
|
||
SATvm *pstSavm = (SATvm *)pGetSATvm();
|
||
|
||
if(1 == i ++) return &g_stBoot;
|
||
|
||
memset(&g_stBoot, 0, sizeof(TBoot));
|
||
|
||
pstSavm->m_lErrno = TVM_DONE_SUCC;
|
||
lGetBootConfig(pstSavm, &g_stBoot);
|
||
|
||
return &g_stBoot;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：from the config to initial table index
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
plOut --number
|
||
ppstIndex --out of index group
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lGetLocalIndex(SATvm *pstSavm, long *plOut, TIndex **ppstIndex)
|
||
{
|
||
FILE *fp = NULL;
|
||
char szPath[512], szVersion[10];
|
||
|
||
if(!pstSavm || !ppstIndex || !plOut)
|
||
{
|
||
pstSavm->m_lErrno = CONDIT_IS_NIL;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
memset(szPath, 0, sizeof(szPath));
|
||
memset(szVersion, 0, sizeof(szVersion));
|
||
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
|
||
if(NULL == (fp = fopen(szPath, "rb")))
|
||
{
|
||
pstSavm->m_lErrno = FILE_NOTFOUND;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(szVersion, 4, 1, fp);
|
||
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
|
||
{
|
||
fclose(fp);
|
||
pstSavm->m_lErrno = BOOT_VER_ICMP;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fseek(fp, sizeof(TBoot), SEEK_CUR);
|
||
fread((void *)plOut, sizeof(long), 1, fp);
|
||
if(*plOut <= 0)
|
||
{
|
||
fclose(fp);
|
||
return RC_SUCC;
|
||
}
|
||
|
||
if(NULL == (*ppstIndex = (void *)calloc(*plOut, sizeof(TIndex))))
|
||
{
|
||
fclose(fp);
|
||
pstSavm->m_lErrno = MALLC_MEM_ERR;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(*ppstIndex, (*plOut) * sizeof(TIndex), 1, fp);
|
||
fclose(fp);
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：from the config to initial domain
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
plOut --number
|
||
ppstIndex --out of index group
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lGetDomainIndex(SATvm *pstSavm, long *plOut, TIndex **ppstIndex)
|
||
{
|
||
FILE *fp = NULL;
|
||
char szPath[512], szVersion[10];
|
||
|
||
if(!pstSavm || !ppstIndex || !plOut)
|
||
{
|
||
pstSavm->m_lErrno = CONDIT_IS_NIL;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
memset(szPath, 0, sizeof(szPath));
|
||
memset(szVersion, 0, sizeof(szVersion));
|
||
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
|
||
if(NULL == (fp = fopen(szPath, "rb")))
|
||
{
|
||
pstSavm->m_lErrno = FILE_NOTFOUND;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(szVersion, 4, 1, fp);
|
||
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
|
||
{
|
||
fclose(fp);
|
||
pstSavm->m_lErrno = BOOT_VER_ICMP;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fseek(fp, sizeof(TBoot), SEEK_CUR);
|
||
fread((void *)plOut, sizeof(long), 1, fp);
|
||
if(*plOut <= 0)
|
||
{
|
||
fclose(fp);
|
||
return RC_SUCC;
|
||
}
|
||
|
||
fseek(fp, (*plOut) * sizeof(TIndex), SEEK_CUR);
|
||
fread((void *)plOut, sizeof(long), 1, fp);
|
||
if(NULL == (*ppstIndex = (void *)calloc(*plOut, sizeof(TIndex))))
|
||
{
|
||
fclose(fp);
|
||
pstSavm->m_lErrno = MALLC_MEM_ERR;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(*ppstIndex, (*plOut) * sizeof(TIndex), 1, fp);
|
||
fclose(fp);
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：from the config to initial table of domain
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
plOut --number
|
||
ppstIndex --out of index group
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lGetDomainTable(SATvm *pstSavm, long *plOut, TDomain **ppstDomain)
|
||
{
|
||
FILE *fp = NULL;
|
||
char szPath[512], szVersion[10];
|
||
|
||
if(!pstSavm || !ppstDomain || !plOut)
|
||
{
|
||
pstSavm->m_lErrno = CONDIT_IS_NIL;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
memset(szPath, 0, sizeof(szPath));
|
||
memset(szVersion, 0, sizeof(szVersion));
|
||
snprintf(szPath, sizeof(szPath), "%s", getenv("TVMCFG"));
|
||
if(NULL == (fp = fopen(szPath, "rb")))
|
||
{
|
||
pstSavm->m_lErrno = FILE_NOTFOUND;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(szVersion, 4, 1, fp);
|
||
if(memcmp(szVersion, TVM_RUNCFG_TAG, 4))
|
||
{
|
||
fclose(fp);
|
||
pstSavm->m_lErrno = BOOT_VER_ICMP;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fseek(fp, sizeof(TBoot), SEEK_CUR);
|
||
fread((void *)plOut, sizeof(long), 1, fp);
|
||
fseek(fp, (*plOut) * sizeof(TIndex), SEEK_CUR);
|
||
fread((void *)plOut, sizeof(long), 1, fp);
|
||
fseek(fp, (*plOut) * sizeof(TIndex), SEEK_CUR);
|
||
fread((void *)plOut, sizeof(long), 1, fp);
|
||
if(*plOut <= 0)
|
||
{
|
||
fclose(fp);
|
||
return RC_SUCC;
|
||
}
|
||
|
||
if(NULL == (*ppstDomain = (void *)calloc(*plOut, sizeof(TDomain))))
|
||
{
|
||
fclose(fp);
|
||
pstSavm->m_lErrno = MALLC_MEM_ERR;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fread(*ppstDomain, (*plOut) * sizeof(TDomain), 1, fp);
|
||
fclose(fp);
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：parse config field
|
||
parameters:
|
||
pszBuffer --file content
|
||
pszTarg --target
|
||
nTarg --target length
|
||
pszValue --The label value
|
||
nValue --value max length
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lPraseField(char *pszBuffer, char *pszTarg, long nTarg, char *pszValue, long nValue)
|
||
{
|
||
char szAttr[512];
|
||
|
||
memset(szAttr, 0, sizeof(szAttr));
|
||
strncpy(szAttr, pszBuffer, sizeof(szAttr));
|
||
if(!strstr(szAttr, "="))
|
||
{
|
||
fprintf(stdout, "%s\n*may be lost '='\n", szAttr);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
strncpy(pszTarg, sgetvalue(szAttr, "=", 1), nTarg);
|
||
strncpy(pszValue, sgetvalue(szAttr, "=", 2), nValue);
|
||
srtrim(pszTarg);
|
||
sltrim(pszValue);
|
||
strimabout(pszValue, "\"", "\"");
|
||
if(!strlen(pszValue))
|
||
{
|
||
fprintf(stdout, "%s\n*config error, The initial value is not set\n", szAttr);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：from the config to initial table index
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
ppstRoot --content list
|
||
pszFile --config file
|
||
pszTarge --target
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long _lParseFile(SATvm *pstSavm, CMList **ppstRoot, char *pszFile, const char *pszTarget)
|
||
{
|
||
FILE *fp = NULL;
|
||
char szLine[4098];
|
||
bool bFlag = false;
|
||
CMList *pstList = NULL;
|
||
|
||
if(NULL == (fp = fopen(pszFile, "rb")))
|
||
{
|
||
pstSavm->m_lErrno = FILE_NOTFOUND;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
memset(szLine, 0, sizeof(szLine));
|
||
while(fgets(szLine, sizeof(szLine), fp))
|
||
{
|
||
strimcrlf(szLine);
|
||
sltrim(szLine);
|
||
srtrim(szLine);
|
||
if(!strlen(szLine))
|
||
continue;
|
||
|
||
if('#' == szLine[0] || !memcmp("//", szLine, 2) || !memcmp("/*", szLine, 2) ||
|
||
!memcmp("＃", szLine, 2) || !memcmp("--", szLine, 2))
|
||
continue;
|
||
|
||
if(!strcmp(pszTarget, szLine) && !bFlag)
|
||
{
|
||
bFlag = true;
|
||
memset(szLine, 0, sizeof(szLine));
|
||
continue;
|
||
}
|
||
else if(szLine[0] == '*' && bFlag)
|
||
break;
|
||
|
||
if(!bFlag)
|
||
{
|
||
memset(szLine, 0, sizeof(szLine));
|
||
continue;
|
||
}
|
||
|
||
if(NULL == (pstList = pInsertList(pstList, (void *)szLine, sizeof(szLine))))
|
||
{
|
||
fclose(fp);
|
||
vDestroyList(pstList);
|
||
return RC_FAIL;
|
||
}
|
||
}
|
||
|
||
fclose(fp);
|
||
*ppstRoot = pstList;
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：parse STVM boot parameter
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
pszFile --config file
|
||
pstBoot --target
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lParseBoot(SATvm *pstSavm, char *pszFile, TBoot *pstBoot)
|
||
{
|
||
char szTarg[128], szValue[64];
|
||
CMList *pstNode = NULL, *pstRoot = NULL;
|
||
|
||
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*GLOBLE"))
|
||
{
|
||
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
for(pstNode = pstRoot; pstNode; pstNode = pstNode->pstNext)
|
||
{
|
||
memset(szTarg, 0, sizeof(szTarg));
|
||
memset(szValue, 0, sizeof(szValue));
|
||
if(RC_SUCC != lPraseField((char *)pstNode->m_psvData, szTarg, sizeof(szTarg), szValue,
|
||
sizeof(szValue)))
|
||
goto PBOOT_ERROR;
|
||
|
||
if(!strcasecmp(szTarg, "MACHINE"))
|
||
strncpy(pstBoot->m_szNode, szValue, sizeof(pstBoot->m_szNode));
|
||
else if(!strcasecmp(szTarg, "LOGNAME"))
|
||
strncpy(pstBoot->m_szLog, szValue, sizeof(pstBoot->m_szLog));
|
||
else if(!strcasecmp(szTarg, "DEPLOY"))
|
||
{
|
||
if(!strcasecmp(szValue, "cluster"))
|
||
pstBoot->m_lBootType = TVM_BOOT_CLUSTER;
|
||
else if(!strcasecmp(szValue, "local"))
|
||
pstBoot->m_lBootType = TVM_BOOT_LOCAL;
|
||
else // local
|
||
pstBoot->m_lBootType = TVM_BOOT_SIMPLE;
|
||
}
|
||
else if(!strcasecmp(szTarg, "MAXTABLE"))
|
||
{
|
||
pstBoot->m_lMaxTable = atol(szValue);
|
||
if(pstBoot->m_lMaxTable <= 5)
|
||
{
|
||
fprintf(stdout, "%s\n*Set STVM maximum support table number error\n",
|
||
(char *)pstNode->m_psvData);
|
||
}
|
||
else if(pstBoot->m_lMaxTable > 255)
|
||
{
|
||
fprintf(stdout, "%s\n*STVM maximum support table 255\n",
|
||
(char *)pstNode->m_psvData);
|
||
goto PBOOT_ERROR;
|
||
}
|
||
}
|
||
else if(!strcasecmp(szTarg, "MAXFILED"))
|
||
{
|
||
pstBoot->m_lMaxField = atol(szValue);
|
||
if(pstBoot->m_lMaxField <= 100)
|
||
{
|
||
fprintf(stdout, "%s\n*Set the number of STVM field details error\n",
|
||
(char *)pstNode->m_psvData);
|
||
goto PBOOT_ERROR;
|
||
}
|
||
}
|
||
else if(!strcasecmp(szTarg, "MAXDOMAIN"))
|
||
{
|
||
pstBoot->m_lMaxDomain = atol(szValue);
|
||
if(pstBoot->m_lMaxDomain <= 0)
|
||
{
|
||
fprintf(stdout, "%s\n*Error in setting maximum number of domain\n",
|
||
(char *)pstNode->m_psvData);
|
||
goto PBOOT_ERROR;
|
||
}
|
||
}
|
||
else if(!strcasecmp(szTarg, "MAXSEQUE"))
|
||
{
|
||
pstBoot->m_lMaxSeque = atol(szValue);
|
||
if(pstBoot->m_lMaxSeque <= 0)
|
||
{
|
||
fprintf(stdout, "%s\n*Error in setting maximum number of sequences\n",
|
||
(char *)pstNode->m_psvData);
|
||
goto PBOOT_ERROR;
|
||
}
|
||
}
|
||
else if(!strcasecmp(szTarg, "SERVER_EXEC"))
|
||
{
|
||
pstBoot->m_lBootExec = atol(szValue);
|
||
if(pstBoot->m_lBootExec <= 0)
|
||
{
|
||
fprintf(stdout, "%s\n*LIS.tvm: startup number set error",
|
||
(char *)pstNode->m_psvData);
|
||
goto PBOOT_ERROR;
|
||
}
|
||
}
|
||
else if(!strcasecmp(szTarg, "SERVER_PORT"))
|
||
{
|
||
pstBoot->m_lBootPort = atol(szValue);
|
||
if(pstBoot->m_lBootPort <= 0)
|
||
{
|
||
fprintf(stdout, "%s\n*LIS.tvm: Error starting port setting\n",
|
||
(char *)pstNode->m_psvData);
|
||
goto PBOOT_ERROR;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
fprintf(stdout, "%s\n*Invalid parameter\n", (char *)pstNode->m_psvData);
|
||
goto PBOOT_ERROR;
|
||
}
|
||
}
|
||
|
||
if(!strlen(pstBoot->m_szNode))
|
||
{
|
||
fprintf(stdout, "MACHINE\n*The local node is not set\n");
|
||
goto PBOOT_ERROR;
|
||
}
|
||
|
||
if(pstBoot->m_lMaxTable <= 0)
|
||
pstBoot->m_lMaxTable = TVM_MAX_TABLE;
|
||
if(pstBoot->m_lMaxField <= 0)
|
||
pstBoot->m_lMaxField = 3000;
|
||
if(pstBoot->m_lMaxDomain <= 0)
|
||
pstBoot->m_lMaxDomain = 500;
|
||
if(pstBoot->m_lMaxSeque <= 0)
|
||
pstBoot->m_lMaxSeque = 500;
|
||
if(pstBoot->m_lBootExec <= 0)
|
||
pstBoot->m_lBootExec = get_nprocs() > 0 ? get_nprocs() : 1;
|
||
if(pstBoot->m_lBootPort <= 0)
|
||
pstBoot->m_lBootPort = TVM_PORT_LISTEN;
|
||
|
||
vDestroyList(pstRoot);
|
||
|
||
return RC_SUCC;
|
||
|
||
PBOOT_ERROR:
|
||
vDestroyList(pstRoot);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：get config domain resource
|
||
parameters:
|
||
lDomain --number of domain
|
||
pstDomain --domain group
|
||
pszDomain --domain
|
||
return:
|
||
void* --domain
|
||
*************************************************************************************************/
|
||
TDomain* pGetResourse(long lDomain, TDomain *pstDomain, char *pszDomain)
|
||
{
|
||
long i = 0;
|
||
|
||
for(i = 0; i < lDomain; i ++)
|
||
{
|
||
if(!strcmp(pstDomain[i].m_szOwner, pszDomain))
|
||
return &pstDomain[i];
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：parse local table config
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
pszFile --config
|
||
plOut --number
|
||
ppstIndex --out of index group
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lParseIndex(SATvm *pstSavm, char *pszFile, long *plOut, TIndex **ppstIndex)
|
||
{
|
||
long i, j, n;
|
||
TIndex *pstIndex = NULL;
|
||
CMList *pstNode = NULL, *pstRoot = NULL;
|
||
char szTarg[128], szValue[64], szAttr[1024];
|
||
|
||
memset(szTarg, 0, sizeof(szTarg));
|
||
memset(szAttr, 0, sizeof(szAttr));
|
||
memset(szValue, 0, sizeof(szValue));
|
||
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*LOCAL_RESOURCE"))
|
||
{
|
||
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
for(pstNode = pstRoot, j = 0; pstNode; pstNode = pstNode->pstNext)
|
||
{
|
||
sfieldreplace((char *)pstNode->m_psvData, '\t', ' ');
|
||
if(!strlen((char *)pstNode->m_psvData)) continue;
|
||
|
||
if(NULL == (pstIndex = (TIndex *)realloc(pstIndex, (++ j) * sizeof(TIndex))))
|
||
{
|
||
pstSavm->m_lErrno = MALLC_MEM_ERR;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
memset(&pstIndex[j - 1], 0, sizeof(TIndex));
|
||
for(i = 0, n = lfieldnum((char *)pstNode->m_psvData, " "); i < n; i ++)
|
||
{
|
||
memset(szTarg, 0, sizeof(szTarg));
|
||
memset(szValue, 0, sizeof(szValue));
|
||
if(RC_SUCC != lPraseField(sfieldvalue((char *)pstNode->m_psvData, " ", i + 1),
|
||
szTarg, sizeof(szTarg), szValue, sizeof(szValue)))
|
||
goto PINDEX_ERROR;
|
||
|
||
if(!strcasecmp(szTarg, "TABLE"))
|
||
pstIndex[j - 1].m_table = atol(szValue);
|
||
else if(!strcasecmp(szTarg, "PERMIT"))
|
||
pstIndex[j - 1].m_lPers = atol(szValue);
|
||
else
|
||
{
|
||
fprintf(stdout, "%s\n*Invalid parameter\n", (char *)pstNode->m_psvData);
|
||
goto PINDEX_ERROR;
|
||
}
|
||
}
|
||
|
||
if(pstIndex[j - 1].m_table <= 0)
|
||
{
|
||
fprintf(stdout, "%s\n*Table setting error\n", (char *)pstNode->m_psvData);
|
||
goto PINDEX_ERROR;
|
||
}
|
||
|
||
if(pstIndex[j - 1].m_lPers <= 0)
|
||
pstIndex[j - 1].m_lPers = OPERATE_DEFAULT;
|
||
}
|
||
*plOut = j;
|
||
*ppstIndex = pstIndex;
|
||
|
||
vDestroyList(pstRoot);
|
||
return RC_SUCC;
|
||
|
||
PINDEX_ERROR:
|
||
TFree(*ppstIndex);
|
||
vDestroyList(pstRoot);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：parse domain
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
pszFile --config
|
||
plCount --number
|
||
ppstDom --out of domain group
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lParseResouce(SATvm *pstSavm, char *pszFile, long *plCout, TDomain **ppstDom)
|
||
{
|
||
TDomain *pv;
|
||
long i, n;
|
||
char szTarg[128], szValue[64];
|
||
CMList *pstNode = NULL, *pstRoot = NULL;
|
||
|
||
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*REMOTE_DOMAIN"))
|
||
{
|
||
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
for(pstNode = pstRoot, *plCout = 0; pstNode; pstNode = pstNode->pstNext)
|
||
{
|
||
sfieldreplace((char *)pstNode->m_psvData, '\t', ' ');
|
||
if(!strlen((char *)pstNode->m_psvData)) continue;
|
||
|
||
if(NULL == (*ppstDom = (TDomain *)realloc(*ppstDom, (++ (*plCout)) * sizeof(TDomain))))
|
||
{
|
||
pstSavm->m_lErrno = MALLC_MEM_ERR;
|
||
return RC_FAIL;
|
||
}
|
||
|
||
pv = &(*ppstDom)[(*plCout) - 1];
|
||
memset(pv, 0, sizeof(TDomain));
|
||
for(i = 0, n = lfieldnum((char *)pstNode->m_psvData, " "); i < n; i ++)
|
||
{
|
||
memset(szTarg, 0, sizeof(szTarg));
|
||
memset(szValue, 0, sizeof(szValue));
|
||
if(RC_SUCC != lPraseField(sfieldvalue((char *)pstNode->m_psvData, " ", i + 1),
|
||
szTarg, sizeof(szTarg), szValue, sizeof(szValue)))
|
||
goto PDOMAIN_ERROR;
|
||
|
||
if(!strcasecmp(szTarg, "DOMAINID"))
|
||
strncpy(pv->m_szOwner, szValue, sizeof(pv->m_szOwner));
|
||
else if(!strcasecmp(szTarg, "GROUP"))
|
||
pv->m_lGroup = atol(szValue);
|
||
else if(!strcasecmp(szTarg, "WSADDR"))
|
||
{
|
||
strncpy(pv->m_szIp, sgetvalue(szValue, ":", 1), sizeof(pv->m_szIp));
|
||
pv->m_lPort = atol(sgetvalue(szValue, ":", 2));
|
||
}
|
||
else if(!strcasecmp(szTarg, "TIMTOUT"))
|
||
pv->m_lTimeOut = atol(szValue);
|
||
else if(!strcasecmp(szTarg, "MAXTRY"))
|
||
pv->m_lTryMax = atol(szValue);
|
||
else if(!strcasecmp(szTarg, "KEEPALIVE"))
|
||
pv->m_lKeepLive = atol(szValue);
|
||
}
|
||
|
||
if(!strlen(pv->m_szOwner))
|
||
{
|
||
fprintf(stdout, "%s\n*域名未设置\n", (char *)pstNode->m_psvData);
|
||
goto PDOMAIN_ERROR;
|
||
}
|
||
|
||
if(!strlen(pv->m_szIp))
|
||
{
|
||
fprintf(stdout, "%s\n*域地址未设置\n", (char *)pstNode->m_psvData);
|
||
goto PDOMAIN_ERROR;
|
||
}
|
||
|
||
if(pv->m_lPort <= 0)
|
||
{
|
||
fprintf(stdout, "%s\n*The domain port is set incorrectly or unset\n",
|
||
(char *)pstNode->m_psvData);
|
||
goto PDOMAIN_ERROR;
|
||
}
|
||
|
||
pv->m_lGroup = pv->m_lGroup > 0 ? pv->m_lGroup : 1;
|
||
pv->m_lTimeOut = pv->m_lTimeOut > 0 ? pv->m_lTimeOut : 5;
|
||
pv->m_lTryMax = pv->m_lTryMax > 0 ? pv->m_lTryMax : 3;
|
||
pv->m_lKeepLive= pv->m_lKeepLive > 0 ? pv->m_lKeepLive : 30;
|
||
}
|
||
TFlst(pstRoot);
|
||
return RC_SUCC;
|
||
|
||
PDOMAIN_ERROR:
|
||
TFree(*ppstDom);
|
||
TFlst(pstRoot);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：parse the table of domain
|
||
parameters:
|
||
pszNode --node
|
||
pszBuffer --content
|
||
plOut --number
|
||
ppIndx --out of index
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lParseTable(char *pszNode, char *pszBuffer, long *plOut, TIndex **ppIndx)
|
||
{
|
||
long i, n;
|
||
TIndex *pv = NULL;
|
||
char szTarg[128], szValue[64];
|
||
|
||
if(NULL == (*ppIndx = (TIndex *)realloc(*ppIndx, (++ (*plOut)) * sizeof(TIndex))))
|
||
return RC_FAIL;
|
||
|
||
pv = &(*ppIndx)[(*plOut) - 1];
|
||
memset(pv, 0, sizeof(TIndex));
|
||
sfieldreplace(pszBuffer, '\t', ' ');
|
||
for(i = 0, n = lfieldnum(pszBuffer, " "); i < n; i ++)
|
||
{
|
||
memset(szTarg, 0, sizeof(szTarg));
|
||
memset(szValue, 0, sizeof(szValue));
|
||
if(RC_SUCC != lPraseField(sfieldvalue(pszBuffer, " ", i + 1), szTarg, sizeof(szTarg),
|
||
szValue, sizeof(szValue)))
|
||
return RC_FAIL;
|
||
|
||
if(!strcasecmp(szTarg, "TABLE"))
|
||
pv->m_table = atol(szValue);
|
||
else if(!strcasecmp(szTarg, "TABLENAME"))
|
||
strncpy(pv->m_szTable, szValue, sizeof(pv->m_szTable));
|
||
else if(!strcasecmp(szTarg, "PART"))
|
||
strncpy(pv->m_szPart, szValue, sizeof(pv->m_szPart));
|
||
|
||
if(!strlen(pv->m_szPart))
|
||
strcpy(pv->m_szPart, pszNode);
|
||
strcpy(pv->m_szOwner, pszNode);
|
||
}
|
||
pv->m_lLocal = RES_REMOT_SID;
|
||
pv->m_lPers = OPERATE_NULL;
|
||
pv->m_lType = TYPE_CLIENT;
|
||
strncpy(pv->m_szTime, sGetUpdTime(), sizeof(pv->m_szTime));
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：parse domain resource
|
||
parameters:
|
||
pszBuffer --content
|
||
pstIndex --index
|
||
pstDom --domain
|
||
plDom --number
|
||
ppstDom --domain list
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lParseDomain(char *pszBuffer, TIndex *pstIndex, TDomain *pstDom, long *plDom,
|
||
TDomain **ppstDom)
|
||
{
|
||
long i, n;
|
||
TDomain *pv = NULL;
|
||
char szTarg[128], szValue[64];
|
||
|
||
if(NULL == (*ppstDom = (TDomain *)realloc(*ppstDom, (++ (*plDom)) * sizeof(TDomain))))
|
||
return RC_FAIL;
|
||
|
||
pv = &(*ppstDom)[(*plDom) - 1];
|
||
memset(pv, 0, sizeof(TDomain));
|
||
for(i = 0, n = lfieldnum(pszBuffer, " "); i < n; i ++)
|
||
{
|
||
memset(szTarg, 0, sizeof(szTarg));
|
||
memset(szValue, 0, sizeof(szValue));
|
||
if(RC_SUCC != lPraseField(sfieldvalue(pszBuffer, " ", i + 1), szTarg, sizeof(szTarg),
|
||
szValue, sizeof(szValue)))
|
||
return RC_FAIL;
|
||
|
||
if(!strcasecmp(szTarg, "MTABLE"))
|
||
pv->m_mtable = atol(szValue);
|
||
else if(!strcasecmp(szTarg, "DOMAINID"))
|
||
strncpy(pv->m_szOwner, szValue, sizeof(pv->m_szOwner));
|
||
else
|
||
{
|
||
fprintf(stdout, "%s\n*Invalid parameter\n", pszBuffer);
|
||
return RC_FAIL;
|
||
}
|
||
}
|
||
|
||
pv->m_lTryMax = 0;
|
||
pv->m_lLastTime = 0;
|
||
pv->m_lStatus = RESOURCE_INIT;
|
||
pv->m_table = pstIndex->m_table;
|
||
pv->m_lPort = pstDom->m_lPort;
|
||
pv->m_lGroup = pstDom->m_lGroup;
|
||
pv->m_lKeepLive = pstDom->m_lKeepLive;
|
||
pv->m_lTimeOut = pstDom->m_lTimeOut;
|
||
pv->m_lTryMax = pstDom->m_lTryMax;
|
||
strcpy(pv->m_szIp, pstDom->m_szIp);
|
||
strcpy(pv->m_szTable, pstIndex->m_szTable);
|
||
strcpy(pv->m_szOwner, pstDom->m_szOwner);
|
||
if(!strlen(pv->m_szPart))
|
||
strcpy(pv->m_szPart, pstDom->m_szOwner);
|
||
|
||
return RC_SUCC;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：parse domain table of remote
|
||
parameters:
|
||
pstSavm --stvm handle
|
||
pszFile --config
|
||
pstBoot --boot paramter
|
||
plOut --number of index
|
||
ppstIndex --out of index list
|
||
plDom --number of domain
|
||
ppstDom --out of domain list
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lParseRemote(SATvm *pstSavm, char *pszFile, TBoot *pstBoot, long *plOut, TIndex **ppstIndex,
|
||
long *plDom, TDomain **ppstDom)
|
||
{
|
||
long i, lResource;
|
||
TIndex *pv = NULL;
|
||
CMList *pstNode = NULL, *pstRoot = NULL;
|
||
TDomain *pstRes = NULL, *pstResouce = NULL;
|
||
char szTarg[128], szValue[64], *p = NULL;
|
||
|
||
if(RC_SUCC != lParseResouce(pstSavm, pszFile, &lResource, &pstResouce))
|
||
return RC_FAIL;
|
||
|
||
if(RC_SUCC != _lParseFile(pstSavm, &pstRoot, pszFile, "*REMOTE_TABLE"))
|
||
{
|
||
fprintf(stderr, "parse file, err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
if(!pstRoot)
|
||
{
|
||
for(i = 0; i < lResource; i ++)
|
||
{
|
||
pstResouce[i].m_table = SYS_TVM_INDEX;
|
||
pstResouce[i].m_mtable = SYS_TVM_INDEX;
|
||
strcpy(pstResouce[i].m_szTable, "SYS_TVM_INDEX");
|
||
strcpy(pstResouce[i].m_szPart, pstResouce[i].m_szOwner);
|
||
}
|
||
|
||
*plOut = 0;
|
||
*ppstIndex = NULL;
|
||
*plDom = lResource;
|
||
*ppstDom = pstResouce;
|
||
return RC_SUCC;
|
||
}
|
||
else
|
||
{
|
||
for(pstNode = pstRoot, *plDom = 0, *plOut = 0; pstNode; pstNode = pstNode->pstNext)
|
||
{
|
||
sfieldreplace((char *)pstNode->m_psvData, '\t', ' ');
|
||
if(!strncmp((char *)pstNode->m_psvData, "TABLE", 5))
|
||
{
|
||
if(RC_SUCC != lParseTable(pstBoot->m_szNode, (char *)pstNode->m_psvData,
|
||
plOut, ppstIndex))
|
||
goto PREMOTE_ERROR;
|
||
pv = &(*ppstIndex)[(*plOut) - 1];
|
||
continue;
|
||
}
|
||
|
||
if(NULL == (p = strstr((char *)pstNode->m_psvData, "DOMAINID")))
|
||
{
|
||
fprintf(stderr, "set error:%s\n", (char *)pstNode->m_psvData);
|
||
goto PREMOTE_ERROR;
|
||
}
|
||
|
||
if(NULL == (pstRes = pGetResourse(lResource, pstResouce,
|
||
strimabout(sfieldvalue(p, "=", 2), "\"", "\""))))
|
||
{
|
||
fprintf(stderr, "No domain (%s) is found\n", sfieldvalue(p, "=", 2));
|
||
goto PREMOTE_ERROR;
|
||
}
|
||
|
||
if(RC_SUCC != lParseDomain((char *)pstNode->m_psvData, pv, pstRes, plDom, ppstDom))
|
||
{
|
||
TFlst(pstRoot);
|
||
return RC_FAIL;
|
||
}
|
||
}
|
||
}
|
||
TFree(pstResouce);
|
||
TFlst(pstRoot);
|
||
|
||
return RC_SUCC;
|
||
|
||
PREMOTE_ERROR:
|
||
TFlst(pstRoot);
|
||
TFree(*ppstIndex);
|
||
TFree(pstResouce);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：Domain uniqueness checks
|
||
parameters:
|
||
lCount --number
|
||
pstDomain --domain list
|
||
return:
|
||
true --repeat
|
||
false
|
||
*************************************************************************************************/
|
||
bool bDomIsRepeat(long lCount, TDomain *pstDomain)
|
||
{
|
||
int i, j;
|
||
|
||
for(i = 0; i < lCount; i ++)
|
||
{
|
||
for(j = 0; j < lCount; j ++)
|
||
{
|
||
if(i == j) continue;
|
||
|
||
if(pstDomain[i].m_lPort == pstDomain[j].m_lPort &&
|
||
!strcmp(pstDomain[i].m_szIp, pstDomain[j].m_szIp) &&
|
||
!strcmp(pstDomain[i].m_szPart, pstDomain[j].m_szPart) &&
|
||
!strcmp(pstDomain[i].m_szTable, pstDomain[j].m_szTable))
|
||
{
|
||
if(SYS_TVM_INDEX == pstDomain[i].m_table)
|
||
{
|
||
fprintf(stderr, "*domain(%s)(%s:%ld)repeate\n", pstDomain[i].m_szOwner,
|
||
pstDomain[i].m_szIp, pstDomain[i].m_lPort);
|
||
}
|
||
else
|
||
{
|
||
fprintf(stderr, "*table(%s)(%s)repeate\n", pstDomain[i].m_szTable,
|
||
pstDomain[i].m_szPart);
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：Compile configuration file
|
||
parameters:
|
||
pszFile --config file
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lMakeConfig(char *pszFile)
|
||
{
|
||
TBoot stBoot;
|
||
FILE *fp = NULL;
|
||
TIndex *pstIndex = NULL;
|
||
TDomain *pstDomain = NULL;
|
||
long i, lOut = 0, lCount = 0;
|
||
SATvm *pstSavm = (SATvm *)pGetSATvm();
|
||
|
||
if(!pszFile || !strlen(pszFile))
|
||
{
|
||
fprintf(stderr, "The configuration file is not set\n");
|
||
return RC_FAIL;
|
||
}
|
||
|
||
if(RC_SUCC != access(pszFile, R_OK | F_OK ))
|
||
{
|
||
fprintf(stderr, "Insufficient authority(%s), please confirm!!!\n\n", pszFile);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
memset(&stBoot, 0, sizeof(TBoot));
|
||
if(NULL == (fp = fopen(getenv("TVMCFG"), "wb")))
|
||
{
|
||
fprintf(stderr, "open (%s) failure, err:(%d)(%s)", getenv("TVMCFG"),
|
||
errno, strerror(errno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
fwrite(TVM_RUNCFG_TAG, 4, 1, fp);
|
||
if(RC_SUCC != lParseBoot(pstSavm, pszFile, &stBoot))
|
||
goto CREATE_ERROR;
|
||
|
||
fwrite(&stBoot, sizeof(stBoot), 1, fp);
|
||
if(TVM_BOOT_CLUSTER != stBoot.m_lBootType) // 单机部署
|
||
{
|
||
fclose(fp);
|
||
fprintf(stdout, "create completed successfully!!!\n");
|
||
return RC_FAIL;
|
||
}
|
||
|
||
if(RC_SUCC != lParseIndex(pstSavm, pszFile, &lOut, &pstIndex))
|
||
goto CREATE_ERROR;
|
||
|
||
fwrite(&lOut, sizeof(long), 1, fp);
|
||
fwrite(pstIndex, sizeof(TIndex), lOut, fp);
|
||
TFree(pstIndex);
|
||
|
||
if(RC_SUCC != lParseRemote(pstSavm, pszFile, &stBoot, &lOut, &pstIndex,
|
||
&lCount, &pstDomain))
|
||
goto CREATE_ERROR;
|
||
|
||
if(bDomIsRepeat(lCount, pstDomain))
|
||
goto CREATE_ERROR;
|
||
|
||
fwrite(&lOut, sizeof(long), 1, fp);
|
||
if(lOut > 0)
|
||
{
|
||
fwrite(pstIndex, sizeof(TIndex), lOut, fp);
|
||
TFree(pstIndex);
|
||
}
|
||
|
||
fwrite(&lCount, sizeof(long), 1, fp);
|
||
if(lCount > 0)
|
||
{
|
||
fwrite(pstDomain, sizeof(TDomain), lCount, fp);
|
||
TFree(pstDomain);
|
||
}
|
||
fclose(fp);
|
||
|
||
fprintf(stdout, "create completed successfully!!!\n");
|
||
|
||
return RC_SUCC;
|
||
|
||
CREATE_ERROR:
|
||
TFree(pstDomain);
|
||
TFree(pstIndex);
|
||
fclose(fp);
|
||
return RC_FAIL;
|
||
}
|
||
|
||
/*************************************************************************************************
|
||
description：Decompilate compilation configuration
|
||
parameters:
|
||
pszFile --config file
|
||
return:
|
||
RC_SUCC --success
|
||
RC_FAIL --failure
|
||
*************************************************************************************************/
|
||
long lUnmakeConfig(char *pszFile)
|
||
{
|
||
char ch;
|
||
TBoot stBoot;
|
||
FILE *fp = NULL;
|
||
bool bf = false;
|
||
TIndex *pstIndex = NULL;
|
||
TDomain *pstDomain = NULL;
|
||
long i, j, lOut = 0, lCount = 0;
|
||
SATvm *pstSavm = (SATvm *)pGetSATvm();
|
||
|
||
if(RC_SUCC == access(pszFile, F_OK))
|
||
{
|
||
fprintf(stderr, "The configuration already exists, Confirm the cover(Y/N)?:");
|
||
ch = getchar();
|
||
if(ch != 'y' && 'Y' != ch)
|
||
return RC_SUCC;
|
||
}
|
||
|
||
if(NULL == (fp = fopen(pszFile, "w")))
|
||
{
|
||
fprintf(stderr, "open file error, %s\n", strerror(errno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
if(RC_SUCC != lGetBootConfig(pstSavm, &stBoot))
|
||
goto UNMAKE_ERR;
|
||
|
||
fprintf(fp, "*GLOBLE\n");
|
||
fprintf(fp, "MACHINE=\"%s\"\n", stBoot.m_szNode);
|
||
fprintf(fp, "MAXTABLE=%ld\n", stBoot.m_lMaxTable);
|
||
fprintf(fp, "MAXFILED=%ld\n", stBoot.m_lMaxField);
|
||
fprintf(fp, "MAXDOMAIN=%ld\n", stBoot.m_lMaxDomain);
|
||
fprintf(fp, "MAXSEQUE=%ld\n", stBoot.m_lMaxSeque);
|
||
fprintf(fp, "SERVER_EXEC=%ld\n", stBoot.m_lBootExec);
|
||
fprintf(fp, "SERVER_PORT=%ld\n", stBoot.m_lBootPort);
|
||
fprintf(fp, "LOGNAME=\"%s\"\n\n", stBoot.m_szLog);
|
||
|
||
fprintf(fp, "*LOCAL_RESOURCE\n");
|
||
if(RC_SUCC != lGetLocalIndex(pstSavm, &lCount, (void *)&pstIndex))
|
||
goto UNMAKE_ERR;
|
||
|
||
for(i = 0; i < lCount; i ++)
|
||
fprintf(fp, "TABLE=%d PERMIT=%ld\n", pstIndex[i].m_table, pstIndex[i].m_lPers);
|
||
TFree(pstIndex);
|
||
|
||
fprintf(fp, "\n*REMOTE_DOMAIN");
|
||
if(RC_SUCC != lGetDomainIndex(pstSavm, &lCount, &pstIndex))
|
||
goto UNMAKE_ERR;
|
||
|
||
if(RC_SUCC != lGetDomainTable(pstSavm, &lOut, &pstDomain))
|
||
goto UNMAKE_ERR;
|
||
|
||
for(i = 0; i < lCount; i ++)
|
||
{
|
||
fprintf(fp, "\nTABLE=%d TABLENAME=\"%s\" PART=\"%s\" ", pstIndex[i].m_table,
|
||
pstIndex[i].m_szTable, pstIndex[i].m_szPart);
|
||
for(j = 0, bf = false; j < lOut; j ++)
|
||
{
|
||
if(strcmp(pstDomain[j].m_szTable, pstIndex[i].m_szTable) ||
|
||
strcmp(pstDomain[j].m_szPart, pstIndex[i].m_szPart))
|
||
continue;
|
||
|
||
if(!bf)
|
||
{
|
||
bf = !bf;
|
||
fprintf(fp, "GROUP=%ld TIMTOUT=%ld MAXTRY=%ld KEEPALIVE=%ld\n",
|
||
pstDomain[j].m_lGroup, pstDomain[j].m_lTimeOut, pstDomain[j].m_lTryMax,
|
||
pstDomain[j].m_lKeepLive);
|
||
}
|
||
|
||
fprintf(fp, "\tDOMAINID=\"%s\" WSADDR=\"%s:%ld\"\n", pstDomain[j].m_szOwner,
|
||
pstDomain[j].m_szIp, pstDomain[j].m_lPort);
|
||
}
|
||
}
|
||
TFree(pstIndex);
|
||
TFree(pstDomain);
|
||
|
||
fclose(fp);
|
||
fprintf(stdout, "导出文件(%s)成功，completed successfully!!!\n", pszFile);
|
||
|
||
return RC_SUCC;
|
||
UNMAKE_ERR:
|
||
fclose(fp);
|
||
TFree(pstIndex);
|
||
TFree(pstDomain);
|
||
fprintf(stderr, "get config err:(%d)(%s)\n", pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
|
||
return RC_FAIL;
|
||
}
|
||
|
||
/**************************************************************************************************
|
||
code end
|
||
**************************************************************************************************/
|