first commit

Author: zoumson

CMakeLists.txt

@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 2.8.9)
+
+set(CMAKE_CXX_STANDARD 17)
+
+#Set the executable name
+set(EXE_SERVER server)
+
+#Set the executable name
+set(EXE_CLIENT client)
+
+project (socketTime)
+
+#Bring the custom libraries
+link_directories( lib )
+
+
+#Bring the headers
+include_directories(include)
+
+#Bring the sources
+file(GLOB SOURCES_SERVER "src/server/*.cpp")
+file(GLOB SOURCES_CLIENT "src/client/*.cpp")
+
+#Add opencv cmake .config path
+#set (OpenCV_DIR opt/opencv/release)
+
+SET(Boost_USE_STATIC_LIBS ON)
+set(CMAKE_USE_PTHREADS_INIT true)
+set(CMAKE_USE_PTHREADS_INIT ON)
+
+find_package(Threads REQUIRED )
+find_package(Boost COMPONENTS program_options log log_setup REQUIRED)
+find_package(Threads)
+
+
+#Build the executable
+add_executable(${EXE_SERVER} ${SOURCES_SERVER})
+add_executable(${EXE_CLIENT} ${SOURCES_CLIENT})
+
+#Link the libraries 
+target_link_libraries(${EXE_SERVER} Threads::Threads Boost::program_options Boost::log Boost::log_setup)
+target_link_libraries(${EXE_CLIENT} Threads::Threads Boost::program_options Boost::log Boost::log_setup)
+
+

README.md

@@ -0,0 +1,3 @@
+programa con arquitectura cliente servidor en c++ con minimo un servidor y dos clientes.
+
+# MultipleThreadMultipleClientSingleServerSocketCPP

build/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

compile.sh

@@ -0,0 +1,3 @@
+g++ Server.cpp main_server.cpp MyThread.cpp CustomerSupport.cpp -o server -lpthread
+g++ Client.cpp main_client.cpp Clock.cpp -o client -lpthread
+

include/Clock.h

@@ -0,0 +1,11 @@
+#ifndef Clock_class
+#define Clock_class
+#include <iostream>
+using namespace std;
+class Clock{
+        public:
+        string currentDateTime();
+        virtual ~Clock();
+};
+#endif
+

include/GetLocalAddress.h

@@ -0,0 +1,13 @@
+#include <iostream>
+#include <iostream>     ///< cout
+#include <cstring>      ///< memset
+#include <errno.h>      ///< errno
+#include <sys/socket.h> ///< socket
+#include <netinet/in.h> ///< sockaddr_in
+#include <arpa/inet.h>  ///< getsockname
+#include <unistd.h>     ///< close
+#include<string.h>
+#include<netinet/in.h> //#define INET_ADDRSTRLEN 16 #define INET6_ADDRSTRLEN 46
+#include <cstring>      ///< memset
+
+int getLocalAddress(std::string& myIP);

include/GetLocalPortNumber.h

@@ -0,0 +1,11 @@
+#include <iostream>
+#include <iostream>     ///< cout
+#include <cstring>      ///< memset
+#include <errno.h>      ///< errno
+#include <sys/socket.h> ///< socket
+#include <netinet/in.h> ///< sockaddr_in
+#include <arpa/inet.h>  ///< getsockname
+#include <unistd.h>     ///< close
+
+int getLocalPortNumber(char* myIP);
+

include/Manager.h

