Removing commented code

KVClient.c

@@ -14,21 +14,7 @@ client library interfaces to do the actual operations.
 #define SA struct sockaddr 
 #include "KVClientLibrary.c"
 struct message* requestMessage;
-void func(int sockfd,struct message* requestMessage) 
-{ 
-    char buff[MAX]; 
-    int n=0; 
-    for (;;) { 
-        bzero(buff, sizeof(buff)); 
-        if(1)
-        {
-            n++;
-            printf("[Message sent to server]\n[[Status:%c]\n[Key:%s]\n[Value:%s]]\n",requestMessage->status,requestMessage->key,requestMessage->value);
-            write(sockfd, requestMessage, sizeof(struct message)); 
-            sleep(2);
-        }  
-    } 
-} 
+
 int main(int argc, char const *argv[]) 
 { 
     int sock = 0, valread; 
@@ -59,9 +45,12 @@ int main(int argc, char const *argv[])
     char key[256]="abc";
     char value[256]="cde";
     char error[256];
-    printf("%d",(int)put(sock,key, value,error));
-    printf("%d",(int)del(sock,key,error));
-    printf("%d",(int)get(sock,key, value,error));
+    //printf("%d",(int)put(sock,key, value,error));
+    //printf("%d",(int)del(sock,key,error));
+    //printf("%d",(int)get(sock,key, value,error));
+    while (1) {
+        printf("%d",(int)put(sock, key, value, error));
+    }
   
     return 0; 
 } 
\ No newline at end of file

KVServer.c

-/*
-
-KVServer will consist of a main thread that will perform the following steps:
-1. It will read a config file and set up a listening socket on a port specified in the config file.
-2. Create n threads at startup which will be specified in the config file.
-3. Perform accept() on the listening socket and pass each established connection to one of
-the n threads in a round robin fashion. For example, the first connection is passed on to
-the first thread of those n thread for processing, and so on.
-
-The KVServer will also have worker threads that are responsible for the following actions:
-1. Each worker thread will set up and monitor an epoll context for the set of connections it
-is responsible for.
-2. It runs an infinite loop that will monitor its client connections for work (in addition, if there
-are new connections for the thread, it must add it to the epoll context). After reading
-requests from clients, it will process those requests, and write a response back to the
-client.
-
-
-Key Value Cache: The server will have limited memory (specified via a config file parameter
-that lays out how many key value entries the server is allowed to hold in memory) and so this
-will serve as cache to the files that will hold the persistent representation of the data. The cache
-will be a fully associative cache (flat structure) with two possible replacement/eviction policies:
-a. LRU:
-b. LFU: Least Frequently used
-Dirty entries evicted from this cache will have to be written out to the persistent representation
-which will be a file. You are free to use locality to evict more than one entry and bring in
-additional entries by locality to drive performance.
-
-
-Persistence: All keys and corresponding values are stored on disk in files. How you organize
-the keys into files is up to you. We suggest that you keep keys that are “close” to each other in a
-single file. You also need to think about how keys are arranged in a file - if you want to read in
-one key (and corresponding value), you should do a lseek to the specific place in the file
-where the key will be. The meta data about key positions and files that exist can be in memory -
-think about using bitmaps.
-
-Interfaces:
-● Your key-value server will support 3 interfaces:
-1. Value GET (Key k): Retrieves the key-value pair corresponding to the provided key.
-2. PUT (Key k, Value v): Inserts/Overwrites the key-value pair into the store.
-3. DEL( Key k): Removes the key-value pair corresponding to the provided key from the
-store.
-
-● You must use the exact request/response formats defined later in the specification for
-communication between external and internal components.
-● 'Keys' and 'values' are always strings with non-zero lengths. They cannot be nulls either.
-● Each key and value cannot be greater than 256 bytes . If the size is breached, return an
-error. (Assume each character to be 1 byte in size)
-● When PUTing a key-value pair, if the key already exists, then the value is overwritten.
-● When GETing a value, if the key does not exist, return an error message.
-● You should ensure the following synchronization properties in your key-value service:
-    1. Reads (GETs) and updates (PUTs and DELETEs) are atomic.
-    2. An update consists of modifying a (key, value) entry in both the cache and
-    persistent representation (you can choose to do this lazily).
-    3. Do NOT lock the entire cache for each write. Only lock that entry so that
-    operations on other keys can proceed in parallel. If you do use locks, use multiple
-    readers single writer locks for efficiency.
-    KVClient
-
-*/
-
-
 #include <stdio.h>
 #include <pthread.h>
 #include <stdlib.h>
