Newserver

.gitignore

@@ -0,0 +1,4 @@
+.idea
+.vscode
+cmake-build-debug
+build

.travis.yml

@@ -0,0 +1,36 @@
+
+language: cpp
+
+os: linux
+
+compiler: gcc
+
+before_install:
+  - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+  - sudo apt-get update -q
+  - sudo apt-get install cppcheck -y
+  - sudo apt-get install python3 -y
+  - sudo apt-get install g++-9 -y
+  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-9 90
+  - sudo apt-get install libboost-all-dev -y
+  - sudo apt-get install protobuf-compiler libprotobuf-dev -y
+  - CMAKE_VERSION=3.15.4
+  - CMAKE_VERSION_DIR=v3.15
+  - CMAKE_OS=Linux-x86_64
+  - CMAKE_TAR=cmake-$CMAKE_VERSION-$CMAKE_OS.tar.gz
+  - CMAKE_URL=http://www.cmake.org/files/$CMAKE_VERSION_DIR/$CMAKE_TAR
+  - CMAKE_DIR=$(pwd)/cmake-$CMAKE_VERSION
+  - wget --quiet $CMAKE_URL
+  - mkdir -p $CMAKE_DIR
+  - tar --strip-components=1 -xzf $CMAKE_TAR -C $CMAKE_DIR
+  - export PATH=$CMAKE_DIR/bin:$PATH
+  - sudo pip install flask
+  - sudo python ./serverAPI.py &
+
+script:
+#  - ./linters/run.sh --local
+  - mkdir build
+  - cd build
+  - cmake -j2 ../
+  - make -j2
+  - ./test

CMakeLists.txt

@@ -0,0 +1,60 @@
+cmake_minimum_required(VERSION 3.15)
+project(GProject)
+
+find_package(Boost COMPONENTS thread log http)
+IF (Boost_FOUND)
+    INCLUDE_DIRECTORIES(${Boost_INCLUDE_DIR})
+    ADD_DEFINITIONS( "-DHAS_BOOST" )
+ENDIF()
+
+find_package(Protobuf)
+include_directories(${PROTOBUF_INCLUDE_DIR})
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+
+configure_file(CMakeLists.txt.in
+googletest-download/CMakeLists.txt)
+execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-download )
+execute_process(COMMAND ${CMAKE_COMMAND} --build .
+WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-download )
+
+add_subdirectory(${CMAKE_BINARY_DIR}/googletest-src
+${CMAKE_BINARY_DIR}/googletest-build)
+
+
+set(CMAKE_CXX_STANDARD 17)
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g ")
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0")
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs")
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage")
+#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+
+include_directories(include)
+
+protobuf_generate_cpp(PROTO_SRC PROTO_HEADER protobuf/structures.proto)
+add_library(proto ${PROTO_HEADER} ${PROTO_SRC})
+
+add_library(algorithm STATIC src/algorithm.cpp)
+
+add_library(queue STATIC src/queue.cpp)
+
+add_library(server STATIC src/server.cpp)
+target_link_libraries(server proto ${Boost_LIBRARIES})
+
+#find_package (sqlite3.h)
+
+#if (SQLITE3_FOUND)
+#    include_directories(${SQLITE3_INCLUDE_DIRS})
+#    target_link_libraries (new ${SQLITE3_LIBRARIES})
+#endif (SQLITE3_FOUND)
+#add_library(sqlite3 STATIC include/sqlite-autoconf-3300100/sqlite3.c)
+
+add_library(worker STATIC src/worker.cpp)
+include_directories(/usr/include)
+link_directories(/usr/lib)
+target_link_libraries(worker gtest gmock sqlite3)
+
+add_executable(testServer test/testServer.cpp)
+target_link_libraries(testServer gtest gmock server proto ${PROTOBUF_LIBRARY})

