SRguide

2014년 7월 25일 (금) 15:58 판

SR guide

이 문서는 SR에 대해 설명한다.

General

• SR : Standard Representation의 약어이다.
• 기본(Primitive) Type 지원: NULL, INT, LL, DBL, STR, OCT, DIR, PTR, BOOL
• Aggregation Type: Enum(Bitwise 가능)
• Extendable Type: 기본 타입을 확장하여 다양한 형 상속 가능하다
• Complex Type: 트리 형식으로 표현 가능, Link를 통해 그래프도 가능하다

Feature

• SR 생성, 삭제, 열람, 복사
• ASR(Argumented SR): SR의 Human-readble 표현형
• SR Encryption/Decryption

Visualized Structure

• SR은 사람이 쉽게 읽을 수 있도록 아래와 같은 구조를 보여준다.

<dir> {
        ebc_port <int>10010;
        services <dir> {
                ebcd <dir> {
                        enabled <bool>true;
                        clname <str>ECMCluster;
                        ndname <str>node;
                        detection_interval <int>0;
                        bdcast_addr <str>"255.255.255.255";
                };
         };
};

SR Type

SR 타입은 위에서 언급된 것과 같이 다양하게 지원된다. 아래는 선언된 SR Type 내용이다.

#define ST_NULL         0x000000
#define ST_INT          0x010000
#define ST_LL           0x020000
#define ST_DBL          0x030000
#define ST_STR          0x040000
#define ST_OCT          0x050000
#define ST_DIR          0x060000
#define ST_PTR          0x070000
#define ST_BOOL         0x080000

#define ST_APPLYOPT     0x010001
#define ST_LNP          0x060001
#define ST_LNI_TYPE     0x010002
#define ST_SRT          0x010003
#define ST_LNPSTR       0x040001

Create SR

SR을 만들때에는 아래와 같은 함수를 사용한다. libsr.h에서 확인할 수 있다. sr_create 함수를 자주 사용한다.

sr_t *sr_create(srt_t srt);
sr_t *sr_create_ref(srt_t srt);
sr_t *sr_create_HMS(srt_t srt);
sr_t *sr_create_virtual(srt_t srt);
sr_t *sr_create_vHMS(srt_t srt);

#define sr_create_val(type, val)        sr_set_val(sr_create(type), val)
#define sr_create_int(type, ival)       sr_set_int(sr_create(type), ival)
#define sr_create_ll(type, lval)        sr_set_ll(sr_create(type), lval)
#define sr_create_dbl(type, dval)       sr_set_dbl(sr_create(type), dval)
#define sr_create_str(type, str)        sr_set_str(sr_create(type), str)
#define sr_create_oct(type, size, data) sr_set_oct(sr_create(type), size, data)
#define sr_create_ptr(type, ptr)        sr_set_ptr(sr_create(type), ptr)
#define sr_create_bool(type, bval)      sr_set_bool(sr_create(type), bval)
#define sr_create_dir()                 sr_create(ST_DIR)

/* create child */
#define sr_createc(root, name, type)    sr_setc(root, name, sr_create(type))
#define sr_createc_val(root, name, type, val)   \
        sr_setc(root, name, sr_create_val(type, val))
#define sr_createc_int(root, name, type, ival)  \
        sr_setc(root, name, sr_create_int(type, ival))
#define sr_createc_ll(root, name, type, lval)   \
        sr_setc(root, name, sr_create_ll(type, lval))
#define sr_createc_dbl(root, name, type, dval)  \
        sr_setc(root, name, sr_create_dbl(type, dval))
#define sr_createc_str(root, name, type, str)   \
        sr_setc(root, name, sr_create_str(type, str))
#define sr_createc_oct(root, name, type, size, data)   \
        sr_setc(root, name, sr_create_oct(type, size, data))
#define sr_createc_bool(root, name, type, bval)   \
        sr_setc(root, name, sr_create_bool(type, bval))
#define sr_createc_dir(root, name) \
        sr_setc(root, name, sr_create_dir())
#define sr_createc_bool(root, name, type, bval)  \
        sr_setc(root, name, sr_create_bool(type, bval))
#define sr_createc_ptr(root, name, type, ptr)   \
        sr_setc(root, name, sr_create_ptr(type, ptr))
#define sr_createc_ref(root, name, type, sr_LNP)        \
        sr_set_ref(sr_setc(root, name, sr_create_ref(type)), sr_LNP)
#define sr_createc_HMS(root, name, type)  sr_setc(root, name, sr_create_HMS(type))


/* create indexed child */
#define sr_createi(dir, idx, type) \
                sr_set_child_idx(dir, idx, sr_create(type))
#define sr_createi_val(dir, idx, type, val) \
                sr_set_idx(dir, idx, sr_create_val(type, val))
#define sr_createi_int(dir, idx, type, ival) \
                sr_set_idx(dir, idx, sr_create_int(type, ival))
#define sr_createi_ll(dir, idx, type, lval) \
                sr_set_idx(dir, idx, sr_create_ll(type, lval))
#define sr_createi_dbl(dir, idx, type, dval) \
                sr_set_idx(dir, idx, sr_create_dbl(type, dval))
#define sr_createi_str(dir, idx, type, str) \
                sr_set_idx(dir, idx, sr_create_str(type, str))
#define sr_createi_oct(dir, idx, type, size, data) \
                sr_set_idx(dir, idx, sr_create_oct(type, size, data))
#define sr_createi_dir(dir, idx) \
                sr_set_idx(dir, idx, sr_create_dir())


