zinfo.c

harvest是一个下载html网页得机器人

       record count, etc. is affected */
    if (key_flush)
	(*zei->updateFunc)(zei->updateHandle, drec, zad->data1_tree);

    node_attributesBySet = data1_mk_tag_uni (zei->dh, zei->nmem,
					   "attributesBySet", node_adinfo);
    set_min = -1;
    while (1)
    {
	data1_node *node_asd;
	data1_attset *attset;
	int set_ordinal = -1;
	for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
	{
	    if ((set_ordinal < 0 || set_ordinal > zsui->info.set)
		&& zsui->info.set > set_min)
		set_ordinal = zsui->info.set;
	}
	if (set_ordinal < 0)
	    break;
	set_min = set_ordinal;
	node_asd = data1_mk_tag (zei->dh, zei->nmem,
                                 "attributeSetDetails",
                                 0 /* attr */, node_attributesBySet);

	attset = data1_attset_search_id (zei->dh, set_ordinal);
	if (!attset)
	{
	    zebraExplain_loadAttsets (zei->dh, zei->res);
	    attset = data1_attset_search_id (zei->dh, set_ordinal);
	}
	if (attset)
	{
	    int oid[OID_SIZE];
	    oident oe;
	    
	    oe.proto = PROTO_Z3950;
	    oe.oclass = CLASS_ATTSET;
	    oe.value = (enum oid_value) set_ordinal;
	    
	    if (oid_ent_to_oid (&oe, oid))
	    {
		data1_node *node_abt, *node_atd, *node_atvs;
		data1_mk_tag_data_oid (zei->dh, node_asd, "oid",
				       oid, zei->nmem);
		
		node_abt = data1_mk_tag (zei->dh, zei->nmem,
                                         "attributesByType",
                                         0 /*attr */, node_asd);
		node_atd = data1_mk_tag (zei->dh, zei->nmem,
                                         "attributeTypeDetails", 
                                         0 /* attr */, node_abt);
		data1_mk_tag_data_int (zei->dh, node_atd,
				       "type", 1, zei->nmem);
		node_atvs = data1_mk_tag (zei->dh, zei->nmem, 
                                          "attributeValues",
                                          0 /* attr */, node_atd);
		writeAttributeValueDetails (zei, zad, node_atvs, attset);
	    }
	}
    }
    /* zebra info (private) */
    node_zebra = data1_mk_tag_uni (zei->dh, zei->nmem,
				 "zebraInfo", node_adinfo);
    node_list = data1_mk_tag_uni (zei->dh, zei->nmem,
				 "attrlist", node_zebra);
    for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
    {
	struct oident oident;
	int oid[OID_SIZE];
	data1_node *node_attr;
	
	node_attr = data1_mk_tag (zei->dh, zei->nmem, "attr", 0 /* attr */,
                                  node_list);
	
	oident.proto = PROTO_Z3950;
	oident.oclass = CLASS_ATTSET;
	oident.value = (enum oid_value) zsui->info.set;
	oid_ent_to_oid (&oident, oid);
	
	data1_mk_tag_data_text (zei->dh, node_attr, "set",
				oident.desc, zei->nmem);
	data1_mk_tag_data_int (zei->dh, node_attr, "use",
			       zsui->info.use, zei->nmem);
	data1_mk_tag_data_int (zei->dh, node_attr, "ordinal",
			       zsui->info.ordinal, zei->nmem);
    }
    /* convert to "SGML" and write it */
#if ZINFO_DEBUG
    data1_pr_tree (zei->dh, zad->data1_tree, stderr);
#endif
    sgml_buf = data1_nodetoidsgml(zei->dh, zad->data1_tree,
				  0, &sgml_len);
    drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
    memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
    drec->size[recInfo_storeData] = sgml_len;
    
    rec_put (zei->records, &drec);
}

