pflib 환경파일 모듈 작성

pflib
├── CMakeLists.txt
├── inc
│   ├── pfchannel.h
│   ├── pfcommon.h
│   ├── pfconf.h
│   ├── pffile.h
│   ├── pfipc.h
│   ├── pflib.h
│   ├── pflog.h
│   ├── pfstring.h
│   └── pftime.h
├── pfchannel.c
├── pfcommon.c
├── pfconf.c
├── pffile.c
├── pfipc.c
├── pflib.c
├── pflog.c
├── pfstring.c
└── pftime.c

환경파일 모듈은 pfconf.c 이다. 프로세스에서 환경파일을 참조해서 설정값을 가져올때 사용하는 함수를 작성한다. 주로 프로세스 실행시 프로세스의 설정을 파일로 관리할때 사용한다.

함수	설명
getConfItem	아이템 메모리확보
freeConfItem	아이템 메모리해제
getConfSection	섹션 메모리확보
freeConfSection	섹션 메모리해제
getConfData	환경파일의 모든내용을 메모리로 로드
makeConfList	getConfData의 내용으로 섹션/아이템으로 만듬
reload	환경파일을 다시 읽어드림
prtConfList	환경파일을 출력
getInt	해당하는 섹션에서 키값을 찾아 int형으로 리턴
getString	해당하는 섹션에서 키값을 찾아 string형으로 리턴
getSectionCount	섹션수를 리턴
getSectionName	해당하는 세션을 구함
getSectionPos	해당하는 세션의 pos를 구함
getItemCount	섹션의 아이템수를 리턴
getItemInfo	섹션의 아이템을 구함
dispose	모든 자원을 해제
initConfSt	환경파일을 메모리로 읽어들이고 섹션/아이템으로 만듬

환경파일은 xml형태를 취한다. 중요한 개념은 섹션과 아이템이다. 섹션은 [섹션명]으로 정의해서 그룹의 형태이고 아이템은 키=값의 형태로 정의한다.

아래와 같은 xml형태의 환경파일을 다룬다.

#app에서 사용하는 환경설정
#
#cfg파일 정의
[CONF]    # 섹션
IPC=conf/ipc_define.conf
TERMSVR=conf/termsvr.conf

[LOG]    # 섹션
#로깅할때 LOG_TYPE_ERR인 경우 로깅할 파일을 정의
#정의하지 않으면 LOG_TYPE_INFO와 같이 작업함
ERR=log/$DATE$/global_err.log

pfconf.h

#ifndef _LIB_PFCONF_H_
#define _LIB_PFCONF_H_

// conf의 섹션의 아이템
typedef struct _confItemListSt {
    char *key;
    char *value;
    struct _confItemListSt *next;
} CONF_ITEM_LIST_ST;

// conf의 섹션
typedef struct _confSectionListSt {
    char *buf;
    struct _confSectionListSt *next;
    CONF_ITEM_LIST_ST *item;
} CONF_SECTION_LIST_ST;

// conf struct and method
typedef struct _confSt {

    CONF_SECTION_LIST_ST *pSection;
    int iSectionCnt;            // 섹션수

    char fname[1024];            // conf file path/name
    char *data;                    // conf data

    void (*dispose)(struct _confSt *pThis);
    int (*getInt)(struct _confSt *pThis, char *section, char *key, int defaultValue);
    int (*getString)(struct _confSt *pThis, char *section, char *key, char *defaultValue, char *retBuf, int retBufLen);
    void (*prtConfList)(struct _confSt *pThis);
    int (*getSectionCount)(struct _confSt *pThis);
    CONF_SECTION_LIST_ST *(*getSectionName)(struct _confSt *pThis, CONF_SECTION_LIST_ST *pConfListPos, char *value);
    CONF_ITEM_LIST_ST *(*getItemInfo)(struct _confSt *pThis, CONF_SECTION_LIST_ST *pConfListPos, CONF_ITEM_LIST_ST *pConfItemPos, char *section, char *item, char *value);
    int (*getItemCount)(struct _confSt *pThis, CONF_SECTION_LIST_ST *pConfListPos, char *section);
    void (*reload)(struct _confSt *pThis);
    CONF_SECTION_LIST_ST *(*getSectionPos)(struct _confSt *pThis, char *section);

} CONF_ST; 