@@ -82,6 +20,8 @@ void *worker(void *args) {
     int epollfd;
     int *newfd=malloc(sizeof(int));
     
+    char *name = (char *) malloc(5 * sizeof(char));
+
     epollfd = epoll_create1(0);
     if (epollfd == -1) {
         perror("epoll_create1");
@@ -105,32 +45,23 @@ void *worker(void *args) {
         }
         for ( i= 0; i < nfds; ++i ) {
             if (events[i].data.fd == read_pipe) {
-                /*  if we get a request from main thread to add new client
-                    ie. events[i].data.fd is equal to the pipe which we use to talk with main thread
-                     - read this newfd from pipe
-                     - add this newfd to epoll instance to monitor for client requests
-                */
+                /*  if we get a request from main thread to add new client */
                 read(read_pipe, newfd, sizeof(newfd));
-                printf("\nread %d\n", *newfd);
+                printf("[%s] read %d\n", name, *newfd);
                 ev.data.fd=*newfd;
                 ev.events = EPOLLIN | EPOLLRDHUP;
                 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, *newfd,  &ev) == -1) {
                     perror("epoll_ctl: read_pipe");
                     exit(EXIT_FAILURE);
                 }
+
                
             } else {
-                /*  if we get a request from client
-                    ie. events[i].data.fd is equal to the client socket fd
-                */
+                /*  if we get a request from client (GET, PUSH, DEL) */
                 int flag = events[i].events;
 
                 if (flag & EPOLLRDHUP) {
-                    /* Connection was closed.
-                        - Remove socket from epoll instance
-                        - Close the socket and dont process more info from this socket
-                        Note: This if block should be before EPOLLIN
-                    */
+                    /* Connection was closed. */
                     epoll_ctl( epollfd, EPOLL_CTL_DEL, events[i].data.fd , NULL );
                     close(events[i].data.fd);
                     continue; 
@@ -158,21 +89,19 @@ void *worker(void *args) {
 int main (int argc, int argv) {
 
     int i;
-    int next = 0;                                   // to decide which worker thread to assign client in round robin fashion
-    pthread_t *threads;                             // set of all worker threads
-    int pool_thread_size = 1;                       // TODO: get pool thread size from config file
+    int next_thread_to_assign = 0;                                   
+    pthread_t *worker_threads;                             
+    int pool_thread_size = 5;                       // TODO: get pool thread size from config file
     int sockfd, newsockfd, portno, clilen, n;
     struct sockaddr_in serv_addr, cli_addr; 
 
     //int *pipes = (int*) malloc(pool_thread_size * 2 * sizeof(pipes));
     int pipes[5][2];                                // TODO: initialize pipes dynamically
 
-    // initialize thread pool with initial pool size
-    threads = malloc(pool_thread_size * sizeof(pthread_t));
-
+    worker_threads = malloc(pool_thread_size * sizeof(pthread_t));
     for( i=0; i < pool_thread_size; i++ ) {
         pipe(pipes[i]);
-        pthread_create( &threads[i], NULL, worker, &pipes[i]);
+        pthread_create( &worker_threads[i], NULL, worker, &pipes[i]);
     }
 
     sockfd = socket(AF_INET, SOCK_STREAM, 0); 
@@ -202,101 +131,12 @@ int main (int argc, int argv) {
         if (newsockfd < 0) 
             perror("ERROR on accept");
 
-        write(pipes[next][1], &newsockfd, sizeof(newsockfd));
+        write(pipes[next_thread_to_assign][1], &newsockfd, sizeof(newsockfd));
         printf("main thread value: %d\n",newsockfd);
         fflush(stdout);
         
-        next = (next+1) % pool_thread_size;
+        next_thread_to_assign = (next_thread_to_assign+1) % pool_thread_size;
     } 
 
     return 0;
-}
-/*
+}
\ No newline at end of file
-#include <stdio.h> 
-#include <netdb.h> 
-#include <netinet/in.h> 
-#include <stdlib.h> 
-#include <string.h> 
-#include <unistd.h>
-#include <sys/socket.h> 
-#include <sys/types.h> 
-#include "KVMessageFormat.h"
-#define MAX 80 
-#define PORT 6969 
-#define SA struct sockaddr 
-  
-// Function designed for chat between client and server. 
-void func(int sockfd) 
-{ 
-    printf("receive functions:");
-    char buff[ sizeof(struct message)]; 
-    int n; 
-    struct message* requestMessage=malloc(sizeof(struct message));
-    // infinite loop for chat 
-         // read the message from client and copy it in buffer 
-        read( sockfd , buff, sizeof(struct message)); 
-        // print buffer which contains the client contents 
-        printf("From client: %c\t To client : ", buff[0]); 
-  
-} 
-  
-// Driver function 
-int main(int argc, char const *argv[]) 
-{ 
-    int server_fd, new_socket, valread; 
-    struct sockaddr_in address; 
-    int opt = 1; 
-    int addrlen = sizeof(address); 
-    char buffer[1024] = {0}; 
-    char *hello = "Hello from server"; 
-       
-    // Creating socket file descriptor 
-    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) 
-    { 
-        perror("socket failed"); 
-        exit(EXIT_FAILURE); 
-    } 
-       
-    // Forcefully attaching socket to the port 8080 
-    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, 
-                                                  &opt, sizeof(opt))) 
-    { 
-        perror("setsockopt"); 
-        exit(EXIT_FAILURE); 
-    } 
-    address.sin_family = AF_INET; 
-    address.sin_addr.s_addr = INADDR_ANY; 
-    address.sin_port = htons( PORT ); 
-       
-    // Forcefully attaching socket to the port 8080 
-    if (bind(server_fd, (struct sockaddr *)&address,  
-                                 sizeof(address))<0) 
-    { 
-        perror("bind failed"); 
-        exit(EXIT_FAILURE); 
-    } 
-    if (listen(server_fd, 3) < 0) 
-    { 
-        perror("listen"); 
-        exit(EXIT_FAILURE); 
-    } 
-    if ((new_socket = accept(server_fd, (struct sockaddr *)&address,  
-                       (socklen_t*)&addrlen))<0) 
-    { 
-        perror("accept"); 
-        exit(EXIT_FAILURE); 
-    } 
-    struct message *requestMessage= malloc(sizeof(struct message));
-    valread = read( new_socket , requestMessage, sizeof(struct message)); 
-    printf("[Message Received from client]\n[[Status:%c]\n[Key:%s]\n[Value:%s]]",requestMessage->status,requestMessage->key,requestMessage->value);
-    struct message *replyMessage=malloc(sizeof(struct message));
-    replyMessage->status='0';
-    char buff[256]="success";
-    memcpy(replyMessage->key,buff,256);
-    replyMessage->value[0]='\0';
-    send(new_socket , replyMessage , sizeof(struct message) , 0 ); 
-     printf("\n[Message sent to client]\n[[Status:%c]\n[Key:%s]\n[Value:%s]]",replyMessage->status,replyMessage->key,replyMessage->value);
-
-    return 0; 
-} 
-*/
\ No newline at end of file