static void zebraExplain_writeDatabase (ZebraExplainInfo zei,
                                        struct zebDatabaseInfoB *zdi,
					int key_flush)
{
    char *sgml_buf;
    int sgml_len;
    Record drec;
    data1_node *node_dbinfo, *node_count, *node_zebra;
    
    if (!zdi->dirty)
	return;

    zdi->dirty = 0;
#if ZINFO_DEBUG
    logf (LOG_LOG, "zebraExplain_writeDatabase %s", zdi->databaseName);
#endif
    drec = createRecord (zei->records, &zdi->sysno);
    assert (zdi->data1_database);

    node_dbinfo = data1_search_tag (zei->dh, zdi->data1_database,
                                    "/databaseInfo");

    assert (node_dbinfo);
    zebraExplain_updateCommonInfo (zei, node_dbinfo);
    zebraExplain_updateAccessInfo (zei, node_dbinfo, zdi->accessInfo);

    /* extract *searchable* keys from it. We do this here, because
       record count, etc. is affected */
    if (key_flush)
	(*zei->updateFunc)(zei->updateHandle, drec, zdi->data1_database);
    /* record count */
    node_count = data1_mk_tag_uni (zei->dh, zei->nmem,
				 "recordCount", node_dbinfo);
    data1_mk_tag_data_int (zei->dh, node_count, "recordCountActual",
			      zdi->recordCount, zei->nmem);

    /* zebra info (private) */
    node_zebra = data1_mk_tag_uni (zei->dh, zei->nmem,
				 "zebraInfo", node_dbinfo);
    data1_mk_tag_data_int (zei->dh, node_zebra,
			   "recordBytes", zdi->recordBytes, zei->nmem);
    /* convert to "SGML" and write it */
#if ZINFO_DEBUG
    data1_pr_tree (zei->dh, zdi->data1_database, stderr);
#endif
    sgml_buf = data1_nodetoidsgml(zei->dh, zdi->data1_database,
				  0, &sgml_len);
    drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
    memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
    drec->size[recInfo_storeData] = sgml_len;
    
    rec_put (zei->records, &drec);
}

static void writeAttributeValues (ZebraExplainInfo zei,
				  data1_node *node_values,
				  data1_attset *attset)
{
    data1_att *atts;
    data1_attset_child *c;

    if (!attset)
	return;

    for (c = attset->children; c; c = c->next)
	writeAttributeValues (zei, node_values, c->child);
    for (atts = attset->atts; atts; atts = atts->next)
    {
	data1_node *node_value;
	
	node_value = data1_mk_tag (zei->dh, zei->nmem, "attributeValue",
                                   0 /* attr */, node_values);
	data1_mk_tag_data_text (zei->dh, node_value, "name",
				atts->name, zei->nmem);
        node_value = data1_mk_tag (zei->dh, zei->nmem, "value",
                                   0 /* attr */, node_value);
	data1_mk_tag_data_int (zei->dh, node_value, "numeric",
			       atts->value, zei->nmem);
    }
}


static void zebraExplain_writeAttributeSet (ZebraExplainInfo zei,
					    zebAccessObject o,
					    int key_flush)
{
    char *sgml_buf;
    int sgml_len;
    Record drec;
    data1_node *node_root, *node_attinfo, *node_attributes, *node_atttype;
    data1_node *node_values;
    struct oident *entp;
    struct data1_attset *attset = NULL;
    
    if ((entp = oid_getentbyoid (o->oid)))
	attset = data1_attset_search_id (zei->dh, entp->value);
	    
#if ZINFO_DEBUG
    logf (LOG_LOG, "zebraExplain_writeAttributeSet %s",
	  attset ? attset->name : "<unknown>");    
#endif

    drec = createRecord (zei->records, &o->sysno);
    node_root =
	data1_read_sgml (zei->dh, zei->nmem,
			 "<explain><attributeSetInfo>AttributeSetInfo\n"
			 "</></>\n" );

    node_attinfo = data1_search_tag (zei->dh, node_root,
				   "/attributeSetInfo");

    assert (node_attinfo);
    zebraExplain_initCommonInfo (zei, node_attinfo);
    zebraExplain_updateCommonInfo (zei, node_attinfo);

    data1_mk_tag_data_oid (zei->dh, node_attinfo,
			    "oid", o->oid, zei->nmem);
    if (attset && attset->name)
	data1_mk_tag_data_text (zei->dh, node_attinfo,
				"name", attset->name, zei->nmem);
    
    node_attributes = data1_mk_tag_uni (zei->dh, zei->nmem,
				      "attributes", node_attinfo);
    node_atttype = data1_mk_tag_uni (zei->dh, zei->nmem,
				   "attributeType", node_attributes);
    data1_mk_tag_data_text (zei->dh, node_atttype,
			    "name", "Use", zei->nmem);
    data1_mk_tag_data_text (zei->dh, node_atttype,
			    "description", "Use Attribute", zei->nmem);
    data1_mk_tag_data_int (zei->dh, node_atttype,
			   "type", 1, zei->nmem);
    node_values = data1_mk_tag (zei->dh, zei->nmem,
                                "attributeValues", 0 /* attr */, node_atttype);
    if (attset)
	writeAttributeValues (zei, node_values, attset);

    /* extract *searchable* keys from it. We do this here, because
       record count, etc. is affected */
    if (key_flush)
	(*zei->updateFunc)(zei->updateHandle, drec, node_root);
    /* convert to "SGML" and write it */
#if ZINFO_DEBUG
    data1_pr_tree (zei->dh, node_root, stderr);
#endif
    sgml_buf = data1_nodetoidsgml(zei->dh, node_root, 0, &sgml_len);
    drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
    memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
    drec->size[recInfo_storeData] = sgml_len;
    
    rec_put (zei->records, &drec);
}