// init
CONF_ST* initConfSt(char *fname);
CONF_ST* initConfStFromEnv(char *env, char *fname);

#endif

사용할 변수와 사용가능한 함수포인트를 선언한다.

pfconf.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <memory.h>

#include "pfstring.h"
#include "pffile.h"
#include "pfconf.h"

// string
static STRING_ST *_gString;

// conf item 메모리확보
static CONF_ITEM_LIST_ST *_getConfItem() {
    CONF_ITEM_LIST_ST *item = (CONF_ITEM_LIST_ST *)malloc(sizeof(CONF_ITEM_LIST_ST));
    if (item == NULL) 
        return NULL;
    item->key = NULL;
    item->value = NULL;
    item->next = NULL;
    return item;
}

// conf item 메모리해제
static void _freeConfItem(CONF_ITEM_LIST_ST *start) {
    CONF_ITEM_LIST_ST *confListPos = start;
    while(confListPos != NULL) {
        if (confListPos->key != NULL) {
            free(confListPos->key);
        }
        if (confListPos->value != NULL) {
            free(confListPos->value);
        }
        CONF_ITEM_LIST_ST *pFree = confListPos;
        confListPos = confListPos->next;
        free(pFree);
    }
}

// conf section 메모리확보
static CONF_SECTION_LIST_ST *_getConfSection() {
    CONF_SECTION_LIST_ST *section = (CONF_SECTION_LIST_ST *)malloc(sizeof(CONF_SECTION_LIST_ST));
    if (section == NULL) 
        return NULL;
    section->buf = NULL;
    section->next = NULL;
    section->item = NULL;
    return section;
}

// conf section 메모리해제
static void _freeConfSection(CONF_SECTION_LIST_ST *start) {
    CONF_SECTION_LIST_ST *confListPos = start;
    while(confListPos != NULL) {
        if (confListPos->buf != NULL)
            free(confListPos->buf);
        if (confListPos->item != NULL)
            _freeConfItem(confListPos->item);
        CONF_SECTION_LIST_ST *pFree = confListPos;
        confListPos = confListPos->next;
        free(pFree);
    }
}

// conf 파일의 모든내용을 메로리로 로드함
static char *_getConfData(char *fname) {
    FILE *fp;

    if ((fp = fopen (fname, "rb")) == NULL) {
        printf("[%s]fopen error!!![%d][%s]\n", fname, errno, strerror(errno));
        return NULL;
    }    
    fseek(fp, 0, SEEK_END);
    long fsize = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    char *buff = (char *)malloc(fsize + 1);
    if (1 != fread(buff, fsize, 1, fp)) {
        fclose(fp);
        free(buff);
        printf("fread error[%d][%s]\n", errno, strerror(errno));
        return NULL;
    }
    fclose(fp);

    buff[fsize] = 0x00;
    return buff;
}

