Exemplo n.º 1
0
/*
	Just try locking/unlocking a single record once
*/
static void fetch_lock_once(struct ctdb_context *ctdb, struct event_context *ev, uint32_t generation)
{
	TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
	TDB_DATA key, data;
	struct ctdb_record_handle *h;
	struct ctdb_ltdb_header *header;
	int ret;

	key.dptr = discard_const(TESTKEY);
	key.dsize = strlen(TESTKEY);

	printf("Trying to fetch lock the record ...\n");

	h = ctdb_fetch_readonly_lock(ctdb_db, tmp_ctx, key, &data, false);
	if (h == NULL) {
		printf("Failed to fetch record '%s' on node %d\n", 
	       		(const char *)key.dptr, ctdb_get_pnn(ctdb));
		talloc_free(tmp_ctx);
		exit(10);
	}

	printf("Record fetchlocked.\n");
	header = talloc_memdup(tmp_ctx, ctdb_header_from_record_handle(h), sizeof(*header));
       	printf("RSN:%d\n", (int)header->rsn);
	talloc_free(h);
	printf("Record released.\n");

	printf("Write new record with RSN+10\n");
	header->rsn += 10;
	data.dptr = (void *)talloc_asprintf(tmp_ctx, "%d", (int)header->rsn);
	data.dsize = strlen((char *)data.dptr);

	ret = ctdb_ctrl_updaterecord(ctdb, ctdb, timeval_zero(), CTDB_CURRENT_NODE, ctdb_db, key, header, data);
	if (ret != 0) {
		printf("Failed to writerecord,  ret==%d\n", ret);	
		exit(1);
	}

	printf("re-fetch the record\n");
	h = ctdb_fetch_lock(ctdb_db, tmp_ctx, key, &data);
	if (h == NULL) {
		printf("Failed to fetch record '%s' on node %d\n", 
	       		(const char *)key.dptr, ctdb_get_pnn(ctdb));
		talloc_free(tmp_ctx);
		exit(10);
	}

	printf("Record fetchlocked.\n");
	header = talloc_memdup(tmp_ctx, ctdb_header_from_record_handle(h), sizeof(*header));
       	printf("RSN:%d\n", (int)header->rsn);
	talloc_free(h);
	printf("Record released.\n");

	talloc_free(tmp_ctx);
}
Exemplo n.º 2
0
static void store_records(struct ctdb_context *ctdb, struct event_context *ev)
{
    TDB_DATA key, data;
    struct ctdb_db_context *ctdb_db;
    TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
    int ret;
    struct ctdb_record_handle *h;
    uint32_t i=0;

    ctdb_db = ctdb_db_handle(ctdb, "test.tdb");

    srandom(time(NULL) ^ getpid());

    start_timer();

    printf("working with %d records\n", num_records);
    while (1) {
        unsigned r = random() % num_records;
        key.dptr = (uint8_t *)&r;
        key.dsize = sizeof(r);

        h = ctdb_fetch_lock(ctdb_db, tmp_ctx, key, &data);
        if (h == NULL) {
            printf("Failed to fetch record '%s' on node %d\n",
                   (const char *)key.dptr, ctdb_get_pnn(ctdb));
            talloc_free(tmp_ctx);
            return;
        }

        if (random() % 100 < delete_pct) {
            data.dptr = NULL;
            data.dsize = 0;
        } else {
            data.dptr = talloc_zero_size(h, data.dsize + sizeof(r));
            data.dsize += sizeof(r);
        }

        ret = ctdb_record_store(h, data);
        if (ret != 0) {
            printf("Failed to store record\n");
        }

        if (data.dptr == NULL && data.dsize == 0) {
            struct ctdb_control_schedule_for_deletion *dd;
            TDB_DATA indata;
            int32_t status;

            indata.dsize = offsetof(struct ctdb_control_schedule_for_deletion, key) + key.dsize;
            indata.dptr = talloc_zero_array(ctdb, uint8_t, indata.dsize);
            if (indata.dptr == NULL) {
                printf("out of memory\n");
                exit(1);
            }
            dd = (struct ctdb_control_schedule_for_deletion *)(void *)indata.dptr;
            dd->db_id = ctdb_db->db_id;
            dd->hdr = *ctdb_header_from_record_handle(h);
            dd->keylen = key.dsize;
            memcpy(dd->key, key.dptr, key.dsize);

            ret = ctdb_control(ctdb,
                               CTDB_CURRENT_NODE,
                               ctdb_db->db_id,
                               CTDB_CONTROL_SCHEDULE_FOR_DELETION,
                               0, /* flags */
                               indata,
                               NULL, /* mem_ctx */
                               NULL, /* outdata */
                               &status,
                               NULL, /* timeout : NULL == wait forever */
                               NULL); /* error message */

            talloc_free(indata.dptr);

            if (ret != 0 || status != 0) {
                DEBUG(DEBUG_ERR, (__location__ " Error sending "
                                  "SCHEDULE_FOR_DELETION "
                                  "control.\n"));
            }
        }

        talloc_free(h);

        if (i % 1000 == 0) {
            printf("%7.0f recs/second   %u total\r", 1000.0 / end_timer(), i);
            fflush(stdout);
            start_timer();
        }
        i++;
    }

    talloc_free(tmp_ctx);
}
Exemplo n.º 3
0
static void store_records(struct ctdb_context *ctdb, struct event_context *ev)
{
	TDB_DATA key, data;
	struct ctdb_db_context *ctdb_db;
	TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
	int ret;
	struct ctdb_record_handle *h;
	uint32_t i;
	
	ctdb_db = ctdb_db_handle(ctdb, "test.tdb");

	printf("creating %d records\n", num_records);
	for (i=0;i<num_records;i++) {
		int r = base_rec + i;
		key.dptr = (uint8_t *)&r;
		key.dsize = sizeof(uint32_t); 

		h = ctdb_fetch_lock(ctdb_db, tmp_ctx, key, &data);
		if (h == NULL) {
			printf("Failed to fetch record '%s' on node %d\n", 
			       (const char *)key.dptr, ctdb_get_pnn(ctdb));
			talloc_free(tmp_ctx);
			return;
		}

		data.dptr = (uint8_t *)&i;
		data.dsize = sizeof(uint32_t);

		ret = ctdb_record_store(h, data);
		talloc_free(h);
		if (ret != 0) {
			printf("Failed to store record\n");
		}
		if (i % 1000 == 0) {
			printf("%u\r", i);
			fflush(stdout);
		}
	}

	printf("fetching all %d records\n", num_records);
	while (1) {
		for (i=0;i<num_records;i++) {
			int r = base_rec + i;
			key.dptr = (uint8_t *)&r;
			key.dsize = sizeof(uint32_t); 

			h = ctdb_fetch_lock(ctdb_db, tmp_ctx, key, &data);
			if (h == NULL) {
				printf("Failed to fetch record '%s' on node %d\n", 
				       (const char *)key.dptr, ctdb_get_pnn(ctdb));
				talloc_free(tmp_ctx);
				return;
			}
			talloc_free(h);
		}
		sleep(1);
		printf(".");
		fflush(stdout);
	}

	talloc_free(tmp_ctx);
}