static void zebraExplain_writeTarget (ZebraExplainInfo zei, int key_flush)
{
    struct zebDatabaseInfoB *zdi;
    data1_node *node_tgtinfo, *node_list, *node_zebra;
    Record trec;
    int sgml_len;
    char *sgml_buf;

    if (!zei->dirty)
	return;
    zei->dirty = 0;

    trec = rec_get (zei->records, 1);
    xfree (trec->info[recInfo_storeData]);

    node_tgtinfo = data1_search_tag (zei->dh, zei->data1_target,
                                     "/targetInfo");
    assert (node_tgtinfo);

    zebraExplain_updateCommonInfo (zei, node_tgtinfo);
    zebraExplain_updateAccessInfo (zei, node_tgtinfo, zei->accessInfo);

    /* convert to "SGML" and write it */
    if (key_flush)
	(*zei->updateFunc)(zei->updateHandle, trec, zei->data1_target);

    node_zebra = data1_mk_tag_uni (zei->dh, zei->nmem,
				 "zebraInfo", node_tgtinfo);
    data1_mk_tag_data_text (zei->dh, node_zebra, "version",
			       ZEBRAVER, zei->nmem);
    node_list = data1_mk_tag (zei->dh, zei->nmem,
                              "databaseList", 0 /* attr */, node_zebra);
    for (zdi = zei->databaseInfo; zdi; zdi = zdi->next)
    {
	data1_node *node_db;
	node_db = data1_mk_tag (zei->dh, zei->nmem,
                                "database", 0 /* attr */, node_list);
	data1_mk_tag_data_text (zei->dh, node_db, "name",
                                zdi->databaseName, zei->nmem);
	data1_mk_tag_data_int (zei->dh, node_db, "id",
                               zdi->sysno, zei->nmem);
	data1_mk_tag_data_int (zei->dh, node_db, "attributeDetailsId",
                               zdi->attributeDetails->sysno, zei->nmem);
    }
    data1_mk_tag_data_int (zei->dh, node_zebra, "ordinalSU",
                           zei->ordinalSU, zei->nmem);

    data1_mk_tag_data_int (zei->dh, node_zebra, "runNumber",
			      zei->runNumber, zei->nmem);

#if ZINFO_DEBUG
    data1_pr_tree (zei->dh, zei->data1_target, stderr);
#endif
    sgml_buf = data1_nodetoidsgml(zei->dh, zei->data1_target,
				  0, &sgml_len);
    trec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
    memcpy (trec->info[recInfo_storeData], sgml_buf, sgml_len);
    trec->size[recInfo_storeData] = sgml_len;
    
    rec_put (zei->records, &trec);
}

int zebraExplain_lookupSU (ZebraExplainInfo zei, int set, int use)
{
    struct zebSUInfoB *zsui;

    assert (zei->curDatabaseInfo);
    for (zsui = zei->curDatabaseInfo->attributeDetails->SUInfo;
	 zsui; zsui=zsui->next)
        if (zsui->info.use == use && zsui->info.set == set)
            return zsui->info.ordinal;
    return -1;
}

int zebraExplain_trav_ord(ZebraExplainInfo zei, void *handle,
			  int (*f)(void *handle, int ord))
{
    struct zebDatabaseInfoB *zdb = zei->curDatabaseInfo;
    if (zdb)
    {
	struct zebSUInfoB *zsui = zdb->attributeDetails->SUInfo;
	for ( ;zsui; zsui = zsui->next)
	    (*f)(handle,  zsui->info.ordinal);
    }
    return 0;
}
			  
int zebraExplain_lookup_ord (ZebraExplainInfo zei, int ord,
			     const char **db, int *set, int *use)
{
    struct zebDatabaseInfoB *zdb;
    for (zdb = zei->databaseInfo; zdb; zdb = zdb->next)
    {
	struct zebSUInfoB *zsui = zdb->attributeDetails->SUInfo;
	for ( ;zsui; zsui = zsui->next)
	    if (zsui->info.ordinal == ord)
	    {
		*db = zdb->databaseName;
		*set = zsui->info.set;
		*use = zsui->info.use;
		return 0;
	    }
    }
    return -1;
}

