int main(int argc, char *argv[])
{
NEOERR *err;
HDF *hdf, *h2;
err = hdf_init(&hdf);
if (err != STATUS_OK)
{
nerr_log_error(err);
return -1;
}
err = hdf_set_value(hdf, "CGI.Foo", "Bar");
if (err)
{
nerr_log_error(err);
return -1;
}
err = hdf_set_value(hdf, "CGI.Foo", "Baz");
if (err)
{
nerr_log_error(err);
return -1;
}
h2 = hdf_get_obj(hdf, "CGI");
err = hdf_set_value(h2, "Foo", "Bang");
hdf_dump(hdf, NULL);
hdf_destroy(&hdf);
return 0;
}
int main(int argc, char *argv[])
{
int ret;
if (argc != 5) {
printf("Usage: %s HOST PORT EVENT_NAME CONFIG_FILE\n", argv[0]);
return 1;
}
settings.smsalarm = 0;
//settings.logfname = "-";
log_init();
if (config_parse_file(argv[4], &g_cfg) != 1) {
printf("parse config file %s failure", argv[3]);
return 1;
}
mevent_t *evt = mevent_init(argv[3]);
if (evt == NULL) {
printf("init error\n");
SMS_ALARM("mevent_init error");
return 1;
}
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 800000;
mevent_add_udp_server(evt, argv[1], atoi(argv[2]), NULL, &tv);
ret = mevent_trigger(evt, NULL, REQ_CMD_STATS, FLAGS_SYNC);
if (PROCESS_OK(ret)) {
hdf_dump(evt->hdfrcv, NULL);
} else {
int try = 0;
redo:
sleep(10);
ret = mevent_trigger(evt, NULL, REQ_CMD_STATS, FLAGS_SYNC);
if (PROCESS_NOK(ret) && try < 3) {
try++;
goto redo;
}
if (PROCESS_NOK(ret) && try >= 3) {
printf("process failure %d\n", ret);
SMS_ALARM("process failure %d, restarted", ret);
system("killall -9 mevent; sleep 2; /usr/local/revive/xport/daemon/mevent -c /usr/local/revive/xport/conf/server.hdf");
} else {
printf("process temproray error %d, %d", ret, try);
}
}
mevent_free(evt);
return 0;
}
int main(void) {
HDF *hdf_1, *hdf_2;
HDF *cur_node,*last_node;
hdf_init(&hdf_1);
hdf_read_file(hdf_1,"hdf_copy_test.hdf");
hdf_dump(hdf_1,NULL);
cur_node = hdf_get_obj(hdf_1,"Chart");
last_node = cur_node;
cur_node = hdf_get_obj(cur_node,"next_stage");
while (hdf_get_obj(cur_node,"next_stage") && strcmp(hdf_get_value(cur_node,"Bucket.FieldId",""),"QUEUE")) {
last_node = cur_node;
cur_node = hdf_get_obj(cur_node,"next_stage");
}
if (hdf_get_obj(cur_node,"next_stage")) {
hdf_copy(hdf_1,"TempHolderPlace",hdf_get_obj(cur_node,"next_stage"));
}
ne_warn("Delete tree from node: %s", hdf_obj_name(last_node));
hdf_remove_tree(last_node,"next_stage");
hdf_dump(hdf_1,NULL);
fprintf(stderr,"-----------------\n");
hdf_copy(last_node,"next_stage",hdf_get_obj(hdf_1,"TempHolderPlace"));
hdf_dump(hdf_1,NULL);
/* Test copy and destroy, make sure we actually copy everything and
* don't reference anything */
hdf_init(&hdf_2);
hdf_copy(hdf_2, "", hdf_1);
hdf_destroy(&hdf_1);
hdf_dump(hdf_2, NULL);
hdf_destroy(&hdf_2);
return 0;
}
void TestSort(HDF* hdf)
{
int i;
float value;
for (i=0;i<15;i++)
{
value = rand()/(RAND_MAX+1.0);
hdf_set_valuef(hdf, "test.%d=%d", i, i);
hdf_set_valuef(hdf, "test.%d.name=item #%d", i, i);
hdf_set_valuef(hdf, "test.%d.val=%f", i, value );
}
hdf_dump(hdf,NULL);
hdf_sort_obj(hdf_get_obj(hdf, "test"), TestCompare);
hdf_dump(hdf,NULL);
}
int main(int argc, char *argv[])
{
NEOERR *err;
HDF *hdf;
double tstart = 0;
err = hdf_init(&hdf);
if (err != STATUS_OK)
{
nerr_log_error(err);
return -1;
}
tstart = ne_timef();
TestSort(hdf);
ne_warn("sort took %5.5fs", ne_timef() - tstart);
hdf_dump(hdf, NULL);
hdf_destroy(&hdf);
return 0;
}
int main (int argc, char *argv[])
{
NEOERR *err;
CSPARSE *parse;
HDF *hdf;
int verbose = 0;
char *hdf_file, *cs_file;
if (argc < 3)
{
ne_warn ("Usage: cstest [-v] <file.hdf> <file.cs>");
return -1;
}
if (!strcmp(argv[1], "-v"))
{
verbose = 1;
if (argc < 4)
{
ne_warn ("Usage: cstest [-v] <file.hdf> <file.cs>");
return -1;
}
hdf_file = argv[2];
cs_file = argv[3];
}
else
{
hdf_file = argv[1];
cs_file = argv[2];
}
err = hdf_init(&hdf);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = hdf_read_file(hdf, hdf_file);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
printf ("Parsing %s\n", cs_file);
err = cs_init (&parse, hdf);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = cgi_register_strfuncs(parse);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = cs_parse_file (parse, cs_file);
if (err != STATUS_OK)
{
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
err = cs_render(parse, NULL, output);
if (err != STATUS_OK)
{
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
if (verbose)
{
printf ("\n-----------------------\nCS DUMP\n");
err = cs_dump(parse, NULL, output);
}
cs_destroy (&parse);
if (verbose)
{
printf ("\n-----------------------\nHDF DUMP\n");
hdf_dump (hdf, NULL);
}
hdf_destroy(&hdf);
return 0;
}
int main(int argc, char *argv[])
{
NEOERR *err;
HDF *hdf;
int x;
char name[256];
char value[256];
double tstart = 0;
err = hdf_init(&hdf);
DIE_NOT_OK(err);
err = hdf_set_value (hdf, "Beware", "1");
DIE_NOT_OK(err);
err = hdf_set_value (hdf, "Beware.The", "2");
DIE_NOT_OK(err);
err = hdf_set_valuef (hdf, "Beware.The.%s=%d", "Ides", 3);
DIE_NOT_OK(err);
err = hdf_set_value (hdf, "Beware.Off", "4");
DIE_NOT_OK(err);
err = hdf_set_value (hdf, "Beware.The.Ides.Of", "5");
DIE_NOT_OK(err);
err = hdf_set_value (hdf, "Beware.The.Butter", "6");
DIE_NOT_OK(err);
err = hdf_set_attr (hdf, "Beware.The.Butter", "Lang", "en");
DIE_NOT_OK(err);
err = hdf_set_attr (hdf, "Beware.The.Butter", "Lang", "1");
DIE_NOT_OK(err);
err = hdf_set_attr (hdf, "Beware.The.Butter", "Lang", NULL);
DIE_NOT_OK(err);
err = hdf_read_file (hdf, "test.hdf");
DIE_NOT_OK(err);
hdf_dump(hdf, NULL);
x = hdf_get_int_value (hdf, "Beware.The.Ides", 0);
if (x != 3)
{
ne_warn("hdf_get_int_value returned %d, expected 3", x);
return -1;
}
/* test symlinks */
{
const char *v;
err = hdf_set_value(hdf, "Destination.Foo", "bar");
DIE_NOT_OK(err);
err = hdf_set_symlink(hdf, "Symlink.baz", "Destination.Foo");
DIE_NOT_OK(err);
v = hdf_get_value(hdf, "Symlink.baz", "notfound");
if (strcmp(v, "bar")) {
ne_warn("hdf_get_value through symlink returned %s, expected bar", v);
return -1;
}
err = hdf_set_value(hdf, "Symlink.baz", "newvalue");
DIE_NOT_OK(err);
v = hdf_get_value(hdf, "Symlink.baz", "notfound");
if (strcmp(v, "newvalue")) {
ne_warn("hdf_get_value through symlink returned %s, expected newvalue",
v);
return -1;
}
err = hdf_set_value(hdf, "Symlink.baz.too", "newtoo");
DIE_NOT_OK(err);
v = hdf_get_value(hdf, "Symlink.baz.too", "newtoo");
if (strcmp(v, "newtoo")) {
ne_warn("hdf_get_value through symlink returned %s, expected newtoo",
v);
return -1;
}
v = hdf_get_value(hdf, "Destination.Foo.too", "newtoo");
if (strcmp(v, "newtoo")) {
ne_warn("hdf_get_value through symlink returned %s, expected newtoo",
v);
return -1;
}
}
for (x = 0; x < 10000; x++)
{
rand_name(name, sizeof(name));
neo_rand_word(value, sizeof(value));
/* ne_warn("Setting %s = %s", name, value); */
err = hdf_set_value (hdf, name, value);
DIE_NOT_OK(err);
}
tstart = ne_timef();
hdf_sort_obj(hdf, sortByName);
ne_warn("sort took %5.5fs", ne_timef() - tstart);
hdf_dump(hdf, NULL);
hdf_destroy(&hdf);
return 0;
}
int main(int argc, char **argv, char **envp)
{
struct json_object *jso;
HDF *node;
bson *doc;
NEOERR *err;
mtc_init("hdftest");
mtimer_start();
for (int i = 0; i < NUM_TOTAL_TEST; i++) {
hdf_init(&node);
//err = mjson_string_to_hdf(node, bdatam);
OUTPUT_NOK(err);
if (VERBERSE) hdf_dump(node, NULL);
hdf_destroy(&node);
}
mtimer_stop("json => hdf");
mtc_foo("%d per second", (int)(NUM_TOTAL_TEST/(elapsed/1000000.0f)));
mtimer_start();
for (int i = 0; i < NUM_TOTAL_TEST; i++) {
doc = mbson_new_from_string(bdatam, true);
if (!doc) printf("bson error");
if (VERBERSE) printf("%s\n", mbson_string(doc));
bson_free(doc);
}
mtimer_stop("json => bson");
mtc_foo("%d per second", (int)(NUM_TOTAL_TEST/(elapsed/1000000.0f)));
hdf_init(&node);
hdf_set_value(node, NULL, bdatam);
//err = mjson_string_to_hdf(node, bdatam);
OUTPUT_NOK(err);
mtimer_start();
for (int i = 0; i < NUM_TOTAL_TEST; i++) {
err = mjson_import_from_hdf(node, &jso);
OUTPUT_NOK(err);
if (VERBERSE) printf("%s\n", json_object_to_json_string(jso));
json_object_put(jso);
}
mtimer_stop("hdf => json");
mtc_foo("%d per second", (int)(NUM_TOTAL_TEST/(elapsed/1000000.0f)));
mtimer_start();
for (int i = 0; i < NUM_TOTAL_TEST; i++) {
err = mbson_import_from_hdf(node, &doc, true);
OUTPUT_NOK(err);
if (VERBERSE) printf("%s\n", mbson_string(doc));
bson_free(doc);
}
mtimer_stop("hdf => bson");
mtc_foo("%d per second", (int)(NUM_TOTAL_TEST/(elapsed/1000000.0f)));
doc = mbson_new_from_string(bdatam, true);
if (!doc) printf("bson error");
mtimer_start();
for (int i = 0; i < NUM_TOTAL_TEST; i++) {
char *s = mbson_string(doc);
if (!s) printf("bson->string error");
if (VERBERSE) printf("%s\n", s);
free(s);
}
mtimer_stop("bson => json");
mtc_foo("%d per second", (int)(NUM_TOTAL_TEST/(elapsed/1000000.0f)));
mtimer_start();
for (int i = 0; i < NUM_TOTAL_TEST; i++) {
hdf_init(&node);
//err = mbson_export_to_hdf(node, doc, false, false);
OUTPUT_NOK(err);
if (VERBERSE) hdf_dump(node, NULL);
hdf_destroy(&node);
}
mtimer_stop("bson => hdf");
//mtc_foo("%d per second", (int)(NUM_TOTAL_TEST/(elapsed/1000000.0f)));
bson_free(doc);
return 0;
}
int main (int argc, char *argv[])
{
NEOERR *err;
CSPARSE *parse;
HDF *hdf;
int verbose = 0;
char *hdf_file, *cs_file;
char c;
extern char *optarg;
err = hdf_init(&hdf);
if (err != STATUS_OK)
{
nerr_warn_error(err);
return -1;
}
err = cs_init (&parse, hdf);
if (err != STATUS_OK) {
nerr_warn_error(err);
return -1;
}
while ((c = getopt(argc, argv, "Hvh:c:")) != EOF )
switch (c) {
case 'h':
hdf_file=optarg;
err = hdf_read_file(hdf, hdf_file);
if (err != STATUS_OK) {
nerr_warn_error(err);
return -1;
}
break;
case 'c':
cs_file=optarg;
if ( verbose )
printf ("Parsing %s\n", cs_file);
err = cs_parse_file (parse, cs_file);
if (err != STATUS_OK) {
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
break;
case 'v':
verbose=1;
break;
case 'H':
fprintf(stderr, "Usage: %s [-v] [-h <file.hdf>] [-c <file.cs>]\n", argv[0]);
fprintf(stderr, " -h <file.hdf> load hdf file file.hdf (multiple allowed)\n");
fprintf(stderr, " -c <file.cs> load cs file file.cs (multiple allowed)\n");
fprintf(stderr, " -v verbose output\n");
return -1;
break;
}
err = cs_render(parse, NULL, output);
if (err != STATUS_OK) {
err = nerr_pass(err);
nerr_warn_error(err);
return -1;
}
if (verbose) {
printf ("\n-----------------------\nCS DUMP\n");
err = cs_dump(parse, NULL, output);
}
cs_destroy (&parse);
if (verbose) {
printf ("\n-----------------------\nHDF DUMP\n");
hdf_dump (hdf, NULL);
}
return 0;
}