@@ -0,0 +1,98 @@
+#ifndef MY_MANAGER_H
+#define MY_MANAGER_H
+
+
+#include <boost/log/attributes.hpp>
+#include <boost/log/common.hpp>
+#include <boost/log/core.hpp>
+#include <boost/log/expressions.hpp>
+#include <boost/log/sinks.hpp>
+#include <boost/log/sinks/sync_frontend.hpp>
+#include <boost/log/sinks/text_ostream_backend.hpp>
+#include <boost/log/sources/logger.hpp>
+#include <boost/log/sources/record_ostream.hpp>
+#include <boost/log/sources/severity_feature.hpp>
+#include <boost/log/sources/severity_feature.hpp>
+#include <boost/log/sources/severity_logger.hpp>
+#include <boost/log/sources/severity_logger.hpp>
+#include <boost/log/support/date_time.hpp>
+#include <boost/log/utility/setup/common_attributes.hpp>
+#include <boost/log/utility/setup/common_attributes.hpp>
+#include <boost/log/utility/setup/formatter_parser.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/thread.hpp>
+#include <fstream>
+#include <boost/core/null_deleter.hpp>
+#include <boost/log/trivial.hpp>
+namespace logging = boost::log;
+namespace attrs = boost::log::attributes;
+namespace src = boost::log::sources;
+namespace sinks = boost::log::sinks;
+namespace expr = boost::log::expressions;
+namespace keywords = boost::log::keywords;
+ 
+enum sign_severity_level 
+{
+  trace,
+  debug,
+  info,
+  warning,
+  error,
+  fatal,
+  report
+};
+
+
+BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(
+    my_logger, src::severity_logger_mt<sign_severity_level>
+);
+
+
+class Manager 
+{
+ public:
+  using Backend = sinks::text_ostream_backend;
+  using TextSink = sinks::synchronous_sink<Backend>;
+ 
+  Manager() 
+  {
+    backend_ = boost::make_shared<Backend>();
+    backend_->auto_flush(true);
+ 
+    boost::shared_ptr<TextSink> sink(new TextSink(backend_));
+    sink->set_formatter(
+        expr::format("[%1%]<%2%>: %3%") %
+        //expr::format("[%1%]<%2%>(%3%): %4%") %
+            expr::format_date_time<boost::posix_time::ptime>("TimeStamp", "%Y-%m-%d %H:%M:%S") %
+            //logging::trivial::severity %
+            expr::attr < sign_severity_level > ("Severity") %
+            //expr::attr < attrs::current_thread_id::value_type > ("ThreadID") %
+            expr::smessage
+    );
+    sink->set_filter(expr::attr<sign_severity_level>("Severity") >= warning);
+    logging::core::get()->add_sink(sink);
+ 
+    logging::add_common_attributes();
+    logging::core::get()->add_global_attribute(
+        "ThreadID", attrs::current_thread_id()
+    );
+  }
+ 
+  void set_log_file(const char* filename) 
+  {
+    backend_->remove_stream(current_stream_);
+    current_stream_.reset(new std::ofstream(filename));
+    backend_->add_stream(current_stream_);
+    //stdout
+     backend_->add_stream(
+        boost::shared_ptr< std::ostream >(&std::clog, boost::null_deleter()));
+  }
+ 
+ private:
+  boost::shared_ptr<Backend> backend_;
+  boost::shared_ptr<std::ostream> current_stream_;
+};
+ 
+
+#endif

include/MyClient.h

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h> 
+#include <iostream>
+#include "Clock.h"
+#include <Manager.h>
+
+class MyClient
+{
+private:
+	int socketConnectToClient_;
+	unsigned short serverPortNumber_;
+	int numberOfByteOfBuffer_;
+
+	Clock clock;
+
+	struct sockaddr_in serverAddress_;
+	struct hostent *serverIP_;
+	Manager logManager;
+	my_logger::logger_type log = my_logger::get();
+	char buffer[1024];
+public:
+	MyClient(char *_serverIP_, unsigned short _serverPort_);
+	int createClientForConnexion();
+	int connectClientToServer();
+	int sendRequestToServer();
+	int receiveResponseFromServer();
+	int closeConnexion();
+	int setLog(std::string& _logName_);
+	int setLog(std::string&& _logName_);
+	// Setter and Getter socketConnectToClient
+
+	auto socketConnectToClient() const& -> const int& { return socketConnectToClient_; }
+	auto socketConnectToClient() &      -> int&       { return socketConnectToClient_; }
+	auto socketConnectToClient() &&     -> int&&      { return std::move(socketConnectToClient_); }
+	// Setter and Getter serverPortNumber
+
+	auto serverPortNumber() const& -> const unsigned short& { return serverPortNumber_; }
+	auto serverPortNumber() &      -> unsigned short&       { return serverPortNumber_; }
+	auto serverPortNumber() &&     -> unsigned short&&      { return std::move(serverPortNumber_); }
+
+	// Setter and Getter numberOfByteOfBuffer
+
+	auto numberOfByteOfBuffer() const& -> const int& { return numberOfByteOfBuffer_; }
+	auto numberOfByteOfBuffer() &      -> int&       { return numberOfByteOfBuffer_; }
+	auto numberOfByteOfBuffer() &&     -> int&&      { return std::move(numberOfByteOfBuffer_); }
+
+	// Setter and Getter socketConnectToClient
+
+	auto serverAddress() const& -> const sockaddr_in& { return serverAddress_; }
+	auto serverAddress() &      -> sockaddr_in&       { return serverAddress_; }
+	auto serverAddress() &&     -> sockaddr_in&&      { return std::move(serverAddress_); }
+	// Setter and Getter socketConnectToClient
+};

include/MyProcessor.h

@@ -0,0 +1,29 @@
+#ifndef MY_PROCESSOR_H
+#define MY_PROCESSOR_H
+#include "MyServer.h"
+
+/**
+ * Implementation of a Processor to deal with a client request
+ *
+ * MyProcessor is an abstract class, due to the  
+ * the existence of the pure virtual member function process (= 0)
+ * process needs to be overriden by derived class otherwise compile error
+ * no objects of class MyProcessor can be directly created
+ * virtual function avoid function overloading
+ * At runtime the os uses dynamic binding to determine the type of the object
+ * Function that are not virtual uses static binding, 
+ * the type of the object is defined at compile time 
+ * For a base class with a derived make the base class desctucort virtual
+ * Then for every derived class define its destructor appropriately
+ * Don't let the base class destructor clean the object when it's out of the current scope
+ * 
+ */
+class MyProcessor
+{
+public:
+
+	virtual void process(MyServer serverProcessingAcceptedConnexion) = 0;
+
+};
+
+#endif /*MY_PROCESSOR_H */