zebAccessObject zebraExplain_announceOid (ZebraExplainInfo zei,
					  zebAccessObject *op,
					  Odr_oid *oid)
{
    zebAccessObject ao;
    
    for (ao = *op; ao; ao = ao->next)
	if (!oid_oidcmp (oid, ao->oid))
	    break;
    if (!ao)
    {
	ao = (zebAccessObject) nmem_malloc (zei->nmem, sizeof(*ao));
	ao->handle = NULL;
	ao->sysno = 0;
	ao->oid = odr_oiddup_nmem (zei->nmem, oid);
	ao->next = *op;
	*op = ao;
    }
    return ao;
}

void zebraExplain_addAttributeSet (ZebraExplainInfo zei, int set)
{
    oident oe;
    int oid[OID_SIZE];

    oe.proto = PROTO_Z3950;
    oe.oclass = CLASS_ATTSET;
    oe.value = (enum oid_value) set;

    if (oid_ent_to_oid (&oe, oid))
    {
	zebraExplain_announceOid (zei, &zei->accessInfo->attributeSetIds, oid);
	zebraExplain_announceOid (zei, &zei->curDatabaseInfo->
				  accessInfo->attributeSetIds, oid);
    }
}

int zebraExplain_addSU (ZebraExplainInfo zei, int set, int use)
{
    struct zebSUInfoB *zsui;

    assert (zei->curDatabaseInfo);
    for (zsui = zei->curDatabaseInfo->attributeDetails->SUInfo;
	 zsui; zsui=zsui->next)
        if (zsui->info.use == use && zsui->info.set == set)
            return -1;
    zebraExplain_addAttributeSet (zei, set);
    zsui = (struct zebSUInfoB *) nmem_malloc (zei->nmem, sizeof(*zsui));
    zsui->next = zei->curDatabaseInfo->attributeDetails->SUInfo;
    zei->curDatabaseInfo->attributeDetails->SUInfo = zsui;
    zei->curDatabaseInfo->attributeDetails->dirty = 1;
    zei->dirty = 1;
    zsui->info.set = set;
    zsui->info.use = use;
    zsui->info.ordinal = (zei->ordinalSU)++;
    return zsui->info.ordinal;
}

void zebraExplain_addSchema (ZebraExplainInfo zei, Odr_oid *oid)
{
    zebraExplain_announceOid (zei, &zei->accessInfo->schemas, oid);
    zebraExplain_announceOid (zei, &zei->curDatabaseInfo->
			      accessInfo->schemas, oid);
}

void zebraExplain_recordBytesIncrement (ZebraExplainInfo zei, int adjust_num)
{
    assert (zei->curDatabaseInfo);

    if (adjust_num)
    {
	zei->curDatabaseInfo->recordBytes += adjust_num;
	zei->curDatabaseInfo->dirty = 1;
    }
}

void zebraExplain_recordCountIncrement (ZebraExplainInfo zei, int adjust_num)
{
    assert (zei->curDatabaseInfo);

    if (adjust_num)
    {
	zei->curDatabaseInfo->recordCount += adjust_num;
	zei->curDatabaseInfo->dirty = 1;
    }
}

int zebraExplain_runNumberIncrement (ZebraExplainInfo zei, int adjust_num)
{
    if (adjust_num)
    {
	zei->dirty = 1;
    }
    return zei->runNumber += adjust_num;
}

RecordAttr *rec_init_attr (ZebraExplainInfo zei, Record rec)
{
    RecordAttr *recordAttr;

    if (rec->info[recInfo_attr])
	return (RecordAttr *) rec->info[recInfo_attr];
    recordAttr = (RecordAttr *) xmalloc (sizeof(*recordAttr));
    rec->info[recInfo_attr] = (char *) recordAttr;
    rec->size[recInfo_attr] = sizeof(*recordAttr);
    
    recordAttr->recordSize = 0;
    recordAttr->recordOffset = 0;
    recordAttr->runNumber = zei->runNumber;
    return recordAttr;
}

static void att_loadset(void *p, const char *n, const char *name)
{
    data1_handle dh = (data1_handle) p;
    if (!data1_get_attset (dh, name))
	logf (LOG_WARN, "Directive attset failed for %s", name);
}

void zebraExplain_loadAttsets (data1_handle dh, Res res)
{
    res_trav(res, "attset", dh, att_loadset);
}

/*
     zebraExplain_addSU adds to AttributeDetails for a database and
     adds attributeSet (in AccessInfo area) to DatabaseInfo if it doesn't
     exist for the database.

     If the database doesn't exist globally (in TargetInfo) an 
     AttributeSetInfo must be added (globally).
 */