CMakeLists.txt.in

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(googletest-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(googletest
+  GIT_REPOSITORY    https://github.com/google/googletest.git
+  GIT_TAG           release-1.8.1
+  SOURCE_DIR        "${CMAKE_BINARY_DIR}/googletest-src"
+  BINARY_DIR        "${CMAKE_BINARY_DIR}/googletest-build"
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND     ""
+  INSTALL_COMMAND   ""
+  TEST_COMMAND      ""
+)

README.md

@@ -1 +1,4 @@
-# GProject
+# GProject
+
+[![Build Status](https://travis-ci.org/Sermelyan/GProject.svg?branch=template)](https://travis-ci.org/Sermelyan/GProject)
+

include/algorithm.hpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2019 <Alex>
+ */
+
+#ifndef INCLUDE_ALGORITHM_HPP_
+#define INCLUDE_ALGORITHM_HPP_
+#include <utility>
+#include <vector>
+#include <unordered_set>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/dijkstra_shortest_paths.hpp>
+#include <assert.h>
+
+class Algorithm {
+
+ public:
+    typedef std::size_t dotId;
+    typedef std::pair<dotId, dotId> edge;
+    typedef std::size_t weight;
+
+ private:
+    typedef boost::adjacency_list <boost::listS, boost::vecS, boost::directedS,
+    boost::no_property,boost::property<boost::edge_weight_t, size_t> > graph_t;
+    typedef boost::graph_traits<graph_t>::vertex_descriptor vertex_descriptor;
+
+ public:
+    Algorithm()= delete;
+    explicit Algorithm(const std::vector<edge> &edgeArr, const std::vector<weight> &weightArr);
+    ~Algorithm();
+    Algorithm(const Algorithm&) = delete;
+    Algorithm(const Algorithm&&) = delete;
+    Algorithm& operator=(const Algorithm&) = delete;
+    Algorithm& operator=(const Algorithm&&) = delete;
+
+    std::vector<dotId> CalcRoute(const dotId &A, const dotId &B);
+
+    std::pair<std::vector<Algorithm::dotId>, size_t>
+    getRoute(dotId from, const size_t &pointsCount,
+            const size_t &time, const size_t &maxPlacesCount);
+
+
+
+    // delete this from algo and use from WorkerAPI
+    long int getWeightIndex(const size_t &pointsCount, const size_t &from, const size_t &to);
+
+ private:
+    void MakeGraph();
+    edge * edgeArr;
+    size_t edgeSize;
+    weight * weightArr;
+    graph_t myGraph;
+    const size_t MAX_PLACES = 200;  // контроль (максимальное кол-во мест в пути)
+};
+
+#endif  //  INCLUDE_ALGORITHM_HPP_

include/data.hpp

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2019 <Copyright Owner>
+ */
+
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#ifndef INCLUDE_DATA_HPP_
+#define INCLUDE_DATA_HPP_
+
+static const unsigned MIN_IN_HOUR = 60;
+
+typedef std::pair<double, double> Point;
+typedef std::vector<Point> Points;
+typedef std::vector<std::string> Filters;
+
+struct DataIn {
+    Filters FilterList;
+    unsigned TimeLimit;
+    unsigned MaxDots;
+    Point StartPoint;
+    Point EndPoint;
+    int UserID;
+    DataIn() {}
+    DataIn(::Filters _f, unsigned _t, unsigned _md, Point _sp, Point _ep,
+           int _u)
+        : FilterList(std::move(_f)),
+          TimeLimit(_t),
+          MaxDots(_md),
+          StartPoint(std::move(_sp)),
+          EndPoint(std::move(_ep)),
+          UserID(_u) {}
+};
+
+struct DataOut {
+    Points RoutePoints;
+    unsigned MaxTime;
+    int UserID;
+    DataOut() {}
+    DataOut(Points _p, unsigned _t, int _u)
+        : RoutePoints(std::move(_p)), MaxTime(_t), UserID(_u) {}
+};
+
+#endif  //  INCLUDE_DATA_HPP_

include/queue.hpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2019 <Alex>
+ */
+
+#ifndef INCLUDE_QUEUE_HPP_
+#define INCLUDE_QUEUE_HPP_
+
+#include <queue>
+#include <mutex>
+#include <memory>
+
+template <class T>
+class GQueue {
+ public:
+    GQueue() = delete;
+    explicit GQueue(const T &element404);
+    ~GQueue();
+    void push(const  T &element);
+    T  popIfNotEmpty();
+
+    GQueue(const GQueue&) = delete;
+    GQueue(const GQueue&&) = delete;
+    GQueue& operator=(const GQueue&) = delete;
+    GQueue& operator=(const GQueue&&) = delete;
+
+ private:
+    T element404;
+    std::unique_ptr<std::queue<T>> queue;
+    std::mutex GQueueMutex;
+};
+
+template <class T>
+GQueue<T>::~GQueue() = default;
+
+template <class T>
+GQueue<T>::GQueue(const T &element404) {
+    queue.reset(new std::queue<T>);
+    this->element404 = element404;
+}
+
+template <class T>
+void GQueue<T>::push(const T &element) {
+    const std::lock_guard<std::mutex> lock(GQueueMutex);
+    queue->push(element);
+}
+
+template <class T>
+T GQueue<T>::popIfNotEmpty() {
+    const std::lock_guard<std::mutex> lock(GQueueMutex);
+    T answer = this->element404;
+    if (!queue->empty()) {
+        answer = queue->front();
+        queue->pop();
+    }
+    return answer;
+}
+
+#endif  //  INCLUDE_QUEU_HPP_

include/server.hpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2019 <Copyright Owner>
+ */
+
+#include <memory>
+#include <set>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+
+#include "data.hpp"
+#include "queue.hpp"
+
+#ifndef INCLUDE_SERVER_HPP_
+#define INCLUDE_SERVER_HPP_
+
+class ClientAdapter;
+class Server;
+
+class Client : std::enable_shared_from_this<Client> {
+  public:
+    int user_id;
+    typedef std::shared_ptr<Client> ClientPtr;
+
+    boost::asio::ip::tcp::socket &Sock();
+    static ClientPtr NewClient(boost::asio::io_service &io, Server &s);
+
+    void Read();
+    void Write(const std::string &msg);
+
+    static std::unique_ptr<DataIn> Unmarshal(const char *msg);
+    static std::string Marshal(const DataOut &out);
+
+  private:
+    explicit Client(boost::asio::io_service &io, Server &s);
+
+    boost::asio::ip::tcp::socket _socket;
+    Server &_server;
+    //    std::string _read_msg;
+    //    std::string _write_msg;
+
+    char _read_msg[4096];
+    std::string _write_msg;
+
+    void onRead(const boost::system::error_code &e, size_t bytes);
+    void onWrite(const boost::system::error_code &e, size_t bytes);
+    static void parseHTTP(const char *msg, const char *msg_end, std::map<std::string, std::string> &httpRequest);
+};
+
+class Server {
+  public:
+    Server(GQueue<DataIn> &in, GQueue<DataOut> &out, unsigned Port);
+    ~Server();
+
+    void Kill();
+    void SendToQueue(std::unique_ptr<DataIn> data);
+    void StartAccept();
+    void StartEchoServer();
+    void StartServer(unsigned serviceThr = 4, unsigned queueThr = 2);
+
+    void AddWaitingClient(const Client::ClientPtr &c);
+    void RemoveWaitingClient(const Client::ClientPtr &c);
+
+  private:
+    boost::asio::io_service service;
+    GQueue<DataIn> &in;
+    GQueue<DataOut> &out;
+    bool alive;
+    unsigned port;
+
+    boost::asio::ip::tcp::acceptor acceptor;
+    std::vector<std::thread> threads;
+    std::set<Client::ClientPtr> waitingClients;
+    std::mutex liveMutex;
+    std::mutex waitingMutex;
+
+    void onAccept(const Client::ClientPtr &c,
+                  const boost::system::error_code &e);
+    bool isAlive();
+    void GetFromQueue();
+
+    void sillyServer();
+};
+
+#endif //  INCLUDE_SERVER_HPP_