// conf 내용을 섹션/데이타로 만듬
static CONF_SECTION_LIST_ST *_makeConfList(CONF_ST *pThis) {

    CONF_SECTION_LIST_ST *confListStart = NULL, *confListPos = NULL;
    CONF_ITEM_LIST_ST *confItemStart = NULL, *confItemPos = NULL;
    char *saveptr;
    char *ptr = strtok_r(pThis->data, "\r\n", &saveptr);    
    int iSectionCnt = 0;

    // get line count
    while (ptr != NULL) {
        // 주석이 아닌 데이타가 있는 경우만 처리
        //strcpy(ptrBuf, ptr);
        _gString->trim(ptr, NULL);
        if (strlen(ptr) > 0 && ptr[0] != '#') {
            if (ptr[0] == '[') {
                // 섹션처리
                CONF_SECTION_LIST_ST *confListItem = _getConfSection();
                if (confListItem == NULL) {
                    _freeConfSection(confListStart);
                    return NULL;
                }
                if (confListPos == NULL) {
                    // start pos
                    confListStart = confListPos = confListItem;
                } else {
                    confListPos->next = confListItem;
                    confListPos = confListItem;
                }
                // [],공백 제거
                _gString->ltrim(ptr, "[ \t");
                _gString->rtrim(ptr, " \t]");
                if ((confListPos->buf = (char *)malloc((strlen(ptr) + 1) * sizeof(char))) == NULL) {
                    _freeConfSection(confListStart);
                    return NULL;
                }
                strcpy(confListPos->buf, ptr);
                iSectionCnt++;
                confItemStart = confItemPos = NULL;
            } else {
                // 섹션의 데이타처리
                CONF_ITEM_LIST_ST *confListItem = _getConfItem();
                if (confListItem == NULL) {
                    _freeConfItem(confItemStart);
                    _freeConfSection(confListStart);
                    return NULL;
                }
                if (confItemPos == NULL) {
                    confItemStart = confItemPos = confListItem;
                    confListPos->item = confListItem;
                } else {
                    confItemPos->next = confListItem;
                    confItemPos = confListItem;
                }
                // key-value로 만듬
                if (_gString->makeKeyValueAlloc(ptr, &(confItemPos->key), &(confItemPos->value)) < 0) {
                    _freeConfItem(confItemStart);
                    _freeConfSection(confListStart);
                    return NULL;
                }
            }
        }
        ptr = strtok_r(NULL, "\r\n", &saveptr);    
    }

    // 섹션수
    pThis->iSectionCnt = iSectionCnt;
    return confListStart;
}

/*
 * 다시읽어드림
 */
static void _reload(CONF_ST *pThis) {

    // 이전메모리 해제
    _freeConfSection(pThis->pSection);

    // load conf data
    pThis->data = _getConfData(pThis->fname);
    // parsing
    pThis->pSection = _makeConfList(pThis);
    free(pThis->data);
}

// 섹션/데이타를 출력함
static void _prtConfList(CONF_ST *pThis) {
    CONF_SECTION_LIST_ST *confListPos = pThis->pSection;

    while(confListPos != NULL) {
        printf("SECTION: %s\n", confListPos->buf);
        CONF_ITEM_LIST_ST *confItemPos = confListPos->item;
        while(confItemPos != NULL) {
            printf("\t %s:%s\n", confItemPos->key, confItemPos->value);
            confItemPos = confItemPos->next;
        }
        confListPos = confListPos->next;
    }
}

// 섹션/키에 맞는 값을 찾아서 int형으로 리턴함
static int _getInt(CONF_ST *pThis, char *section, char *key, int defaultValue) {
    // find section
    CONF_SECTION_LIST_ST *confListPos = pThis->pSection;

    while(confListPos != NULL) {
        if (!strcmp(section, confListPos->buf)) {
            CONF_ITEM_LIST_ST *confItemPos = confListPos->item;
            while(confItemPos != NULL) {
                if (!strcmp(key, confItemPos->key)) {
                    if (confItemPos->value != NULL)
                        return atoi(confItemPos->value);
                    else
                        return defaultValue;
                }
                confItemPos = confItemPos->next;
            }
        }
        confListPos = confListPos->next;
    }
    return defaultValue;
}

