[Note] [Informatica] custom sequence generator component

/************************************************************************** * * Copyright (c) 2003 Informatica Corporation.  This file contains * material proprietary to Informatica Corporation and may not be copied * or distributed in any form without the written permission of Informatica * Corporation * **************************************************************************//************************************************************************** * Custom Transformation p_GetSeqVal Procedure File * * This file contains code that functions that will be called by the main * server executable. * * For more information on these files, * see $(PM_HOME)/ExtProc/include/Readme.txt **************************************************************************//**************************************************************************                               Includes **************************************************************************/#include "p_GetSeqVal.h"#include <stdio.h>#include <string.h>#include <stdlib.h>#include <windows.h>#include <stdarg.h>#include <process.h>/**************************************************************************                               UserDefineMacro **************************************************************************/#define DLLNAME "SeqGenerator.dll"#define PMDTM "pmdtm.exe"#define EXTPROCDIR "ExtProc\\"#define SEQFILE "SeqGenerator.tsv"#define LOCKFILE "SeqGenerator.lock"#define SEQNAMELEN 100#define MAXSEQNUM 10000typedef unsigned long int seqval_t;#define MSGCHARS 1000#define MAX_LINE_SIZE 1000#define MSGMARK ">>>>>>>>>>>>>>>"#define PROCNAME "SeqGenerator"/**************************************************************************                               SharedVariables **************************************************************************/struct seq_t{char chSeqName[SEQNAMELEN+1];seqval_t nSeqVal;};struct seqlist_t{struct seq_t arrSequences[MAXSEQNUM];int nSeqNums;};#pragma data_seg("SeqGeneratorShared")static int nInitFlag=0;static int nRefCount=0;static struct seqlist_t strSeqList={0};#pragma data_seg()#pragma comment(linker,"/section:SeqGeneratorShared,rws") /**************************************************************************                               Debug switch **************************************************************************///#define DEBUG_MODE#ifdef DEBUG_MODE    //LogMessage("%s DebugLog:",MSGMARK);#endif/**************************************************************************                               Global Variables **************************************************************************/char chLogMsg[MSGCHARS],chMutexName[MSGCHARS];TCHAR szPath[MAX_PATH],dllDir[MAX_PATH],SeqFilePath[MAX_PATH],LockFilePath[MAX_PATH];FILE *fpSeqFile,*fpLockFile;char *rowSeqName;char chSeqName[SEQNAMELEN+1];seqval_t nSeqVal;struct seqcache_t{char chSeqName[SEQNAMELEN+1];seqval_t *ptrSeqVal;};struct seqlistcache_t{struct seqcache_t arrSequences[MAXSEQNUM];int nSeqNums;};struct seqlistcache_t strSeqListCache={0};//HANDLE hMutex;/**************************************************************************                               Functions **************************************************************************/int LogMessage(char *fmt,...){    va_list ptrArg;va_start(ptrArg,fmt);vsprintf(chLogMsg,fmt,ptrArg);va_end(ptrArg);INFA_CTLogMessageM( eESL_LOG,chLogMsg);return 0;}int GetFileNumRows(FILE* fp){       int i = 0;    char strLine[MAX_LINE_SIZE];    fseek(fp,0,SEEK_SET);    while (fgets(strLine, MAX_LINE_SIZE, fp))        i++;    fseek(fp,0,SEEK_SET);    return i;}char * left(char *dst,char *src, int n){    char *p = src;    char *q = dst;    int len = strlen(src);    if(n>len) n = len;    while(n--) *(q++) = *(p++);    *(q++)=‘\0‘;     return dst;}char * mid(char *dst,char *src, int n,int m) {    char *p = src;    char *q = dst;    int len = strlen(src);    if(m>len) m = len-n;     if(n<0) n=0;      if(n>len) return NULL;    p += n;    while(m--) *(q++) = *(p++);    *(q++)=‘\0‘;     return dst;}/*INFA_STATUS mGetMutex(){    while(1){    hMutex=CreateMutex(NULL,FALSE,PROCNAME);if(hMutex&&GetLastError()==ERROR_ALREADY_EXISTS){    if(hMutex!=NULL){    CloseHandle(hMutex);}Sleep(1000);continue;} else if(hMutex!=NULL){    break;}else {return INFA_FAILURE;}}return INFA_SUCCESS;}*//**************************************************************************   Function: p_GetSeqVal_procInit Description: Initialization for the procedure.  Returns INFA_SUCCESS if  procedure initialization succeeds, else return INFA_FAILURE. Input: procedure - the handle for the procedure Output: None Remarks: This function will get called once for the session at initialization time.  It will be called after the moduleInit function. **************************************************************************/INFA_STATUS p_GetSeqVal_procInit( INFA_CT_PROCEDURE_HANDLE procedure){//Sleep(10000);    INFA_CTChangeStringMode( procedure, eASM_MBCS );if( !GetModuleFileName( NULL, szPath, MAX_PATH ) ){        LogMessage("GetModuleFileName failed (%d)\n", GetLastError());        return INFA_FAILURE;} else {LogMessage("ModuleFileName is : %s\n", szPath);mid(dllDir,szPath,0,strlen(szPath)-strlen(PMDTM));strcat(dllDir,EXTPROCDIR);LogMessage("ModuleDirectory is : %s\n", dllDir);strcpy(SeqFilePath,dllDir);strcat(SeqFilePath,SEQFILE);LogMessage("Sequence File is : %s\n", SeqFilePath);strcpy(LockFilePath,dllDir);strcat(LockFilePath,LOCKFILE);LogMessage("Lock File is : %s\n", LockFilePath);}//CreateMutex(NULL,FALSE,PROCNAME);//mGetMutex();//WaitForSingleObject(hMutex, INFINITE);fpLockFile=fopen(LockFilePath,"w");while(LockFile(fpLockFile,1,1,1,1)!=0){Sleep(2000);}if(1==++nRefCount){int nFileNumRows,i;        LogMessage("%s Loading Sequence File\n",MSGMARK);        fpSeqFile=fopen(SeqFilePath,"a+");        nFileNumRows=GetFileNumRows(fpSeqFile);LogMessage("%s Sequence Objects Nums: %d\n",MSGMARK,nFileNumRows);strSeqList.nSeqNums=0;for(i=0;i<nFileNumRows;i++){fscanf(fpSeqFile,"%s\t%lu\n",chSeqName,&nSeqVal);strSeqList.nSeqNums++;strcpy(strSeqList.arrSequences[i].chSeqName,chSeqName);strSeqList.arrSequences[i].nSeqVal=nSeqVal;}if(EOF==fclose(fpSeqFile)){    LogMessage("Close Sequence File Failed!\n" );    return INFA_FAILURE;    }nInitFlag=1;//CloseHandle(hMutex);LogMessage("%s Finish loading Sequence File",MSGMARK);} else {LogMessage("%s Wait for loading Sequence File",MSGMARK);while(1!=nInitFlag){}LogMessage("%s Finish loading Sequence File",MSGMARK);}UnlockFile(fpLockFile,1,1,1,1);if(EOF==fclose(fpLockFile)){        LogMessage("Close Lock File Failed!\n" );return INFA_FAILURE;}//ReleaseMutex(hMutex);    return INFA_SUCCESS;}/**************************************************************************   Function: p_GetSeqVal_procDeinit Description: Deinitialization for the procedure.  Returns INFA_SUCCESS if  procedure deinitialization succeeds, else return INFA_FAILURE. Input: procedure - the handle for the procedure Output: None Remarks: This function will get called once for the session at deinitialization time.  It will be called before the moduleDeinit function. **************************************************************************/INFA_STATUS p_GetSeqVal_procDeinit( INFA_CT_PROCEDURE_HANDLE procedure, INFA_STATUS sessionStatus ){//mGetMutex();//WaitForSingleObject(hMutex, INFINITE);fpLockFile=fopen(LockFilePath,"w");while(LockFile(fpLockFile,1,1,1,1)!=0){Sleep(2000);}if(0==--nRefCount){int i;LogMessage("%s Writing Sequence File",MSGMARK);fpSeqFile=fopen(SeqFilePath,"w");for(i=0;i<strSeqList.nSeqNums;i++){fprintf(fpSeqFile,"%s\t%lu\n",strSeqList.arrSequences[i].chSeqName,strSeqList.arrSequences[i].nSeqVal);}if(EOF==fclose(fpSeqFile)){LogMessage("Close Sequence File Failed!\n" );return INFA_FAILURE;}LogMessage("%s Finish Writing Sequence File",MSGMARK);}    UnlockFile(fpLockFile,1,1,1,1);if(EOF==fclose(fpLockFile)){        LogMessage("Close Lock File Failed!\n" );return INFA_FAILURE;}//ReleaseMutex(hMutex);//CloseHandle(hMutex);    return INFA_SUCCESS;}/**************************************************************************   Function: p_GetSeqVal_partitionInit Description: Initialization for the partition.  Returns INFA_SUCCESS if  partition deinitialization succeeds, else return INFA_FAILURE. Input: partition - the handle for the partition Output: None Remarks: This function will get called once for each partition for each transformation in the session. **************************************************************************/INFA_STATUS p_GetSeqVal_partitionInit( INFA_CT_PARTITION_HANDLE partition ){    /*TODO: fill in code here*/    return INFA_SUCCESS;}/**************************************************************************   Function: p_GetSeqVal_partitionDeinit Description: Deinitialization for the partition.  Returns INFA_SUCCESS if  partition deinitialization succeeds, else return INFA_FAILURE. Input: partition - the handle for the partition Output: None Remarks: This function will get called once for each partition for each transformation in the session. **************************************************************************/INFA_STATUS p_GetSeqVal_partitionDeinit( INFA_CT_PARTITION_HANDLE partition ){    /*TODO: fill in code here*/    return INFA_SUCCESS;}/**************************************************************************   Function: p_GetSeqVal_inputRowNotification Description: Notification that a row needs to be processed for an input group in a transformation for the given partition.  Returns INFA_ROWSUCCESS if the input row was processed successfully, INFA_ROWERROR if the input row was not processed successfully and INFA_FATALERROR if the input row causes the session to fail. Input: partition - the handle for the partition for the given row        group - the handle for the input group for the given row Output: None Remarks: This function is probably where the meat of your code will go, as it is called for every row that gets sent into your transformation.  **************************************************************************/INFA_ROWSTATUS p_GetSeqVal_inputRowNotification( INFA_CT_PARTITION_HANDLE partition,                                    INFA_CT_INPUTGROUP_HANDLE inputGroup ){    const INFA_CT_OUTPUTGROUP_HANDLE* outputGroups = NULL;    const INFA_CT_INPUTPORT_HANDLE* inputGroupPorts = NULL;    const INFA_CT_OUTPUTPORT_HANDLE* outputGroupPorts = NULL;    size_t nNumInputPorts = 0, nNumOutputGroups = 0, nNumPortsInOutputGroup = 0;int i,j;outputGroups = INFA_CTGetChildrenHandles(partition,&nNumOutputGroups,OUTPUTGROUPTYPE);outputGroupPorts = INFA_CTGetChildrenHandles(outputGroups[0],&nNumPortsInOutputGroup,OUTPUTPORTTYPE);inputGroupPorts = INFA_CTGetChildrenHandles(inputGroup,&nNumInputPorts,INPUTPORTTYPE);    rowSeqName=(char*)INFA_CTGetDataVoid(inputGroupPorts[0]);for(j=0;j<strSeqListCache.nSeqNums;j++){        if(strcmp(rowSeqName,strSeqListCache.arrSequences[j].chSeqName)==0)break;}if(j==strSeqListCache.nSeqNums){for(i=0;i<strSeqList.nSeqNums;i++){if(strcmp(rowSeqName,strSeqList.arrSequences[i].chSeqName)==0)break;}if(i==strSeqList.nSeqNums){strcpy(strSeqList.arrSequences[i].chSeqName,rowSeqName);strSeqList.nSeqNums++;strcpy(strSeqListCache.arrSequences[j].chSeqName,rowSeqName);    strSeqListCache.arrSequences[j].ptrSeqVal=&(strSeqList.arrSequences[i].nSeqVal);    strSeqListCache.nSeqNums++;}nSeqVal=++(strSeqList.arrSequences[i].nSeqVal);strcpy(strSeqListCache.arrSequences[j].chSeqName,rowSeqName);strSeqListCache.arrSequences[j].ptrSeqVal=&(strSeqList.arrSequences[i].nSeqVal);strSeqListCache.nSeqNums++;} else {nSeqVal=++*(strSeqListCache.arrSequences[j].ptrSeqVal);}    INFA_CTSetData(outputGroupPorts[0], &nSeqVal);INFA_CTSetIndicator(outputGroupPorts[0],INFA_DATA_VALID);    return INFA_CTOutputNotification(outputGroups[0]);}/**************************************************************************   Function: p_GetSeqVal_eofNotification Description: Notification that the last row for an input group has already been seen.  Return INFA_FAILURE if the session should fail as a result of seeing this notification, INFA_SUCCESS otherwise. Input: partition - the handle for the partition for the notification        group - the handle for the input group for the notification Output: None **************************************************************************/INFA_STATUS p_GetSeqVal_eofNotification( INFA_CT_PARTITION_HANDLE partition,                            INFA_CT_INPUTGROUP_HANDLE group){    /*TODO: fill in code here*/    return INFA_SUCCESS;}/**************************************************************************   Function: p_GetSeqVal_dataBdryNotification Description: Notification that a transaction has ended.  The data boundary type can either be commit or rollback. Return INFA_FAILURE if the session should fail as a result of seeing this notification, INFA_SUCCESS otherwise. Input: partition - the handle for the partition for the notification        transactionType - commit or rollback  Output: None **************************************************************************/INFA_STATUS p_GetSeqVal_dataBdryNotification (                        INFA_CT_PARTITION_HANDLE partition,                       INFA_CT_DATABDRY_TYPE transactionType){    /*TODO: fill in code here*/    return INFA_SUCCESS;}