/* create descendant */
#define sr_createn1(root, LNP, type)    sr_setn1(root, LNP, sr_create(type))
#define sr_createn1_val(root, LNP, type, val)   \
  sr_setn1(root, LNP, sr_create_val(type, val))
#define sr_createn1_int(root, LNP, type, ival)  \
  sr_setn1(root, LNP, sr_create_int(type, ival))
#define sr_createn1_ll(root, LNP, type, lval)   \
  sr_setn1(root, LNP, sr_create_ll(type, lval))
#define sr_createn1_dbl(root, LNP, type, dval)  \
  sr_setn1(root, LNP, sr_create_dbl(type, dval))
#define sr_createn1_str(root, LNP, type, str)   \
  sr_setn1(root, LNP, sr_create_str(type, str))
#define sr_createn1_oct(root, LNP, type, size, data)   \
  sr_setn1(root, LNP, sr_create_oct(type, size, data))
#define sr_createn1_dir(root, LNP)  sr_setn1(root, LNP, sr_create_dir())
#define sr_createn1_bool(root, LNP, type, bval)  \
        sr_setn1(root, LNP, sr_create_bool(type, bval))
#define sr_createn1_ptr(root, LNP, type, ptr)  \
        sr_setn1(root, LNP, sr_create_ptr(type, ptr))
#define sr_createn1_ref(root, LNP, type, target)  \
        sr_set_ref(sr_setn1(root, LNP, sr_create_ref(type)), target)
#define sr_createn1_HMS(root, LNP, type)  sr_setn1(root, LNP, sr_create_HMS(type))

ASR 파일 처리

예를 들어 아래와 같은 ASR 형식의 텍스트 파일이 있다고 가정한다.

libRvazon <dir> {
	vmt <dir> {
		vmt_1 <dir> {
			vmt_id <int>1;
			vmt_name <str>c3.xlarge;
			vmt_cores <int>4;
			vmt_mem <int>7;
			vmt_hdd <int>80;
			vmt_net_perf <str>Moderate;
			vmt_fee_rank <int>1;	
		};
		vmt_2 <dir> {
			vmt_id <int>2;
			vmt_name <str>c3.2xlarge;
			vmt_cores <int>8;
			vmt_mem <int>15;
			vmt_hdd <int>160;
			vmt_net_perf <str>High;
			vmt_fee_rank <int>2;
		};
	};

	rgn <dir> {
		rgn_1 <dir> {
			rgn_id <int>1;
			rgn_name <str>us-east-1;
			rgn_desc <str>"US East (N. Virginia)";
		};

	};
}

위와 같은 형식일때 sr_t 으로 반환 하는 함수는 아래와 같이 구현가능하다.

static sr_t *
load_asr(const char *fpath)
{
	sr_t		*sr = NULL;
	int		fd;
	char		*buf;
	ecm_uint64	filesize;
	ecm_size_t	buflen;

	fd = ecm_open(fpath, ECM_O_RDONLY);
	if (fd < 0)
		return NULL;

	if (!ecm_filesize(fd, &filesize)) {
		ecm_close(fd);
		return NULL;
	}

	buflen = (ecm_size_t)filesize;
	buf = (char*)ecm_malloc(buflen + 1);
	if (ecm_read(fd, buf, &buflen)) {
		buf[buflen] = '\0';
		sr = sr_asr_scan(buf);
	}
	ecm_free(buf);
	ecm_close(fd);

	return sr;
}

SR 조작

• sr_t의 포인터를 처리하는 함수는 다음과 같다.

sr_t *sr_get_child(const sr_t *sr_group, const char *name);

ex) 
sr_t *sr_vmt = sr_get_child(sr, "vmt");

• sr_t *sr_get_child(const sr_t *sr_group, const char *name) : 해당 sr에서 해당 dir의 child를 반환한다.
• sr_get_child를 줄여서 sr_getc라는 매크로로 사용가능하다.

#define sr_append(group, mbr)     sr_add_list(group, mbr);

• sr_append : sr_group에 해당하는 sr를 추가한다.

int sr_get_num_child(const sr_t *sr_group);

ex) 
ecm_uint32 child_num = sr_get_num_child(sr_vmt);

• sr_get_num_child(const sr_t *sr_group) : 해당 sr에서 child 개수를 반환한다.

sr_t *sr_get_idx(const sr_t *sr_group, int idx);

ex) 
ecm_uint32 i = 0;
sr_t *tmp_sr = sr_get_idx(sr_vmt, i);

• sr_t *sr_get_idx(const sr_t *sr_group, int idx) : 해당 sr에서 해당 index의 sr을 반환한다. <dir> 밑에 있는 SR 변수들의 인덱스를 뜻함

ecm_int32 sr_get_int(const sr_t *sr);

• sr_get_int : 해당 sr에서 int 값을 반환한다.

const char *sr_get_str(const sr_t *sr);

• sr_get_str : 해당 sr에서 str 값을 반환한다.

/* get SR data value */
ecm_int32 sr_get_int(const sr_t *sr);
ecm_int64 sr_get_ll(const sr_t *sr);
ecm_double sr_get_dbl(const sr_t *sr);
const char *sr_get_str(const sr_t *sr);
char *sr_crop_str(sr_t *sr);
char *sr_dup_str(const sr_t *sr);
ecm_size_t sr_get_oct_size(const sr_t *sr);
ecm_ptr_t sr_get_oct_data(const sr_t *sr);
ecm_ptr_t sr_get_ptr(const sr_t *sr);
ECMBOOL sr_get_bool(const sr_t *sr);

• 기타 사용법은 EBCguide 를 참고하면 된다.
• libsr.h를 보면 자세히 나와있다.