// 섹션/키에 맞는 값을 찾아서 리턴함
static int _getString(CONF_ST *pThis, char *section, char *key, char *defaultValue, char *retBuf, int retBufLen) {
    // find section
    CONF_SECTION_LIST_ST *confListPos = pThis->pSection;

    // init return buffer
    memset(retBuf, 0x00, retBufLen);
    while(confListPos != NULL) {
        if (!strcmp(section, confListPos->buf)) {
            CONF_ITEM_LIST_ST *confItemPos = confListPos->item;
            while(confItemPos != NULL) {
                if (!strcmp(key, confItemPos->key)) {
                    if (confItemPos->value != NULL) {
                        if ((size_t)retBufLen < strlen(confItemPos->value))        // 버퍼부족
                            strcpy(retBuf, defaultValue);
                        else    
                            strcpy(retBuf, confItemPos->value);
                    }
                    else
                        strcpy(retBuf, defaultValue);
                    return (int)strlen(retBuf);
                }
                confItemPos = confItemPos->next;
            }
        }
        confListPos = confListPos->next;
    }
    return (int)strlen(retBuf);
}


/*
 * 섹션수
 */
static int _getSectionCount(CONF_ST *pThis) {
    if (pThis == NULL)
        return -1;
    return pThis->iSectionCnt;
}

/*
 * pConfListPos에 해당하는 섹션명을 value에 복사하고
 * pConfListPos->next 다음 섹션을 리턴해줌
 */
static CONF_SECTION_LIST_ST *_getSectionName(CONF_ST *pThis, CONF_SECTION_LIST_ST *pConfListPos, char *value) {
    if (pThis == NULL)
        return NULL;

    CONF_SECTION_LIST_ST *confListPos = pConfListPos == NULL ? pThis->pSection : pConfListPos;
    if (confListPos != NULL) {
        if (value != NULL)
            strcpy(value, confListPos->buf);
        return confListPos->next;
    } else {
        if (value != NULL)
            value[0] = 0x00;
        return NULL;
    }
}

/*
 * section에 해당하는 섹션 pos를 구함
 */
static CONF_SECTION_LIST_ST *_getSectionPos(CONF_ST *pThis, char *section) {
    CONF_SECTION_LIST_ST *confListPos = pThis->pSection;

    while(confListPos != NULL) {
        if (!strcasecmp(section, confListPos->buf))
            return confListPos;
        confListPos = confListPos->next;
    }
    return NULL;
}

/*
 * 섹션의 Item수
 */
static int _getItemCount(CONF_ST *pThis, CONF_SECTION_LIST_ST *pConfListPos, char *section) {
    if (pThis == NULL)
        return -1;

    CONF_SECTION_LIST_ST *confListPos;
    if (pConfListPos == NULL) {
        // section명으로 해당하는 섹션을 찾음
        confListPos = _getSectionPos(pThis, section);
        if (confListPos == NULL)
            return -1;
    } else {
        confListPos = pConfListPos;
    }

    int cnt = 0;
    CONF_ITEM_LIST_ST *confItemPos = confListPos->item;
    while(confItemPos != NULL) {
        //printf("\t %s:%s\n", confItemPos->key, confItemPos->value);
        cnt++;
        confItemPos = confItemPos->next;
    }

    return cnt;
}

/*
 * pConfListPos-pConfItemPos에 해당하는 키값을 value에 복사하고
 * pConfItemPos->next 다음 Item을 리턴해줌
 */
static CONF_ITEM_LIST_ST *_getItemInfo(CONF_ST *pThis, CONF_SECTION_LIST_ST *pConfListPos, CONF_ITEM_LIST_ST *pConfItemPos, char *section, char *item, char *value) {
    if (pThis == NULL)
        return NULL;

    CONF_SECTION_LIST_ST *confListPos;
    if (pConfListPos == NULL) {
        // section명으로 해당하는 섹션을 찾음
        confListPos = _getSectionPos(pThis, section);
        if (confListPos == NULL)
            return NULL;
    } else {
        confListPos = pConfListPos;
    }

    CONF_ITEM_LIST_ST *confItemPos = pConfItemPos == NULL ? confListPos->item : pConfItemPos;
    if (confItemPos != NULL) {
        if (item != NULL) {
            if (confItemPos->key == NULL)
                item[0] = 0x00;
            else
                strcpy(item, confItemPos->key);
        }
        if (value != NULL) {
            if (confItemPos->value == NULL)
                value[0] = 0x00;
            else
                strcpy(value, confItemPos->value);
        }
        return confItemPos->next;
    } else {
        if (item != NULL)
            item[0] = 0x00;
        if (value != NULL)
            value[0] = 0x00;
        return NULL;
    }
}

