ssize_t handler_get(gfcontext_t *ctx, char *path, void* arg){
	int fildes;
	ssize_t file_len, bytes_transferred;
	ssize_t read_len, write_len;
	char buffer[BUFFER_SIZE];

	if( 0 > (fildes = content_get(path)))
		return gfs_sendheader(ctx, GF_FILE_NOT_FOUND, 0);

	/* Calculating the file size */
	file_len = lseek(fildes, 0, SEEK_END);

	gfs_sendheader(ctx, GF_OK, file_len);

	/* Sending the file contents chunk by chunk. */
	bytes_transferred = 0;
	while(bytes_transferred < file_len){
		read_len = pread(fildes, buffer, BUFFER_SIZE, bytes_transferred);
		if (read_len <= 0){
			fprintf(stderr, "handle_with_file read error, %zd, %zu, %zu", read_len, bytes_transferred, file_len );
			gfs_abort(ctx);
			return -1;
		}
		write_len = gfs_send(ctx, buffer, read_len);
		if (write_len != read_len){
			fprintf(stderr, "handle_with_file write error");
			gfs_abort(ctx);
			return -1;
		}
		bytes_transferred += write_len;
	}

	return bytes_transferred;
}
Пример #2
0
ssize_t handle_with_file(gfcontext_t *ctx, char *path, void* arg){
	int fildes;
	size_t file_len, bytes_transferred;
	ssize_t read_len, write_len;
	char buffer[4096];
	char *data_dir = arg;

	strcpy(buffer,data_dir);
	strcat(buffer,path);

	if( 0 > (fildes = open(buffer, O_RDONLY))){
		if (errno == ENOENT)
			/* If the file just wasn't found, then send FILE_NOT_FOUND code*/ 
			return gfs_sendheader(ctx, GF_FILE_NOT_FOUND, 0);
		else
			/* Otherwise, it must have been a server error. gfserver library will handle*/ 
			return EXIT_FAILURE;
	}

	/* Calculating the file size */
	file_len = lseek(fildes, 0, SEEK_END);
	lseek(fildes, 0, SEEK_SET);

	gfs_sendheader(ctx, GF_OK, file_len);

	/* Sending the file contents chunk by chunk. */
	bytes_transferred = 0;
	while(bytes_transferred < file_len){
		read_len = read(fildes, buffer, 4096);
		if (read_len <= 0){
			fprintf(stderr, "handle_with_file read error, %zd, %zu, %zu", read_len, bytes_transferred, file_len );
			return EXIT_FAILURE;
		}
		write_len = gfs_send(ctx, buffer, read_len);
		if (write_len != read_len){
			fprintf(stderr, "handle_with_file write error");
			return EXIT_FAILURE;
		}
		bytes_transferred += write_len;
	}

	return bytes_transferred;
}
Пример #3
0
ssize_t handle_with_cache(gfcontext_t *ctx, char *path, void* arg)
{
	mqd_t msg_q;
	void *mem;
	struct request_info *req;
	struct shm_info *shm_blk;
	sem_t *sem1;
	sem_t *sem2;
	int file_in_cache;
	size_t file_size = 0;
	size_t bytes_transferred = 0;
	ssize_t write_len;
	size_t cache_file_size;

	pthread_mutex_lock(seg_q_mutex);
	while (steque_isempty(seg_q)) {
		pthread_cond_wait(seg_q_cond, seg_q_mutex);
	}
	shm_blk = (struct shm_info *)steque_pop(seg_q);
	pthread_mutex_unlock(seg_q_mutex);

	if ((sem1 = sem_open(shm_blk->sem1_name, O_CREAT, 0644, 0)) ==
	    SEM_FAILED) {
		perror("sem_open");
		return -1;
    	}
    	if ((sem2 = sem_open(shm_blk->sem2_name, O_CREAT, 0644, 0)) ==
	    SEM_FAILED) {
		perror("sem_open");
		return -1;
    	}
retry:
	errno = 0;
	msg_q = mq_open(QUEUE_NAME, O_WRONLY);
	if (msg_q == -1) {
		if (errno == ENOENT || errno == EACCES) {
			/* simplecached isn't ready yet, sleep and then retry */
			fprintf(stdout, "waiting for simplecached\n");
			sleep(2);
			goto retry;
		}
		perror("mq_open");
		return -1;
	}

	mem = mmap(NULL, seg_size, PROT_READ | PROT_WRITE, MAP_SHARED,
	    shm_blk->memfd, 0);
	if (!mem) {
		perror("mmap");
		return -1;
	}
	req = malloc(sizeof(*req) + strlen(path) + 1);
	memcpy(&req->mem_i, (char *)shm_blk + sizeof(int), sizeof(req->mem_i));
	req->mem_size = seg_size;
	req->file_len = strlen(path) + 1;
	strncpy(req->file_path, path, strlen(path));
	req->file_path[strlen(path)] = '\0';
	mq_send(msg_q, (char *)req, sizeof(*req) + strlen(path) + 1, 0);
	free(req);

	sem_wait(sem1);
	file_in_cache = *(int *)mem;
	sem_post(sem1);

	if (file_in_cache == -1) {
		 gfs_sendheader(ctx, GF_FILE_NOT_FOUND, 0);
		 goto finish;
	}
	sem_wait(sem1);
	file_size = *(size_t *)mem;
	cache_file_size = file_size;
	gfs_sendheader(ctx, GF_OK, file_size);
	sem_post(sem1);
	if (!file_size) {
		goto finish;
	}
	while (file_size) {
		sem_wait(sem1);
		bytes_transferred =  seg_size < file_size ?
		    seg_size : file_size;
		write_len = gfs_send(ctx, (char *)mem, bytes_transferred);
		if (write_len != bytes_transferred) {
			fprintf(stderr, "write error");
		}
		file_size -= bytes_transferred;
		sem_post(sem1);
	}
	sem_wait(sem1);
	file_size = *(size_t *)mem;
	if (file_size) {
		fprintf(stderr, "transfer error");
	}
	sem_post(sem1);

finish:
	mq_close(msg_q);
	sem_close(sem1);
	sem_close(sem2);
	sem_unlink(shm_blk->sem1_name);
	sem_unlink(shm_blk->sem2_name);
	munmap(mem, seg_size);
	pthread_mutex_lock(seg_q_mutex);
	steque_push(seg_q, shm_blk);
	pthread_mutex_unlock(seg_q_mutex);
	pthread_cond_signal(seg_q_cond);

	return cache_file_size;
}
Пример #4
0
ssize_t handle_with_cache(gfcontext_t *ctx, char *path, void *arg) {

    /* Get thread id */
    Workload *wld = (Workload *)arg;

    pthread_t tid = pthread_self();

    printf("entered %ld\n", tid);
    /* Sequence of steps to pop a segment number from the queue  */
    /* Read phase */
    /* Lock the mutex */
    pthread_mutex_lock(wld->sq_mtx_p);

    /* Wait until the queue is empty and writers are waiting */
    while(steque_isempty(wld->segqueue)) {
        fprintf(stderr, "[handle_with_cache, thread_id = %ld] Waiting for shm segment\n", tid);
        pthread_cond_wait(wld->sq_notempty_p, wld->sq_mtx_p);
    }

    /* Pop a segment number */
    long shm_segnum = (long) steque_pop(wld->segqueue);
    fprintf(stderr, "[handle_with_cache, thread_id = %ld] Popped shm segment %ld\n", tid, shm_segnum);

    /* unlock the mutex */
    fprintf(stderr, "[handle_with_cache, thread_id = %ld] Unlocking the mutex\n", tid);
    pthread_mutex_unlock(wld->sq_mtx_p);

    /* convert the shm_segnum to shm_segid string */
    fprintf(stderr, "[handle_with_cache, thread_id = %ld] converting segnum to segid\n", tid);
    char shm_segid[SEGID_LEN];
    memset(shm_segid, 0, SEGID_LEN);
    if (sprintf(shm_segid, "%ld", shm_segnum) < 0) {
        err_exit("handle_with_cache", "sprintf", 1);
    }

    /* Open descriptor for shared memory region */
    int shm_fd = shm_open(shm_segid, O_RDWR, 0);
    if (shm_fd == -1) {
        strerr_exit("handle_with_cache, shm_open", errno);
    }

    /* obtain the pointer to shared memory */
    Shm_Block *shmb_p;
    shmb_p = mmap(NULL, wld->shm_blocksize, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
    if (shmb_p == MAP_FAILED) {
        err_exit("handle_with_cache", "mmap failed", errno);
    }

    /* close shm file descriptor; its no longer needed */
    close(shm_fd);

    /* SHM data buffer starts after the shm metadata */
    char *shm_buf = (char *) shmb_p + sizeof(Shm_Block);

    /* Initialize writer (simplecached) semaphore to 1; initially available */
    if (sem_init(&shmb_p->sem_writer, 1, 1) == -1) {
        err_exit("handle_with_cache", "Unable to initialize writer semaphore.", errno);
    }

    /* Initialize reader (handle_with_cache) semaphore to 0; initially unavailable */
    if (sem_init(&shmb_p->sem_reader, 1, 0) == -1) {
        err_exit("handle_with_cache", "Unable to initialize reader semaphore.", errno);
    }

    /* Compose message to be sent to simplecached with URL, shm segment id and shm_blocksize */
    char msg[MQ_MSGSIZE];
    if(sprintf(msg, "%s %ld %zu", path, shm_segnum, wld->shm_blocksize) < 0 ) {
        err_exit("handle_with_cache", "sprintf", 1);
    }

    /* Send message */
    fprintf(stderr, "[handle_with_cache, thread_id = %ld] Sending message on mqueue\n", tid);
    if (mq_send(wld->mqd, msg, strlen(msg), 0) == -1)
        strerr_exit("handle_with_cache, mq_send", errno);

    /* Lock the reader */
    if (sem_wait(&shmb_p->sem_reader) == -1) {
        strerr_exit("handle_with_cache, sem_wait (hdr)", errno);
    }

    /* Read file size from simplecached */
    fprintf(stderr, "[handle_with_cache, thread_id = %ld] Reading file-size from simplecached\n", tid);
    int file_size = shmb_p->file_size;
    fprintf(stderr, "[handle_with_cache] Req path = %s, file_size = %d\n", path, file_size);
    /* send GFS header */

    if (file_size == -1) {
        fprintf(stderr, "[handle_with_cache, thread_id = %ld] FNF, about to lock mutex\n", tid);
        pthread_mutex_lock(wld->sq_mtx_p);
        fprintf(stderr, "[handle_with_cache, thread_id = %ld] Enqueuing the segnum %ld\n", tid, shm_segnum);
        steque_enqueue(wld->segqueue, (steque_item) shm_segnum);
        pthread_mutex_unlock(wld->sq_mtx_p);
        pthread_cond_broadcast(wld->sq_notempty_p);
        return gfs_sendheader(ctx, GF_FILE_NOT_FOUND, 0);
    }

    /* unlock the writer */
    if (sem_post(&shmb_p->sem_writer) == -1) {
        strerr_exit("handle_with_cache, sem_post (hdr)", errno);
    }

    gfs_sendheader(ctx, GF_OK, file_size);

    /* STEPS FOR FILE TRANSFER */
    /* We use a pair of semaphores to alternate control between reader (i.e. handle_with_cache)
    and the writer (i.e. simplecached). We also keep track of number of trnasfers and bytes
    transferred */
    int nxfrs = 0;
    ssize_t bytes_xfrd = 0;

    for (nxfrs = 0, bytes_xfrd = 0 ;; nxfrs++, bytes_xfrd += shmb_p->cnt) {

        /* Lock the reader semaphore. If it is already locked, this call will block. Thus, the
        control will never go past this point unless the writer has unlocked the semaphore. */
        if (sem_wait(&shmb_p->sem_reader) == -1) {
            strerr_exit("handle_with_cache, sem_wait (data)", errno);
        }

        /* File is done on the writer side */
        if (shmb_p->cnt == 0) {
            break;
        }

        /* Read Bytes from the shared memory */
        // printf("\n[handle_with_cache] writing data below \n\n");
        // write(STDOUT_FILENO, shm_buf, shmb_p->cnt);

        if (gfs_send(ctx, shm_buf, shmb_p->cnt) != shmb_p->cnt) {
            err_exit("handle_with_cache", "gfs_send", EXIT_FAILURE);
        }

        /* Unlock the writer */
        if (sem_post(&shmb_p->sem_writer) == -1) {
            strerr_exit("handle_with_cache, sem_post (data)", errno);
        }
    }

    /* Work is done; steps to put the shared memory segment back into queue */
    fprintf(stderr, "[handle_with_cache, thread_id = %ld] FF, about to lock mutex\n", tid);
    pthread_mutex_lock(wld->sq_mtx_p);
    fprintf(stderr, "[handle_with_cache, thread_id = %ld] Enqueuing the segnum %ld\n", tid, shm_segnum);
    steque_enqueue(wld->segqueue, (steque_item) shm_segnum);
    pthread_mutex_unlock(wld->sq_mtx_p);
    pthread_cond_broadcast(wld->sq_notempty_p);

    return bytes_xfrd;
}
ssize_t handle_with_cache(gfcontext_t* ctx, char *path, void* arg) {
        char* fldes;

        pthread_mutex_lock(&fldes_mutex);
        while (fldes_queue_size == 0) {
                pthread_cond_wait(&read_cond, &fldes_mutex);
        }
        fldes = (char*)steque_pop(&fldes_queue);
        fldes_queue_size--;
//		fprintf(stdout, "fldes is:%s.", fldes);
        pthread_mutex_unlock(&fldes_mutex);
        pthread_cond_broadcast(&write_cond);
		//pthread_cond_signal(&write_cond);



        shm_data* mem = create_shm_channel(fldes);

        mqd_t mq;

        do {
                mq = mq_open (MSGQID, O_RDWR);
        } while(mq == (mqd_t) -1 || mq == 0);

        msgq_data data;
        strcpy(data.path, path);
        strcpy(data.fldes, fldes);
        data.segment_size = segment_size;

 //       pthread_mutex_lock(&msgq_mutex);

        int msg_rsp = mq_send(mq, (const char *) &data, 1024, 1);
        if (msg_rsp < 0) {
                fprintf(stderr, "Error %d (%s) on server proxy mq_send.\n", errno, strerror(errno));
				fflush(stdout);
  //              exit(1);
        }
        mq_close(mq);
 //       pthread_mutex_unlock(&msgq_mutex);

        pthread_mutex_lock(&mem->file_len_mutex);
        while(mem->file_length == 0) {
			pthread_cond_wait(&mem->proxy_cond, &mem->file_len_mutex);
        }

        int file_len = mem->file_length;

        pthread_mutex_unlock(&mem->file_len_mutex);
        pthread_cond_broadcast(&mem->cache_cond);

 //       fprintf(stdout, "Received file length is: %d\n", file_len);
//        fflush(stdout);
        
        if(file_len < 0) {
 //               fprintf(stdout, "File not found in cache\n");
//				fflush(stdout);
                destroy_shm_seg(fldes, mem);
                return gfs_sendheader(ctx, GF_FILE_NOT_FOUND, 0);
        }else {

                gfs_sendheader(ctx, GF_OK, file_len);

             
                int bytes_transferred = 0;
                int write_len = 0;
                char *data_start = (void *)(mem + 1);
                while (bytes_transferred < file_len) {

                        pthread_mutex_lock(&mem->data_mutex);
                        while(mem->bytes_written == 0) {
                                pthread_cond_wait(&mem->proxy_cond, &mem->data_mutex);
                        }
                        int read_len = mem->bytes_written;
                        write_len = gfs_send(ctx, data_start, read_len);
                        if (write_len != read_len) {
                                fprintf(stderr, "handle_with_cache write error");
                                return EXIT_FAILURE;
                        }
                        mem->bytes_written = 0;

                        pthread_mutex_unlock(&mem->data_mutex);
                        pthread_cond_broadcast(&mem->cache_cond);
                        bytes_transferred += write_len;
                }


                destroy_shm_seg(fldes, mem);
                fflush(stdout);
                return bytes_transferred;
        }
}