/* Main ========================================================= */
int main(int argc, char **argv) {
int i, option_char = 0;
unsigned short port = 8888;
unsigned short nworkerthreads = 1;
char *server = "s3.amazonaws.com/content.udacity-data.com";
if (signal(SIGINT, _sig_handler) == SIG_ERR){
fprintf(stderr,"Can't catch SIGINT...exiting.\n");
exit(EXIT_FAILURE);
}
if (signal(SIGTERM, _sig_handler) == SIG_ERR){
fprintf(stderr,"Can't catch SIGTERM...exiting.\n");
exit(EXIT_FAILURE);
}
// Parse and set command line arguments
while ((option_char = getopt_long(argc, argv, "p:t:s:h", gLongOptions, NULL)) != -1) {
switch (option_char) {
case 'p': // listen-port
port = atoi(optarg);
break;
case 't': // thread-count
nworkerthreads = atoi(optarg);
break;
case 's': // file-path
server = optarg;
break;
case 'h': // help
fprintf(stdout, "%s", USAGE);
exit(0);
break;
default:
fprintf(stderr, "%s", USAGE);
exit(1);
}
}
/* SHM initialization...*/
/*Initializing server*/
gfserver_init(&gfs, nworkerthreads);
/*Setting options*/
gfserver_setopt(&gfs, GFS_PORT, port);
gfserver_setopt(&gfs, GFS_MAXNPENDING, 10);
gfserver_setopt(&gfs, GFS_WORKER_FUNC, handle_with_curl);
for(i = 0; i < nworkerthreads; i++)
gfserver_setopt(&gfs, GFS_WORKER_ARG, i, server);
printf("I am running\n");
/*Loops forever*/
gfserver_serve(&gfs);
}
/* Main ========================================================= */
int main(int argc, char **argv) {
int option_char = 0;
unsigned short port = 8888;
char *content = "content.txt";
gfserver_t *gfs;
int threads = 2;
// Parse and set command line arguments
while ((option_char = getopt(argc, argv, "p:t:c:h")) != -1) {
switch (option_char) {
case 'p': // listen-port
port = atoi(optarg);
break;
case 't': // number of threads
threads = atoi(optarg);
break;
case 'c': // file-path
content = optarg;
break;
case 'h': // help
fprintf(stdout, "%s", USAGE);
exit(0);
break;
default:
fprintf(stderr, "%s", USAGE);
exit(1);
}
}
content_init(content);
InitializeThreadConstructs();
InitializeThreadPool(threads);
/*Initializing server*/
gfs = gfserver_create();
/*Setting options*/
gfserver_set_port(gfs, port);
gfserver_set_maxpending(gfs, 100);
gfserver_set_handler(gfs, handler_get);
gfserver_set_handlerarg(gfs, NULL);
/*Loops forever*/
gfserver_serve(gfs);
ThreadCleanup();
}
/* main */
int main(int argc, char **argv) {
int option_char = 0;
unsigned short port = 8888;
unsigned short nworkerthreads = 1;
char *server = "s3.amazonaws.com/content.udacity-data.com";
size_t shm_segsize = 4 * KBYTE;
fprintf(stderr, "server = %s\n", server);
if (signal(SIGINT, _sig_handler) == SIG_ERR){
fprintf(stderr,"Can't catch SIGINT...exiting.\n");
exit(EXIT_FAILURE);
}
if (signal(SIGTERM, _sig_handler) == SIG_ERR){
fprintf(stderr,"Can't catch SIGTERM...exiting.\n");
exit(EXIT_FAILURE);
}
/* Parse and set command line arguments */
while ((option_char = getopt_long(argc, argv, "p:t:s:z:n:h", gLongOptions, NULL)) != -1) {
switch (option_char) {
case 'p': // listen-port
port = atoi(optarg);
break;
case 't': // thread-count
nworkerthreads = atoi(optarg);
break;
case 's': // file-path
server = optarg;
break;
case 'z': // shm segment size
shm_segsize = atoi(optarg);
break;
case 'n': // shm segment count
shm_segcount = atoi(optarg);
break;
case 'h': // help
fprintf(stdout, "%s", USAGE);
exit(0);
break;
default:
fprintf(stderr, "%s", USAGE);
exit(1);
}
}
/* Initialize steque to hold shm segment ids */
steque_init(&shm_segnum_queue);
/* SHM initialization...*/
/* Initially spawn 100 threads */
long shm_segnum;
int shm_fd;
char shm_segid[SEGID_LEN];
/* total size of shared memory segment is size of the struct + requested segment size */
size_t shm_blocksize = sizeof(Shm_Block) + shm_segsize;
printf("shm_blocksize = %zu\n", shm_blocksize);
for (shm_segnum = 0; shm_segnum < shm_segcount; shm_segnum++) {
sprintf(shm_segid, "/%ld", shm_segnum);
/* Steps to create SHM segment id */
/* Delete previous shm instance of same name */
if (shm_unlink(shm_segid) == -1) {
//warn("main", "No previous shared memory instance found");
}
/* Create file descritor */
shm_fd = shm_open(shm_segid, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
if (shm_fd == -1) {
err_exit("webproxy", "shm_open", errno);
}
/* adjust the memory region to size of shmbuf */
if (ftruncate(shm_fd, shm_blocksize) == -1) {
err_exit("main", "ftruncate", errno);
}
/* map the memory */
Shm_Block *shmb_p;
shmb_p = mmap(NULL, shm_blocksize, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
if (shmb_p == MAP_FAILED) {
err_exit("main", "mmap failed", errno);
}
/* Push the segnum into the queue; because steque performs
only a shallow copy, we need to push elemental types, not
pointers. */
steque_push(&shm_segnum_queue, (steque_item)shm_segnum);
/* close the SHM file descriptors, they're no longer needed */
close(shm_fd);
}
/* Set up message queue attrs */
struct mq_attr attr;
attr.mq_maxmsg = MQ_MAXMSG;
attr.mq_msgsize = MQ_MSGSIZE;
/* Open message mqueue with specified attributes */
mqd = mq_open(mq_name, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR, &attr);
if (mqd == (mqd_t) -1){
strerr_exit("webproxy, mq_open", errno);
}
/* Initialize mutex and cv to protect segqueue*/
pthread_mutex_init(&sq_mtx, NULL);
pthread_cond_init(&sq_notempty, NULL);
/* Initializing server */
gfserver_init(&gfs, nworkerthreads);
/* Setting options */
gfserver_setopt(&gfs, GFS_PORT, port);
gfserver_setopt(&gfs, GFS_MAXNPENDING, 10);
gfserver_setopt(&gfs, GFS_WORKER_FUNC, handle_with_cache);
/* Spawn threads */
num_writers = 0;
num_readers = nworkerthreads;
long *th_ids = (long *) malloc(nworkerthreads * sizeof(long));
int i;
for(i = 0; i < nworkerthreads; i++) {
th_ids[i] = i;
// fprintf(stderr, "Assigning thread id %ld\n", th_ids[i]);
/* Construct workload context to pass on to the handler */
Workload wld;
wld.shm_blocksize = shm_blocksize;
wld.mqd = mqd; /* populate mq file desc */
wld.segqueue = &shm_segnum_queue; /* populate segment queue id */
wld.sq_mtx_p = &sq_mtx; /* populate the mutex */
wld.sq_notempty_p = &sq_notempty; /* populate cv */
gfserver_setopt(&gfs, GFS_WORKER_ARG, i, &wld);
}
free(th_ids);
/* Loops forever */
gfserver_serve(&gfs);
}
/* Main ========================================================= */
int main(int argc, char **argv)
{
int i, option_char = 0;
unsigned short port = 8888;
unsigned short nworkerthreads = 1;
unsigned short nsegments = 1;
unsigned short segmentSize = 1024;
char *server = "http://s3.amazonaws.com/content.udacity-data.com";
if (signal(SIGINT, _sig_handler) == SIG_ERR)
{
fprintf(stderr,"Can't catch SIGINT...exiting.\n");
exit(EXIT_FAILURE);
}
if (signal(SIGTERM, _sig_handler) == SIG_ERR)
{
fprintf(stderr,"Can't catch SIGTERM...exiting.\n");
exit(EXIT_FAILURE);
}
// Parse and set command line arguments
while ((option_char = getopt_long(argc, argv, "n:z:p:t:s:h", gLongOptions, NULL)) != -1)
{
switch (option_char)
{
case 'n': // segment-count
nsegments = atoi(optarg);
break;
case 'z': // segnment-size
segmentSize = atoi(optarg);
break;
case 'p': // listen-port
port = atoi(optarg);
break;
case 't': // thread-count
nworkerthreads = atoi(optarg);
break;
case 's': // file-path
server = optarg;
printf("set server to %s\n", server);
break;
case 'h': // help
fprintf(stdout, "%s", USAGE);
exit(0);
break;
default:
fprintf(stderr, "%s", USAGE);
exit(1);
}
}
/* SHM initialization...*/
InitializeSharedSegmentPool(nsegments, segmentSize);
InitializeSynchronizationQueues();
/*Initializing server*/
gfserver_init(&gfs, nworkerthreads);
/*Setting options*/
gfserver_setopt(&gfs, GFS_PORT, port);
gfserver_setopt(&gfs, GFS_MAXNPENDING, 100);
gfserver_setopt(&gfs, GFS_WORKER_FUNC, handle_with_cache);
printf("server set to %s\n", server);
for(i = 0; i < nworkerthreads; i++)
gfserver_setopt(&gfs, GFS_WORKER_ARG, i, server);
/*Loops forever*/
gfserver_serve(&gfs);
CleanupSynchronizationQueues();
CleanupSharedSegmentPool();
return 0;
}
/* Main ========================================================= */
int main(int argc, char **argv) {
int i, option_char = 0;
unsigned short port = 8888;
unsigned short nworkerthreads = 1;
unsigned short nsegments = 1;
unsigned long segment_size = 1024;
char *server = "s3.amazonaws.com/content.udacity-data.com";
struct shm_info *shm_blk;
if (signal(SIGINT, _sig_handler) == SIG_ERR){
fprintf(stderr,"Can't catch SIGINT...exiting.\n");
exit(EXIT_FAILURE);
}
if (signal(SIGTERM, _sig_handler) == SIG_ERR){
fprintf(stderr,"Can't catch SIGTERM...exiting.\n");
exit(EXIT_FAILURE);
}
// Parse and set command line arguments
while ((option_char = getopt_long(argc, argv, "n:z:p:t:s:h", gLongOptions,
NULL)) != -1) {
switch (option_char) {
case 'n': // num segments
nsegments = atoi(optarg);
break;
case 'z': // size of segments
segment_size = atol(optarg);
break;
case 'p': // listen-port
port = atoi(optarg);
break;
case 't': // thread-count
nworkerthreads = atoi(optarg);
break;
case 's': // file-path
server = optarg;
break;
case 'h': // help
fprintf(stdout, "%s", USAGE);
exit(0);
break;
default:
fprintf(stderr, "%s", USAGE);
exit(1);
}
}
/* SHM initialization...*/
/*Initializing server*/
gfserver_init(&gfs, nworkerthreads);
/*Setting options*/
gfserver_setopt(&gfs, GFS_PORT, port);
gfserver_setopt(&gfs, GFS_MAXNPENDING, 10);
gfserver_setopt(&gfs, GFS_WORKER_FUNC, handle_with_cache);
steque_init(&segfds_q);
/* Create the segments */
for (i = 0; i < nsegments; i++) {
shm_blk = malloc(sizeof(*shm_blk));
snprintf(shm_blk->mem_name, sizeof(shm_blk->mem_name), "mem_%d", i);
if (shm_unlink(shm_blk->mem_name) == 0) {
fprintf(stdout, "Shared mem %s removed from system.\n",
shm_blk->mem_name);
}
shm_blk->memfd = shm_open(shm_blk->mem_name, O_CREAT | O_RDWR | O_TRUNC,
0777);
if (shm_blk->memfd < 0) {
perror("shm_open");
exit(1);
}
ftruncate(shm_blk->memfd, segment_size);
snprintf(shm_blk->sem1_name, sizeof(shm_blk->sem1_name), "sem_%d_1", i);
if (sem_unlink(shm_blk->sem1_name) == 0) {
fprintf(stdout, "Semaphore %s removed from system.\n",
shm_blk->sem1_name);
}
snprintf(shm_blk->sem2_name, sizeof(shm_blk->sem2_name), "sem_%d_2", i);
if (sem_unlink(shm_blk->sem2_name) == 0) {
fprintf(stdout, "Semaphore %s removed from system.\n",
shm_blk->sem2_name);
}
steque_push(&segfds_q, shm_blk);
}
for(i = 0; i < nworkerthreads; i++)
gfserver_setopt(&gfs, GFS_WORKER_ARG, i, server);
handle_with_cache_init(&segfds_q, segment_size, &segfds_q_mutex,
&segfds_q_cond);
/*Loops forever*/
gfserver_serve(&gfs);
}