// 사용후 반드시 콜해야함
static void _dispose(CONF_ST *pThis) {
    if (pThis) {
        _freeConfSection(pThis->pSection);
        free(pThis);
        pThis = NULL;
    }
}

// init struct
CONF_ST* initConfSt(char *fname) {

    CONF_ST *pConfSt;

    // string lib
    _gString = initStringSt();

    pConfSt = (CONF_ST *)malloc(sizeof(CONF_ST));
    if (pConfSt == NULL)
        return NULL;

    // conf filename
    strcpy(pConfSt->fname, fname);
    // load conf data
    if ((pConfSt->data = _getConfData(fname)) == NULL) {
        fprintf(stderr, "initConfSt[%s] _getConfData error!!!\n", fname);
        fflush(stderr);
        return NULL;
    }
    // parsing
    pConfSt->pSection = _makeConfList(pConfSt);
    free(pConfSt->data);

    if (pConfSt->pSection == NULL) {
        _dispose(pConfSt);
        return NULL;
    }
    // set method
    pConfSt->dispose = _dispose;
    pConfSt->getInt = _getInt;
    pConfSt->getString = _getString;
    pConfSt->prtConfList = _prtConfList;
    pConfSt->getSectionCount = _getSectionCount;
    pConfSt->getSectionName = _getSectionName;
    pConfSt->getItemInfo = _getItemInfo;
    pConfSt->getItemCount = _getItemCount;
    pConfSt->reload = _reload;
    pConfSt->getSectionPos = _getSectionPos;

    return pConfSt;
}

// init struct : env(WORKHOME)로 conf/conf filename의 폴더를 만들어서 initConfSt()를 호출함
// initConfStFromEnv("WORKHOME", conffile)
CONF_ST* initConfStFromEnv(char *env, char *fname) {
    FILE_ST *pFile = initFileSt();
    char basedir[256];
    char confName[1024];

    //basedir
    pFile->getEnvDir(env, basedir);

    sprintf(confName, "%s/%s", basedir, fname);

    return initConfSt(confName);
}

CONF_ST에는 생성자를 2개 제공한다. 환경파일명을 환경변수에서 가져올때 initConfStFromEnv()함수를 사용한다.

생성자에서는 환경파일 전체를 메모리에 로드해서 사용한다. 환경파일에서 섹션/아이템을 자료구조 링크드리스트(Linked-List)를 사용한다.

이렇게 하는 이유는 여러개의 키값을 가져올 경우 매번 파일을 오픈하고 검색해서 가져와야 하는 부하가 생기는걸 방지하기 위함이다.

pfconf 사용

// 생성
CONF_ST *pConf = initConfSt("my.conf");

// 함수사용
pConf->getSectionCount(pConf);

// 종료시 해제
pConf->dispose(pConf);

my.conf 환경파일로 생성하면 my.conf파일 전체를 메모리에 섹션, 아이템으로 로드한다. 제공하는 함수를 통해서 섹션/아이템의 값을 가져올 수 있다. 사용이 완료되면 반드시 dispose()를 호출해야 한다.

tapas-dev

이 블로그 검색

타파스에서 사용하는 제품군(인프라) 선정

pflib 환경파일 모듈 작성

태그

댓글

댓글 쓰기

이 블로그의 인기 게시물

velog글을 blogger로 게시하는 방법

시세 데이타를 수신 및 처리 개요