Quick MySQL docker deployment & code cleaning

MySQL Cache Manager & code cleanup
Deployment / CPack / Docker / Boost / Versionning
2016-05-24 08:56:11 +02:00 · 2016-05-23 21:22:12 +02:00 · 2016-05-23 21:20:56 +02:00 · 2016-05-23 21:19:40 +02:00 · 2016-05-23 21:14:59 +02:00 · 2016-05-23 17:14:41 +02:00
38 changed files with 1313 additions and 82 deletions
@@ -13,7 +13,19 @@
 ## limitations under the License.

 cmake_minimum_required (VERSION 2.8.1)
-cmake_policy(SET CMP0042 NEW)
+cmake_policy(SET CMP0048 OLD)
+
+set (PROJECT_NAME cameradar)
+
+project (${PROJECT_NAME})
+
+set (${PROJECT_NAME}_VERSION_MAJOR 0)
+set (${PROJECT_NAME}_VERSION_MINOR 2)
+set (${PROJECT_NAME}_VERSION_PATCH 0)
+set (${PROJECT_NAME}_SUFFIX "-beta")
+set (${PROJECT_NAME}_VERSION "${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR}.${${PROJECT_NAME}_VERSION_PATCH}${${PROJECT_NAME}_SUFFIX}")
+
+find_package(Git REQUIRED)

 # compiler flags
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14") #enable C++14
@@ -32,17 +44,88 @@ set(CMAKE_MACOSX_RPATH 1)
 # list of all cache managers
 set (CAMERADAR_CACHE_MANAGERS "")

+# dependencies directory
+set(DEPS_DIR ${CMAKE_SOURCE_DIR}/deps)
+
 # output path for cache managers
-set (CCTV_CACHE_MANAGER_OUTPUT_FOLDER cache_managers)
-set (CCTV_CACHE_MANAGER_OUTPUT_PATH ${CMAKE_BINARY_DIR}/${CCTV_CACHE_MANAGER_OUTPUT_FOLDER})
+set (CAMERADAR_CACHE_MANAGER_OUTPUT_FOLDER cache_managers)
+set (CAMERADAR_CACHE_MANAGER_OUTPUT_PATH ${CMAKE_BINARY_DIR}/${CAMERADAR_CACHE_MANAGER_OUTPUT_FOLDER})

 set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)

-include_directories (
-        "cameradar_standalone/include"
-        "../cctv_server2/deps/jsoncpp/src/deps.jsoncpp/include"
+# the place where the version.h file is generated, used from the main.cpp of cameradar
+set (VERSION_INCLUDE_DIR ${PROJECT_BINARY_DIR})
+
+# get the git revision
+message (STATUS "retrieve current git revision SHA1 of cameradar")
+execute_process(
+    COMMAND "git" "rev-parse" "HEAD"
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+    OUTPUT_VARIABLE CAMERADAR_GIT_SHA1
 )

+# remove last character of the git output (\n)
+string(LENGTH ${CAMERADAR_GIT_SHA1} CAMERADAR_GIT_SHA1_LEN)
+math(EXPR CAMERADAR_GIT_SHA1_LEN "${CAMERADAR_GIT_SHA1_LEN} - 1")
+string(SUBSTRING ${CAMERADAR_GIT_SHA1} 0 ${CAMERADAR_GIT_SHA1_LEN} CAMERADAR_GIT_SHA1)
+
+# print the SHA1
+message (STATUS "current cameradar git revision SHA1 is ${CAMERADAR_GIT_SHA1}")
+
+# generate build number from the current timestamp
+string(TIMESTAMP CAMERADAR_VERSION_BUILD "%Y%m%d%H%M%S" "UTC")
+
+# print version
+message (STATUS "current cameradar build version will be ${CAMERADAR_VERSION_BUILD}")
+
+configure_file (
+    "${PROJECT_SOURCE_DIR}/version.h.in"
+    "${PROJECT_BINARY_DIR}/version.h"
+)
+
+# add all deps libraries to the link directories path
+link_directories (
+    # third party libraries
+    "deps/jsoncpp/src/deps.jsoncpp/src/lib_json"
+    "deps/boost/src/deps.boost/libs"
+    "deps/mysql-connector/lib"
+)
+
+include_directories (
+    "cameradar_standalone/include"
+    "deps/jsoncpp/src/deps.jsoncpp/include"
+    "deps/boost/src/deps.boost/include"
+    "deps/mysql-connector/include"
+)
+
+set (${CAMERADAR_BINARIES} "")
+set (${CAMERADAR_LIBRARIES} "")
+
 #build cache managers
+add_subdirectory (deps)
 add_subdirectory (cameradar_standalone)
 add_subdirectory (cache_managers)
+
+list (APPEND CAMERADAR_LIBRARIES ${CAMERADAR_INSTALL_DEPENDENCIES} ${CAMERADAR_LIBRARIES})
+
+install (PROGRAMS ${CAMERADAR_BINARIES} DESTINATION bin)
+install (FILES ${CAMERADAR_CACHE_MANAGERS} DESTINATION cache_managers)
+install (FILES ${CAMERADAR_LIBRARIES} DESTINATION libraries)
+install (DIRECTORY ${CMAKE_SOURCE_DIR}/deps/licenses DESTINATION libraries)
+
+# cpack configuration
+include (InstallRequiredSystemLibraries)
+set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "cameradar")
+set (CPACK_PACKAGE_VENDOR "Etix Labs")
+set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "cameradar tool")
+set (CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}_${${PROJECT_NAME}_VERSION}_${CMAKE_BUILD_TYPE}_${CMAKE_SYSTEM_NAME}")
+set (CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+set (CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+set (CPACK_PACKAGE_VERSION_MAJOR "0")
+set (CPACK_PACKAGE_VERSION_MINOR "1")
+set (CPACK_PACKAGE_VERSION_PATCH "0")
+set (CPACK_PACKAGE_INSTALL_DIRECTORY "${PROJECT_NAME}_${${PROJECT_NAME}_VERSION}")
+set (CPACK_GENERATOR "TGZ")
+set (CPACK_SOURCE_GENERATOR "TGZ")
+
+include(CPack)
@@ -1,6 +1,6 @@
 # Cameradar

-## An RTSP surveillance camera access multitool.
+## An RTSP surveillance camera access multitool

 #### Cameradar allows you to:

@@ -18,7 +18,15 @@ Of course, you can also call for individual tasks if you plug in a Database to C

 ## Table of content

- [Installation](#installation)
+- [Quick install](#quick-install)
+  - [Dependencies](#quick-install###dependencies)
+  - [Five steps guide](#quick-install###five-steps-guide)
+- [Manual installation](#manual-installation)
+  - [Dependencies](#manual-installation###dependencies)
+  - [Steps](#manual-installation###Steps)
+- [Advanced docker deployment](#advanced-docker-deployment)
+  - [Dependencies](#advanced-docker-deployment###dependencies)
+  - [Deploy a custom version of Cameradar](#advanced-docker-deployment###deploy-a-custom-version-of-cameradar)
 - [Configuration](#configuration)
 - [Output](#output)
 - [Check camera access](#check-camera-access)
@@ -28,23 +36,74 @@ Of course, you can also call for individual tasks if you plug in a Database to C
 - [Next improvements](#next-improvements)
 - [License](#license)

-## Installation
+## Quick install
+
+The quick install uses docker to build Cameradar without polluting your machine with dependencies and makes it easy to deploy Cameradar in a few commands. **However, it may require networking knowledge, as your docker containers will need access to the cameras subnetwork.**
+
+### Dependencies
+
+The only dependencies are `docker` and `docker-compose`.
+
+### Five steps guide
+
+1. `git clone https://github.com/EtixLabs/cameradar.git`
+2. Go into the Cameradar repository, then to the `deployment` directory
+3. Tweak the `conf/cameradar.conf.json` as you need (see [the onfiguration guide here](#configuration) for more information)
+4. Run `docker-compose build cameradar` to build the cameradar container
+5. Run `docker-compose up cameradar` to launch Cameradar
+
+If you want to deploy your custom version of Cameradar using the same method, you should check the [advanced docker deployment](#advanced-docker-deployment) tutorial here.
+
+## Manual installation
+
+The manual installation is recommended if you want to tweak Cameradar and quickly test them using CMake and running Cameradar in command-line. If you just want to use Cameradar, it is recommended to use the [quick install](#quick-install) instead.
+
+### Dependencies
+
+To install Cameradar you will need these packages
+
+* cmake (`cmake`)
+
+### Steps

 The simplest way would be to follow these steps :

-1. `git clone git@github.com:EtixLabs/cameradar.git`
-2. Go into the Cameradar repository, create a directory named `build`
+1. `git clone https://github.com/EtixLabs/cameradar.git`
+2. Go into the Cameradar repository, create a directory named `build` and go in it
 3. In the build directory, run `cmake ..` This will generate the Makefiles you need to build Cameradar
 4. Run the command `make`
 5. This should compile Cameradar. Go into the `cameradar_standalone` directory
 6. You can now customize the `conf/cameradar.conf.json` file to set the subnetworks and specific ports you want to scan, as well as the thumbnail generation path. More information will be given about the configuration file in another part of this document.
 7. You are now ready to launch Cameradar by launching `./cameradar` in the cameradar_standalone directory.

+## Advanced Docker deployment
+
+### Dependencies
+
+The only dependencies are `docker` and `docker-compose`.
+
+### Deploy a custom version of Cameradar
+
+2. Go into the Cameradar repository, create a directory named `build` and go in it
+3. In the build directory, run `cmake .. -DCMAKE_BUILD_TYPE=Release` This will generate the Makefiles you need to build Cameradar
+4. Run the command `make package` to compile it into a package
+5. Copy your package into the `deployment` directory
+6. Run `docker-compose build cameradar` to build the cameradar container using your custom package
+5. Run `docker-compose up cameradar` to launch Cameradar
+
+
 ### Configuration

 Here is the basic content of the configuration file with simple placeholders :
 ```json
 {
+  "mysql_db" : {
+     "host" : "MYSQL_SERVER_IP_ADDRESS",
+     "port" : MYSQL_SERVER_PORT,
+     "user": "root",
+     "password": "root",
+     "db_name": "cmrdr"
+  },
  "subnets" : "SUBNET1,SUBNET2,SUBNET3,[...]",
  "ports" : "PORT1,PORT2,[...]",
  "rtsp_url_file" : "conf/url.json",
@@ -69,8 +128,6 @@ The cache manager path and name variables are used to change the cache manager y

 ## Output

-Here you go :
-
 ```json
 {
   "address" : "173.16.100.45",
@@ -152,7 +209,8 @@ If you have other cool ideas, feel free to share them with me at brendan.leglaun

 ## Next improvements

- [ ] Development of a MySQL cache manager
+- [x] Add a docker deployment to avoid the current deps hell
+- [x] Development of a MySQL cache manager
 - [ ] Development of a JSON file cache manager
 - [ ] Development of an XML file cache manager

@@ -16,8 +16,9 @@ cmake_minimum_required (VERSION 2.8.1)
 cmake_policy(SET CMP0042 NEW)

 # set temporarly the ouput path for all server plugins
-set (LIBRARY_OUTPUT_PATH ${CCTV_CAMERA_MANAGER_OUTPUT_PATH})
+set (LIBRARY_OUTPUT_PATH ${CAMERADAR_CACHE_MANAGER_OUTPUT_PATH})

 add_subdirectory(dumb_cache_manager)
+add_subdirectory(mysql_cache_manager)

-set (CCTV_CACHE_MANAGERS ${CCTV_CACHE_MANAGERS} PARENT_SCOPE)
+set (CAMERADAR_CACHE_MANAGERS ${CAMERADAR_CACHE_MANAGERS} PARENT_SCOPE)
@@ -20,7 +20,6 @@ project(dumb_cache_manager CXX)
 find_package(PkgConfig)

 include_directories (${PROJECT_SOURCE_DIR}/include ${CAMERADAR_INCLUDES})
-message("${CAMERADAR_INCLUDES}")

 include (find_sources)
 find_sources ("src" "include")
@@ -29,6 +28,6 @@ add_library (dumb_cache_manager SHARED ${SOURCES})
 set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined")
 target_link_libraries (dumb_cache_manager)

-set (CACHE_MANAGER_NAME ${CAMERADAR_CACHE_MANAGER_OUTPUT_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}dumb_cache_manager{CMAKE_SHARED_LIBRARY_SUFFIX})
+set (CACHE_MANAGER_NAME ${CAMERADAR_CACHE_MANAGER_OUTPUT_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}dumb_cache_manager${CMAKE_SHARED_LIBRARY_SUFFIX})
 list (APPEND CAMERADAR_CACHE_MANAGERS ${CACHE_MANAGER_NAME})
 set (CAMERADAR_CACHE_MANAGERS ${CAMERADAR_CACHE_MANAGERS} PARENT_SCOPE)
@@ -14,11 +14,11 @@

 #pragma once

-#include <vector>
 #include <cachemanager.h>
-#include <stream_model.h>
 #include <configuration.h>
 #include <logger.h>
+#include <stream_model.h>
+#include <vector>

 namespace etix {
 namespace cameradar {
@@ -42,9 +42,9 @@ public:

    void update_stream(const etix::cameradar::stream_model& newmodel);

-    std::vector<etix::cameradar::stream_model> get_streams() const;
+    std::vector<etix::cameradar::stream_model> get_streams();

-    std::vector<etix::cameradar::stream_model> get_valid_streams() const;
+    std::vector<etix::cameradar::stream_model> get_valid_streams();
 };
 }
 }
@@ -60,7 +60,7 @@ dumb_cache_manager::update_stream(const etix::cameradar::stream_model& newmodel)

 //! Gets all cached streams
 std::vector<etix::cameradar::stream_model>
-dumb_cache_manager::get_streams() const {
+dumb_cache_manager::get_streams() {
    std::vector<stream_model> ret;
    for (const auto& it : this->streams) {
        if (not it.service_name.compare("rtsp") && not it.state.compare("open")) ret.push_back(it);
@@ -70,7 +70,7 @@ dumb_cache_manager::get_streams() const {

 //! Gets all valid streams
 std::vector<etix::cameradar::stream_model>
-dumb_cache_manager::get_valid_streams() const {
+dumb_cache_manager::get_valid_streams() {
    std::vector<stream_model> ret;
    for (const auto& it : this->streams) {
        if ((not it.service_name.compare("rtsp") && not it.state.compare("open")) && it.ids_found &&
@@ -0,0 +1,33 @@
+## Copyright 2016 Etix Labs
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+cmake_minimum_required (VERSION 2.8.1)
+cmake_policy(SET CMP0042 NEW)
+
+project(mysql_cache_manager CXX)
+
+find_package(PkgConfig)
+
+include_directories (${PROJECT_SOURCE_DIR}/include ${CAMERADAR_INCLUDES})
+
+include (find_sources)
+find_sources ("src" "include")
+
+add_library (mysql_cache_manager SHARED ${SOURCES})
+set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined")
+target_link_libraries (mysql_cache_manager jsoncpp mysqlcppconn pthread)
+
+set (CACHE_MANAGER_NAME ${CAMERADAR_CACHE_MANAGER_OUTPUT_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}mysql_cache_manager${CMAKE_SHARED_LIBRARY_SUFFIX})
+list (APPEND CAMERADAR_CACHE_MANAGERS ${CACHE_MANAGER_NAME})
+set (CAMERADAR_CACHE_MANAGERS ${CAMERADAR_CACHE_MANAGERS} PARENT_SCOPE)
@@ -0,0 +1,85 @@
+// Copyright 2016 Etix Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cppconn/resultset.h> // for ResultSet
+#include <mutex>               // for mutex
+#include <stdbool.h>           // for bool, false
+#include <string>              // for string
+#include <utility>             // for pair, make_pair
+
+#include "query_result.h"
+
+namespace sql {
+class Connection;
+class Driver;
+class ResultSet;
+}
+
+namespace etix {
+
+namespace cameradar {
+
+namespace mysql {
+
+//! MySQL Database connection handling
+//! Abstracts all connection to the database
+class db_connection {
+private:
+    static const std::string create_database_query;
+
+    //! SQL driver
+    sql::Driver* driver = nullptr;
+    //! SQL connection
+    sql::Connection* connection = nullptr;
+    std::mutex access_mtx;
+    bool connected = false;
+
+    std::string db_name;
+
+    //! Create the database if it doesn't exist at connector launch
+    empty_result create_database(void);
+
+public:
+    db_connection(void);
+    ~db_connection(void);
+
+    //! Try to connect to the database
+    std::pair<bool, std::string> connect(const std::string& host,
+                                         const std::string& user,
+                                         const std::string& pass,
+                                         const std::string& db_name,
+                                         bool create_db_if_not_exist = true);
+
+    //! Execute a MySQL command
+    empty_result execute(const std::string& request);
+
+    //! Execute a query
+    query_result<sql::ResultSet*> query(const std::string& query);
+
+    bool is_connected();
+
+    //! Return db_name
+    const std::string&
+    get_db_name(void) const {
+        return this->db_name;
+    }
+};
+
+} // mysql
+
+} // cameradar
+
+} // etix
@@ -0,0 +1,81 @@
+// Copyright 2016 Etix Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cachemanager.h>
+#include <configuration.h>
+#include <db_conn.h>
+#include <fmt.h>
+#include <logger.h>
+#include <stream_model.h>
+#include <vector>
+
+namespace etix {
+
+namespace cameradar {
+
+struct mysql_configuration {
+    unsigned int port;
+    std::string host;
+    std::string db_name;
+    std::string user;
+    std::string password;
+
+    mysql_configuration() = default;
+
+    mysql_configuration(unsigned int port,
+                        const std::string& host,
+                        const std::string& db_name,
+                        const std::string& user = "",
+                        const std::string& password = "")
+    : port(port), host(host), db_name(db_name), user(user), password(password) {}
+};
+
+class mysql_cache_manager : public cache_manager_base {
+private:
+    static const std::string name;
+    std::vector<etix::cameradar::stream_model> streams;
+    std::shared_ptr<etix::cameradar::configuration> configuration;
+    etix::cameradar::mysql_configuration db_conf;
+    etix::cameradar::mysql::db_connection connection;
+
+    static const std::string create_table_query;
+    static const std::string insert_with_id_query;
+    static const std::string exist_query;
+    static const std::string get_results_query;
+    static const std::string update_result_query;
+
+public:
+    using cache_manager_base::cache_manager_base;
+    ~mysql_cache_manager();
+
+    // Specific to MySQL
+    bool execute_query(const std::string& query);
+
+    const std::string& get_name() const override;
+    static const std::string& static_get_name();
+    bool load_mysql_conf(std::shared_ptr<etix::cameradar::configuration> configuration);
+    bool configure(std::shared_ptr<etix::cameradar::configuration> configuration) override;
+
+    void set_streams(std::vector<etix::cameradar::stream_model> model);
+
+    void update_stream(const etix::cameradar::stream_model& newmodel);
+
+    std::vector<etix::cameradar::stream_model> get_streams();
+
+    std::vector<etix::cameradar::stream_model> get_valid_streams();
+};
+}
+}
@@ -0,0 +1,65 @@
+// Copyright 2016 Etix Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+namespace etix {
+
+namespace cameradar {
+
+namespace mysql {
+
+enum class execute_result { success, not_found, no_row_updated, sql_error, error };
+
+//! Wrapper of a DB query result
+//! Templated on the data type we want to return (list<model>, bool, whatever)
+template <typename DataType>
+struct query_result {
+    DataType data;
+    execute_result state;
+    std::string error_msg;
+
+    inline bool
+    success(void) const {
+        return state == execute_result::success;
+    }
+    inline bool
+    error(void) const {
+        return not success();
+    }
+};
+
+//! Empty query result for when we just want to return the status
+//! of the request with no associated data
+template <>
+struct query_result<void> {
+    execute_result state;
+    std::string error_msg;
+
+    inline bool
+    success(void) const {
+        return state == execute_result::success;
+    }
+    inline bool
+    error(void) const {
+        return not success();
+    }
+};
+typedef query_result<void> empty_result;
+
+} //! mysql
+
+} //! cameradar
+
+} //! etix
@@ -0,0 +1,139 @@
+// Copyright 2016 Etix Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "db_conn.h"            // for db_connection
+#include "cppconn/connection.h" // for Connection
+#include "query_result.h"       // for queries
+#include <cppconn/driver.h>     // for get_driver_instance, etc
+#include <cppconn/exception.h>  // for SQLException
+#include <cppconn/statement.h>  // for Statement
+#include <fmt.h>                // for fmt
+#include <logger.h>             // for LOG_
+
+namespace etix {
+
+namespace cameradar {
+
+namespace mysql {
+
+const std::string db_connection::create_database_query = "CREATE DATABASE IF NOT EXISTS %s";
+
+db_connection::db_connection() : connected(false) {}
+
+db_connection::~db_connection() { delete this->connection; }
+
+std::pair<bool, std::string>
+db_connection::connect(const std::string& host,
+                       const std::string& user,
+                       const std::string& pass,
+                       const std::string& db_name,
+                       bool create_db_if_not_exist) {
+    this->db_name = db_name;
+
+    try {
+        this->driver = get_driver_instance();
+        if (this->driver == nullptr) {
+            return std::make_pair(false, "Cannot instantiate sql_driver");
+        }
+        this->connection = driver->connect(host, user, pass);
+        if (this->connection == nullptr) return std::make_pair(false, "Cannot connect to mysql");
+
+        this->connected = true;
+        if (create_db_if_not_exist) {
+            auto cdb = this->create_database();
+            if (cdb.state == mysql::execute_result::sql_error) { return { false, cdb.error_msg }; }
+            this->connection->setSchema(db_name);
+        }
+    } catch (sql::SQLException& e) {
+        this->connected = false;
+        return { false, e.what() };
+    }
+
+    return std::make_pair(true, "");
+}
+
+empty_result
+db_connection::execute(const std::string& request) {
+    std::lock_guard<std::mutex> lock(this->access_mtx);
+
+    sql::Statement* stmt = nullptr;
+    empty_result return_value = { execute_result::success, "" };
+
+    if (!this->is_connected()) {
+        return { execute_result::sql_error, "Error, not connected to MySQL database" };
+    }
+
+    try {
+        stmt = this->connection->createStatement();
+        stmt->execute(request);
+        if (stmt->getUpdateCount() == 0) {
+            return_value = { execute_result::no_row_updated, "No row updated" };
+        }
+    } catch (sql::SQLException& e) { return_value = { execute_result::sql_error, e.what() }; }
+    if (stmt) { delete stmt; }
+
+    return return_value;
+}
+
+query_result<sql::ResultSet*>
+db_connection::query(const std::string& query) {
+    std::lock_guard<std::mutex> lock(this->access_mtx);
+
+    sql::Statement* stmt = nullptr;
+    query_result<sql::ResultSet*> return_value = { nullptr, execute_result::success, "" };
+
+    if (!this->is_connected()) {
+        return { nullptr, execute_result::sql_error, "Error, not connected to MySQL database" };
+    }
+
+    try {
+        stmt = this->connection->createStatement();
+        return_value = { stmt->executeQuery(query), execute_result::success, "" };
+    } catch (sql::SQLException& e) {
+        return_value = { nullptr, execute_result::sql_error, e.what() };
+    }
+
+    if (stmt) { delete stmt; }
+
+    return return_value;
+}
+
+bool
+db_connection::is_connected() {
+    if (this->connection == nullptr) return false;
+
+    // check if our connection is always valid
+    if (this->connection->isClosed() || not this->connection->isValid()) {
+        LOG_INFO_("MySQL database connection is either closed or invalid, try to reconnect.",
+                  "db_connection");
+        this->connection->reconnect();
+        if (this->connection->isClosed() || not this->connection->isValid()) {
+            this->connected = false;
+            LOG_ERR_("Unable to reconnect to MySQL.", "db_connection");
+        }
+    }
+    return this->connected;
+}
+
+empty_result
+db_connection::create_database() {
+    auto query = tool::fmt(this->create_database_query, this->db_name.c_str());
+    return this->execute(query);
+}
+
+} // mysql
+
+} // cameradar
+
+} // etix
@@ -0,0 +1,269 @@
+// Copyright 2016 Etix Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <mysql_cache_manager.h>
+
+/* DATA FORMAT
+**
+**    Example :
+**
+**   "address" : "173.16.100.45",
+**   "ids_found" : true,
+**   "password" : "123456",
+**   "path_found" : true,
+**   "port" : 554,
+**   "product" : "Vivotek FD9381-HTV",
+**   "protocol" : "tcp",
+**   "route" : "/live.sdp",
+**   "service_name" : "rtsp",
+**   "state" : "open",
+**   "thumbnail_path" : "/tmp/127.0.0.1/1463735257.jpg",
+**   "username" : "admin"
+**
+*/
+
+namespace etix {
+
+namespace cameradar {
+
+const std::string mysql_cache_manager::create_table_query =
+    "CREATE TABLE IF NOT EXISTS `results` ("
+    "`id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT, "
+    "`address` tinytext NOT NULL, "
+    "`password` tinytext NOT NULL, "
+    "`product` tinytext NOT NULL, "
+    "`protocol` tinytext NOT NULL, "
+    "`route` tinytext NOT NULL, "
+    "`service_name` tinytext NOT NULL, "
+    "`state` tinytext NOT NULL, "
+    "`thumbnail_path` tinytext NOT NULL, "
+    "`username` tinytext NOT NULL, "
+    "`port` int(11) UNSIGNED NOT NULL, "
+    "`ids_found` tinytext NOT NULL, "
+    "`path_found` tinytext NOT NULL, "
+    "PRIMARY KEY (`id`));";
+
+const std::string mysql_cache_manager::insert_with_id_query =
+    "INSERT INTO `%s`.`results`"
+    " (`address`, `password`, `product`, `protocol`, `route`, `service_name`, `state`, "
+    "`thumbnail_path`, `username`, `port`, `ids_found`, `path_found`)"
+    " VALUES ('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s')";
+
+const std::string mysql_cache_manager::update_result_query =
+    "UPDATE `%s`.`results` SET"
+    " `results`.`address` = '%s',"
+    " `results`.`password` = '%s',"
+    " `results`.`product` = '%s',"
+    " `results`.`protocol` = '%s',"
+    " `results`.`route` = '%s',"
+    " `results`.`service_name` = '%s',"
+    " `results`.`state` = '%s',"
+    " `results`.`thumbnail_path` = '%s',"
+    " `results`.`username` = '%s',"
+    " `results`.`port` = '%s',"
+    " `results`.`ids_found` = '%s',"
+    " `results`.`path_found` = '%s'"
+    " WHERE `results`.`address` LIKE '%s'";
+
+const std::string mysql_cache_manager::exist_query =
+    "SELECT * FROM `%s`.`results` WHERE `results`.`address` = '%s'";
+
+const std::string mysql_cache_manager::get_results_query = "SELECT * FROM `%s`.`results`";
+
+const std::string mysql_cache_manager::name = "mysql-cache-manager";
+
+mysql_cache_manager::~mysql_cache_manager() {}
+
+const std::string&
+mysql_cache_manager::get_name() const {
+    return mysql_cache_manager::static_get_name();
+}
+
+const std::string&
+mysql_cache_manager::static_get_name() {
+    return mysql_cache_manager::name;
+}
+
+bool
+mysql_cache_manager::configure(std::shared_ptr<etix::cameradar::configuration> configuration) {
+    return this->load_mysql_conf(configuration);
+}
+
+bool
+mysql_cache_manager::execute_query(const std::string& query) {
+    auto check_err = [](const auto& res) {
+        if (res.state == mysql::execute_result::sql_error) {
+            LOG_WARN_(res.error_msg, "mysql_cache_manager");
+            return false;
+        }
+        return true;
+    };
+    return check_err(this->connection.execute(query));
+}
+
+bool
+mysql_cache_manager::load_mysql_conf(
+    std::shared_ptr<etix::cameradar::configuration> configuration) {
+    this->configuration = configuration;
+
+    try {
+        this->db_conf.host = configuration->raw_conf["mysql_db"]["host"].asString();
+        this->db_conf.port = configuration->raw_conf["mysql_db"]["port"].asUInt();
+        this->db_conf.user = configuration->raw_conf["mysql_db"]["user"].asString();
+        this->db_conf.password = configuration->raw_conf["mysql_db"]["password"].asString();
+        this->db_conf.db_name = configuration->raw_conf["mysql_db"]["db_name"].asString();
+    } catch (std::exception& e) {
+        LOG_ERR_("Configuration of the MySQL db failed : " + std::string(e.what()),
+                 "mysql_cache_manager");
+        return false;
+    }
+
+    if (not this->connection
+                .connect(db_conf.host + ":" + std::to_string(db_conf.port),
+                         db_conf.user,
+                         db_conf.password,
+                         db_conf.db_name)
+                .first) {
+        LOG_ERR_("Configuration of the MySQL DB failed", "mysql_cache_manager");
+        return false;
+    }
+
+    // Tries to create the Result table in the DB and returns the success state
+    return (execute_query(create_table_query));
+}
+
+//! Replaces all cached streams by the content of the vector given as
+//! parameter
+void
+mysql_cache_manager::set_streams(std::vector<etix::cameradar::stream_model> models) {
+    LOG_DEBUG_("Beginning stream list DB insertion", "mysql_cache_manager");
+    for (const auto& model : models) {
+        auto query = tool::fmt(
+            this->exist_query, this->connection.get_db_name().c_str(), model.address.c_str());
+        auto result = this->connection.query(query);
+        // If an entry already exists for this address in the database,
+        // no need to insert it.
+        if (result.data->next()) return;
+
+        query = tool::fmt(this->insert_with_id_query,
+                          this->connection.get_db_name().c_str(),
+                          model.address.c_str(),
+                          model.password.c_str(),
+                          model.product.c_str(),
+                          model.protocol.c_str(),
+                          model.route.c_str(),
+                          model.service_name.c_str(),
+                          model.state.c_str(),
+                          model.thumbnail_path.c_str(),
+                          model.username.c_str(),
+                          std::to_string(model.port).c_str(),
+                          std::to_string(model.ids_found).c_str(),
+                          std::to_string(model.path_found).c_str());
+        execute_query(query);
+    }
+}
+
+//! Inserts a single stream to the cache
+void
+mysql_cache_manager::update_stream(const etix::cameradar::stream_model& model) {
+    auto query = tool::fmt(this->update_result_query,
+                           this->connection.get_db_name().c_str(),
+                           model.address.c_str(),
+                           model.password.c_str(),
+                           model.product.c_str(),
+                           model.protocol.c_str(),
+                           model.route.c_str(),
+                           model.service_name.c_str(),
+                           model.state.c_str(),
+                           model.thumbnail_path.c_str(),
+                           model.username.c_str(),
+                           std::to_string(model.port).c_str(),
+                           std::to_string(model.ids_found).c_str(),
+                           std::to_string(model.path_found).c_str(),
+                           model.address.c_str());
+    execute_query(query);
+}
+
+//! Gets all cached streams
+std::vector<etix::cameradar::stream_model>
+mysql_cache_manager::get_streams() {
+    auto query = tool::fmt(this->get_results_query, this->connection.get_db_name().c_str());
+    auto result = this->connection.query(query);
+
+    if (not result.data) {
+        delete result.data;
+        return {};
+    }
+
+    std::vector<stream_model> lst;
+    while (result.data->next()) {
+        // If it's an open RTSP stream
+        if (not result.data->getString("state").compare("open") &&
+            not result.data->getString("service_name").compare("rtsp")) {
+            stream_model s{
+                result.data->getString("address"),     result.data->getUInt("port"),
+                result.data->getString("username"),    result.data->getString("password"),
+                result.data->getString("route"),       result.data->getString("service_name"),
+                result.data->getString("product"),     result.data->getString("protocol"),
+                result.data->getString("state"),       result.data->getBoolean("ids_found"),
+                result.data->getBoolean("path_found"), result.data->getString("thumbnail_path")
+            };
+            lst.push_back(s);
+        }
+    }
+
+    delete result.data;
+    return lst;
+}
+
+//! Gets all valid streams
+std::vector<etix::cameradar::stream_model>
+mysql_cache_manager::get_valid_streams() {
+    auto query = tool::fmt(this->get_results_query, this->connection.get_db_name().c_str());
+    auto result = this->connection.query(query);
+
+    if (not result.data) {
+        delete result.data;
+        return {};
+    }
+
+    std::vector<stream_model> lst;
+    while (result.data->next()) {
+        // If the ID and the Path were found add this stream
+        if (not result.data->getString("ids_found").compare("1") &&
+            not result.data->getString("path_found").compare("1")) {
+            stream_model s{
+                result.data->getString("address"),     result.data->getUInt("port"),
+                result.data->getString("username"),    result.data->getString("password"),
+                result.data->getString("route"),       result.data->getString("service_name"),
+                result.data->getString("product"),     result.data->getString("protocol"),
+                result.data->getString("state"),       result.data->getBoolean("ids_found"),
+                result.data->getBoolean("path_found"), result.data->getString("thumbnail_path")
+            };
+            lst.push_back(s);
+        }
+    }
+
+    delete result.data;
+    return lst;
+}
+
+extern "C" {
+cache_manager_iface*
+cache_manager_instance_new() {
+    return new mysql_cache_manager();
+}
+}
+}
+}
@@ -13,7 +13,7 @@
 ## limitations under the License.

 cmake_minimum_required (VERSION 2.8.1)
-cmake_policy(SET CMP0042 NEW)
+cmake_policy(SET CMP0048 OLD)

 project(cameradar CXX)

@@ -23,11 +23,15 @@ include(FindPkgConfig)
 pkg_search_module(GSTREAMER REQUIRED gstreamer-1.0)
 find_library(LIB_GSTREAMER NAMES ${GSTREAMER_LIBRARIES} HINTS ${GSTREAMER_LIBRARY_DIRS})

-include_directories (${GSTREAMER_INCLUDE_DIRS})
+include_directories (
+  ${GSTREAMER_INCLUDE_DIRS}
+	${PROJECT_SOURCE_DIR}/include
+	${VERSION_INCLUDE_DIR}
+)

 link_directories (
        ${GSTREAMER_LIBRARY_DIRS}
-        "../../cctv_server2/deps/jsoncpp/src/deps.jsoncpp/src/lib_json"
+        "../deps/jsoncpp/src/deps.jsoncpp/src/lib_json"
 )

 if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
@@ -52,4 +56,5 @@ add_custom_command(TARGET cameradar PRE_BUILD
                 ${CMAKE_SOURCE_DIR}/cameradar_standalone/conf $<TARGET_FILE_DIR:cameradar>/conf/)

 set (BINARIES_NAME ${PROJECT_BINARY_DIR}/cameradar)
-list (APPEND CCTV_BINARIES ${BINARIES_NAME})
+list (APPEND CAMERADAR_BINARIES ${BINARIES_NAME})
+set (CAMERADAR_BINARIES ${CAMERADAR_BINARIES} PARENT_SCOPE)
@@ -1,5 +1,13 @@
 {
-  "subnets" : "172.16.100.13,localhost",
+  "mysql_db" : {
+    "host" : "0.0.0.0",
+    "port" : 3306,
+    "user": "root",
+    "password": "root",
+    "db_name": "cctv_dev"
+  },
+
+  "subnets" : "172.16.100.11",

  // If not specified, will scan all ports (1-65535)
  "ports" : "554,8554",
@@ -9,6 +17,9 @@
  // You must give an accessible path to an already existing directory
  "thumbnail_storage_path" : "/tmp",

-  "cache_manager_path" : "../cache_managers/dumb_cache_manager",
-  "cache_manager_name" : "dumb"
+  // This is the path that will be used in the Docker container
+  // if you're not familiar with Docker, only change the
+  // cache_manager_name value
+  "cache_manager_path" : "../cache_managers",
+  "cache_manager_name" : "mysql"
 }
@@ -14,10 +14,10 @@

 #pragma once

-#include <vector>
+#include <configuration.h>
 #include <memory>
 #include <stream_model.h>
-#include <configuration.h>
+#include <vector>

 namespace etix {
 namespace cameradar {
@@ -42,10 +42,10 @@ public:
    virtual void update_stream(const etix::cameradar::stream_model& newmodel) = 0;

    //! Gets all cached streams
-    virtual std::vector<etix::cameradar::stream_model> get_streams() const = 0;
+    virtual std::vector<etix::cameradar::stream_model> get_streams() = 0;

    //! Gets all valid streams which have been accessed
-    virtual std::vector<etix::cameradar::stream_model> get_valid_streams() const = 0;
+    virtual std::vector<etix::cameradar::stream_model> get_valid_streams() = 0;
 };

 class cache_manager_base : public cache_manager_iface {
@@ -68,10 +68,10 @@ public:
    virtual void update_stream(const etix::cameradar::stream_model& newmodel) = 0;

    //! Gets all cached streams
-    virtual std::vector<etix::cameradar::stream_model> get_streams() const = 0;
+    virtual std::vector<etix::cameradar::stream_model> get_streams() = 0;

    //! Gets all valid streams which have been accessed
-    virtual std::vector<etix::cameradar::stream_model> get_valid_streams() const = 0;
+    virtual std::vector<etix::cameradar::stream_model> get_valid_streams() = 0;

    //! Get the manager's instance
    cache_manager_base& get_instance();
@@ -14,11 +14,15 @@

 #pragma once

+#include <assert.h> // assert
 #include <csignal>  // sigint
 #include <iostream> // stc::cout
-#include <assert.h> // assert
+
+// To avoid an unused warning for the asserted in handle_signal
+#define _unused(x) ((void)(x))

 namespace etix {
+
 namespace cameradar {

 enum class stop_priority { running, stop, force_stop };
@@ -30,6 +34,7 @@ public:
    virtual int
    handle_signal(int signum) {
        assert(signum == SIGINT);
+        _unused(signum);
        std::cout << "\b\b\b\033[K";
        if (this->ss == stop_priority::running)
            this->ss = stop_priority::stop;
@@ -14,8 +14,8 @@

 #pragma once

-#include <string>
 #include <json/value.h>
+#include <string>

 namespace etix {
 namespace cameradar {
@@ -24,7 +24,7 @@ struct stream_model {
    // Ex : "172.16.100.113"
    std::string address;
    // Ex : 8554
-    unsigned short port;
+    unsigned int port;
    // Ex : "admin"
    std::string username = "";
    // Ex : "123456"
@@ -14,12 +14,11 @@

 #pragma once

-#include <cameradar_task.h>                // task interface
-#include <boost/algorithm/string/find.hpp> // boost::find
-#include <iostream>                        // std::ofstream
-#include <fstream>                         // std::ofstream
-#include <stream_model.h>                  // data model
-#include <cachemanager.h>                  // cacheManager
+#include <cachemanager.h>   // cacheManager
+#include <cameradar_task.h> // task interface
+#include <fstream>          // std::ofstream
+#include <iostream>         // std::ofstream
+#include <stream_model.h>   // data model

 namespace etix {
 namespace cameradar {
@@ -12,9 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

+#include <configuration.h> // configuration
 #include <fstream>         // std::ifstream
 #include <unistd.h>        // access, F_OK
-#include <configuration.h> // configuration

 namespace etix {

@@ -22,9 +22,9 @@ namespace cameradar {

 const std::string configuration::name_ = "configuration";

-// read a file at the path "path"
-// if the file is available we return the whole content as an std::string inside
-// a pair
+// Read a file at the path "path"
+// If the file is available we return the whole content as
+// an std::string inside a pair
 // otherwise return false and an empty string inside a pair
 std::pair<bool, std::string>
 read_file(const std::string& path) {
@@ -107,14 +107,6 @@ configuration::load_url() {
        auto root = Json::Value();
        auto reader = Json::Reader();
        reader.parse(content, root);
-        //    auto result = tool::json::check_fields(
-        //        {{"urls", Json::arrayValue, root["urls"]}}, "general
-        //        configuration");
-
-        //    if (not result.first) {
-        //      LOG_ERR_(result.second, "general configuration");
-        //      return false;
-        //    }

        for (unsigned int i = 0; i < root["urls"].size(); i++) {
            if (not root["urls"][i].isString()) {
@@ -194,7 +186,6 @@ load(const std::string& path) {
    }
    // Deserialize the json to a configuration struct
    // and return
-    // REPLACE THIS WITH JSONCPP
    std::pair<bool, configuration> conf = serialize(root);
    conf.second.raw_conf = root;
    conf.first &= conf.second.load_url();
@@ -20,12 +20,20 @@ namespace cameradar {
 // The main loop of the binary
 void
 dispatcher::run() {
+    if (not(*cache)->configure(std::make_shared<configuration>(conf))) {
+        LOG_ERR_(
+            "There was a problem with the cache manager, Cameradar can't work properly without "
+            "cache management",
+            "dispatcher");
+        return;
+    }
    std::thread worker(&dispatcher::do_stuff, this);
    using namespace std::chrono_literals;
-    // catch CTRL+C signal
+
+    // Catch CTRL+C signal
    signal_handler::instance();

-    // wait for event or end
+    // Wait for event or end
    while (signal_handler::instance().should_stop() not_eq stop_priority::stop &&
           current != task::finished) {
        std::this_thread::sleep_for(30ms);
@@ -36,7 +44,7 @@ dispatcher::run() {
        LOG_INFO_("Press CTRL+C again to force stop", "dispatcher");
    }

-    // waiting for task to cleanup / force stop command
+    // Waiting for task to cleanup / force stop command
    while ((signal_handler::instance().should_stop() not_eq stop_priority::force_stop) and
           doing_stuff()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(30));
@@ -76,7 +84,8 @@ dispatcher::do_stuff() {
        if (queue.front()->run())
            queue.pop_front();
        else {
-            LOG_ERR_("An error occured in one of the tasks, Cameradar will now stop.", "dispatcher");
+            LOG_ERR_("An error occured in one of the tasks, Cameradar will now stop.",
+                     "dispatcher");
            break;
        }
    }
@@ -12,12 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include <fs.h>         // fs::home
-#include <opt_parse.h>  // parsing opt
+#include "version.h"    // versionning
 #include <dispatcher.h> // program loop
+#include <fs.h>         // fs::home
+#include <iostream>     // iostream
+#include <opt_parse.h>  // parsing opt

 namespace cmrdr = etix::cameradar;

+void
+print_version() {
+    std::cout << "Cameradar version " << CAMERADAR_VERSION << std::endl;
+    std::cout << "Build " << CAMERADAR_VERSION_BUILD << std::endl;
+    std::cout << "Git commit " << CAMERADAR_VERSION_GIT_SHA1 << std::endl;
+}
+
 // Command line parsing
 std::pair<bool, etix::tool::opt_parse>
 parse_cmdline(int argc, char* argv[]) {
@@ -37,7 +46,7 @@ parse_cmdline(int argc, char* argv[]) {
        opt_parse.print_help();
        return std::make_pair(false, opt_parse);
    } else if (opt_parse.exist("-v")) {
-        std::cout << "Cameradar 0.1" << std::endl;
+        print_version();
        return std::make_pair(false, opt_parse);
    } else if (opt_parse.has_error()) {
        std::cout << "Usage: ./cameradar [option]\n\toptions:\n" << std::endl;
@@ -76,6 +85,7 @@ main(int argc, char* argv[]) {
    auto args = parse_cmdline(argc, argv);
    if (not args.first) return EXIT_FAILURE;

+    print_version();
    // configure file configuration path
    auto conf_path = std::string{};
    if (not args.second.exist("-c")) {
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-#include <tasks/brutelogs.h>
 #include <cachemanager.h>
+#include <tasks/brutelogs.h>

 namespace etix {
 namespace cameradar {
@@ -36,10 +36,10 @@ brutelogs::test_ids(const etix::cameradar::stream_model& stream,
    std::string path = stream.service_name + "://";
    if (username != "" || password != "") { path += username + ":" + password + "@"; }
    path += stream.address + ":" + std::to_string(stream.port);
-    LOG_DEBUG_("Testing ids : " + path, "bruteforce");
+    LOG_DEBUG_("Testing ids : " + path, "brutelogs");
    try {
        if (curl_describe(path, true)) {
-            LOG_DEBUG_("[FOUND IDS] : " + path, "bruteforce");
+            LOG_DEBUG_("[FOUND IDS] : " + path, "brutelogs");
            found = true;
            stream_model newstream{
                stream.address, stream.port,         username,       password,
@@ -55,7 +55,7 @@ brutelogs::test_ids(const etix::cameradar::stream_model& stream,
            (*cache)->update_stream(newstream);
        }
    } catch (const std::runtime_error& e) {
-        LOG_DEBUG_("Ids already tested : " + std::string(e.what()), "bruteforce");
+        LOG_DEBUG_("Ids already tested : " + std::string(e.what()), "brutelogs");
    }
    return found;
 }
@@ -75,7 +75,7 @@ brutelogs::run() const {
    LOG_INFO_(
        "Beginning bruteforce of the usernames and passwords task, it may "
        "take a while.",
-        "bruteforce");
+        "brutelogs");
    std::vector<etix::cameradar::stream_model> streams = (*cache)->get_streams();
    bool doubleskip;
    size_t found = 0;
@@ -88,7 +88,7 @@ brutelogs::run() const {
                          " : This camera's ids were already discovered in "
                          "the database. Skipping to "
                          "the next camera.",
-                      "bruteforce");
+                      "brutelogs");
            ++found;
        } else {
            for (const auto& username : conf.usernames) {
@@ -110,12 +110,12 @@ brutelogs::run() const {
        }
    }
    if (!found) {
-        LOG_WARN_(no_ids_warning_, "bruteforce");
+        LOG_WARN_(no_ids_warning_, "brutelogs");
        return false;
    } else
        LOG_INFO_("Found " + std::to_string(found) + " ids for " + std::to_string(streams.size()) +
                      " cameras",
-                  "bruteforce");
+                  "brutelogs");
    return true;
 }
 }
@@ -28,9 +28,12 @@ namespace cameradar {
 //! problem.
 bool
 nmap_is_ok() {
-    return (launch_command("test `dpkg -l | cut -c 5-9 | grep nmap` = nmap")
-    // && launch_command("test `nmap --version | cut -c 14-18  | head -n2 | tail -n1` = 6.47")
-    && launch_command("mkdir -p scans")); // Creates the directory in which the scans will be stored
+    return (
+        launch_command("test `dpkg -l | cut -c 5-9 | grep nmap` = nmap")
+        // && launch_command("test `nmap --version | cut -c 14-18  | head -n2 | tail -n1` = 6.47")
+        &&
+        launch_command(
+            "mkdir -p scans")); // Creates the directory in which the scans will be stored
 }

 //! Launches and checks the return of the nmap command
@@ -44,6 +47,7 @@ mapping::run() const {
        LOG_INFO_("Beginning mapping task. This may take a while.", "mapping");
        std::string cmd =
            "nmap -T4 -A " + subnets + " -p " + this->conf.ports + " -oX " + nmap_output;
+        LOG_DEBUG_("Launching nmap : " + cmd, "mapping");
        bool ret = launch_command(cmd);
        if (ret)
            LOG_INFO_("Nmap XML output successfully generated in file: " + nmap_output, "mapping");
@@ -81,11 +81,11 @@ set(BOOST_LIBRARY_DIR ${BOOST_LIBRARY_DIR} PARENT_SCOPE)

 # list all the boost libraries .dylib/.so
 file(GLOB BOOST_INSTALL_DEPENDENCIES "${BOOST_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}boost_*${CMAKE_SHARED_LIBRARY_SUFFIX}")
-list (APPEND CCTV_INSTALL_DEPENDENCIES ${BOOST_INSTALL_DEPENDENCIES})
+list (APPEND CAMERADAR_INSTALL_DEPENDENCIES ${BOOST_INSTALL_DEPENDENCIES})
 # on linux
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
  file(GLOB BOOST_INSTALL_DEPENDENCIES "${BOOST_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}boost_*${CMAKE_SHARED_LIBRARY_SUFFIX}.${BOOST_VERSION}")
-  list (APPEND CCTV_INSTALL_DEPENDENCIES ${BOOST_INSTALL_DEPENDENCIES})
+  list (APPEND CAMERADAR_INSTALL_DEPENDENCIES ${BOOST_INSTALL_DEPENDENCIES})
 endif()

-set(CCTV_INSTALL_DEPENDENCIES ${CCTV_INSTALL_DEPENDENCIES} PARENT_SCOPE)
+set(CAMERADAR_INSTALL_DEPENDENCIES ${CAMERADAR_INSTALL_DEPENDENCIES} PARENT_SCOPE)
@@ -43,6 +43,6 @@ set (JSONCPP_LIBRARY_DIR "${SOURCE_DIR}/src/lib_json")
 set (JSONCPP_LIBRARY_DIR ${JSONCPP_LIBRARY_DIR} PARENT_SCOPE)

 file(GLOB JSONCPP_INSTALL_DEPENDENCIES "${JSONCPP_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}jsoncpp*${CMAKE_SHARED_LIBRARY_SUFFIX}*")
-list (APPEND CCTV_INSTALL_DEPENDENCIES ${JSONCPP_INSTALL_DEPENDENCIES})
+list (APPEND CAMERADAR_INSTALL_DEPENDENCIES ${JSONCPP_INSTALL_DEPENDENCIES})

-set(CCTV_INSTALL_DEPENDENCIES ${CCTV_INSTALL_DEPENDENCIES} PARENT_SCOPE)
+set(CAMERADAR_INSTALL_DEPENDENCIES ${CAMERADAR_INSTALL_DEPENDENCIES} PARENT_SCOPE)
@@ -0,0 +1,43 @@
+# Copyright (C) 2015 Etix Labs - All Rights Reserved.
+# All information contained herein is, and remains the property of Etix Labs and its suppliers,
+# if any. The intellectual and technical concepts contained herein are proprietary to Etix Labs
+# Dissemination of this information or reproduction of this material is strictly forbidden unless
+# prior written permission is obtained from Etix Labs.
+
+# MySQL Connector dependency
+message(STATUS "Configuring deps.mysqlconnector")
+
+set (MYSQL_CONNECTOR_VERSION 1.1.6)
+set (MD5 9e49dcfc1408b18b3d3ca02781ff7efb)
+set (MYSQL_CONNECTOR_DIR mysql-connector)
+set (MYSQL_CONNECTOR_PATH ${DEPS_DIR}/${MYSQL_CONNECTOR_DIR})
+
+set (BOOST_ROOT_DIR ${DEPS_DIR}/boost/src/deps.boost)
+
+# include(ExternalProject)
+ExternalProject_Add(
+    deps.mysql_connector
+    PREFIX ${MYSQL_CONNECTOR_PATH}
+    URL http://dev.mysql.com/get/Downloads/Connector-C++/mysql-connector-c++-${MYSQL_CONNECTOR_VERSION}.tar.gz
+    URL_HASH MD5=${MD5}
+    CONFIGURE_COMMAND ${CMAKE_COMMAND} -DBOOST_ROOT=${BOOST_ROOT_DIR} "-DCMAKE_INSTALL_PREFIX=${MYSQL_CONNECTOR_PATH}" -DBUILD_TYPE=Release -DMYSQL_CXXFLAGS=-fexceptions <SOURCE_DIR>
+    BUILD_IN_SOURCE ON
+    UPDATE_COMMAND ""
+    BUILD_COMMAND ${CMAKE_MAKE_PROGRAM}
+    INSTALL_COMMAND ${CMAKE_MAKE_PROGRAM} install
+    LOG_DOWNLOAD ON
+    LOG_UPDATE ON
+    LOG_CONFIGURE ON
+    LOG_BUILD ON
+)
+
+set (MYSQL_CONNECTOR_INCLUDE_DIR "${MYSQL_CONNECTOR_PATH}/include" PARENT_SCOPE)
+set (MYSQL_CONNECTOR_LIBRARY_DIR "${MYSQL_CONNECTOR_PATH}/lib")
+
+set (MYSQL_CONNECTOR_LIBRARY_DIR ${MYSQL_CONNECTOR_LIBRARY_DIR} PARENT_SCOPE)
+
+# list all the hiredis libraries
+file(GLOB MYSQL_CONNECTOR_INSTALL_DEPENDENCIES "${MYSQL_CONNECTOR_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}mysqlcppconn*${CMAKE_SHARED_LIBRARY_SUFFIX}*")
+list (APPEND CAMERADAR_INSTALL_DEPENDENCIES ${MYSQL_CONNECTOR_INSTALL_DEPENDENCIES})
+
+set(CAMERADAR_INSTALL_DEPENDENCIES ${CAMERADAR_INSTALL_DEPENDENCIES} PARENT_SCOPE)
@@ -0,0 +1,23 @@
+FROM ubuntu:15.10
+
+MAINTAINER brendan.leglaunec@etixgroup.com
+
+ENV LD_LIBRARY_PATH="/cameradar/libraries"
+
+RUN apt-get update && apt-get install -y \
+    nmap \
+    ffmpeg \
+    libgstreamer1.0-dev \
+    gstreamer1.0-plugins-base \
+    gstreamer1.0-plugins-good \
+    libcurl4-openssl-dev \
+    libmysqlclient18 \
+    mysql-client
+
+ADD cameradar_*_Release_Linux.tar.gz /
+RUN mv cameradar_*_Release_Linux cameradar
+
+RUN mkdir /conf
+ADD run.sh /run.sh
+
+CMD ["/run.sh"]
@@ -0,0 +1,25 @@
+{
+  "mysql_db" : {
+    "host" : "__MYSQL_ADDR__",
+    "port" : __MYSQL_PORT__,
+    "user": "root",
+    "password": "root",
+    "db_name": "cmrdr"
+  },
+
+  "subnets" : "localhost",
+
+  // If not specified, will scan all ports (1-65535)
+  "ports" : "554,8554",
+  "rtsp_url_file" : "conf/url.json",
+  "rtsp_ids_file" : "conf/ids.json",
+
+  // You must give an accessible path to an already existing directory
+  "thumbnail_storage_path" : "/tmp",
+
+  // This is the path that will be used in the Docker container
+  // if you're not familiar with Docker, only change the
+  // cache_manager_name value
+  "cache_manager_path" : "/cameradar/cache_managers",
+  "cache_manager_name" : "mysql"
+}
@@ -0,0 +1,31 @@
+{
+  "username": [
+    "",
+    "admin",
+    "Admin",
+    "root",
+    "supervisor",
+    "ubnt"
+  ],
+  "password" : [
+    "",
+    "admin",
+    "9999",
+    "123456",
+    "pass",
+    "camera",
+    "1234",
+    "12345",
+    "fliradmin",
+    "system",
+    "jvc",
+    "meinsm",
+    "root",
+    "4321",
+    "1111111",
+    "password",
+    "ikwd",
+    "supervisor",
+    "ubnt"
+  ]
+}
@@ -0,0 +1,77 @@
+{
+   "urls" : [
+       "/",
+       "/1.AMP",
+       "/1/stream1",
+       "/CAM_ID.password.mp2",
+       "/GetData.cgi",
+       "/MediaInput/h264",
+       "/MediaInput/mpeg4",
+       "/VideoInput/1/h264/1",
+       "/access_code",
+       "/access_name_for_stream_1_to_5",
+       "/av0_0",
+       "/av2",
+       "/avn=2",
+       "/axis-media/media.amp",
+       "/cam",
+       "/cam0_0",
+       "/cam0_1",
+       "/cam1/h264",
+       "/cam1/h264/multicast",
+       "/cam1/mjpeg",
+       "/cam1/mpeg4",
+       "/camera.stm",
+       "/ch0",
+       "/ch001.sdp",
+       "/ch0_unicast_firststream",
+       "/ch0_unicast_secondstream",
+       "/channel1",
+       "/h264",
+       "/h264/media.amp",
+       "/image.mpg",
+       "/img/media.sav",
+       "/img/video.asf",
+       "/img/video.sav",
+       "/ioImage/1",
+       "/ipcam.sdp",
+       "/ipcam_h264.sdp",
+       "/live.sdp",
+       "/live/h264",
+       "/live/mpeg4",
+       "/live_mpeg4.sdp",
+       "/livestream",
+       "/livestream/",
+       "/media/media.amp",
+       "/media/video1",
+       "/mjpeg/media.smp",
+       "/mp4",
+       "/mpeg4",
+       "/mpeg4/1/media.amp",
+       "/mpeg4/media.amp",
+       "/mpeg4/media.smp",
+       "/mpeg4unicast",
+       "/mpg4/rtsp.amp",
+       "/multicaststream",
+       "/now.mp4",
+       "/nph-h264.cgi",
+       "/nphMpeg4/g726-640x",
+       "/nphMpeg4/g726-640x480",
+       "/nphMpeg4/nil-320x240",
+       "/play1.sdp",
+       "/play2.sdp",
+       "/rtpvideo1.sdp",
+       "/rtsp_tunnel",
+       "/rtsph264",
+       "/stream1",
+       "/user.pin.mp2",
+       "/user_defined",
+       "/video",
+       "/video.3gp",
+       "/video.mp4",
+       "/video1",
+       "/video1+audio1",
+       "/vis",
+       "/wfov"
+   ]
+}
@@ -0,0 +1,16 @@
+cameradar:
+  build: .
+  dockerfile: Dockerfile
+  env_file: env_file
+  volumes:
+    - "./conf:/tmp/conf:ro"
+    - "./cameradar_thumbnails:/tmp/cameradar_thumbnails"
+  links:
+   - ext_cctv_mysql
+ext_cctv_mysql:
+  image: mysql:5.7
+  environment:
+   MYSQL_ROOT_PASSWORD: root
+   MYSQL_DATABASE: cmrdr
+  ports:
+   - "3306:3306"
@@ -0,0 +1,2 @@
+CAMERAS_SUBNETWORKS=172.16.100.0/24,192.168.178.47
+CAMERAS_PORTS=554,8554
@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+
+ESC_SEQ="\x1b["
+COL_RESET=$ESC_SEQ"39;49;00m"
+COL_RED=$ESC_SEQ"31;01m"
+COL_GREEN=$ESC_SEQ"32;01m"
+COL_YELLOW=$ESC_SEQ"33;01m"
+COL_BLUE=$ESC_SEQ"34;01m"
+COL_MAGENTA=$ESC_SEQ"35;01m"
+COL_CYAN=$ESC_SEQ"36;01m"
+
+# declare usefuls vars
+CONF=/conf/cameradar.conf.json
+
+# copy configuration
+cp /tmp/conf/* /conf/
+
+echo -n "replacing cameras subnetworks in configuration "
+sed -i s#__CAMERAS_SUBNETWORKS__#$CAMERAS_SUBNETWORKS#g $CONF
+echo -e $COL_GREEN"ok"$COL_RESET
+
+echo -n "replacing cameras ports in configuration "
+sed -i s#__PORTS_TO_CHECK__#$CAMERAS_PORTS#g $CONF
+echo -e $COL_GREEN"ok"$COL_RESET
+
+# Replace ext_cctv_mysql with the IP address of your DB or the name of its Docker
+# container. The container has to be linked in docker-compose.yml for cameradar
+# to be able to interact with it.
+echo -n "replacing mysql host and port in configuration "
+sed -i s#__MYSQL_ADDR__#ext_cctv_mysql#g $CONF
+
+# Reaplce 3306 with the port of your DB
+sed -i s#__MYSQL_PORT__#3306#g $CONF
+echo -e $COL_GREEN"ok"$COL_RESET
+
+/cameradar/bin/cameradar -l 1 -c /conf/cameradar.conf.json &
+cameradar_pid=$!
+
+trap 'kill -2 $cameradar_pid; wait $cameradar_pid; exit $?' SIGTERM SIGINT
+wait $cameradar_pid
@@ -0,0 +1,23 @@
+## Copyright 2016 Etix Labs
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##     http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+
+cmake_minimum_required (VERSION 2.8.1)
+
+# Lib subdirectory
+
+include (jsoncpp)
+include (mysql_connector)
+
+set_directory_properties(PROPERTIES CLEAN_NO_CUSTOM ON)
+set (CAMERADAR_INSTALL_DEPENDENCIES ${CAMERADAR_INSTALL_DEPENDENCIES} PARENT_SCOPE)
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,55 @@
+The JsonCpp library's source code, including accompanying documentation,
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all
+jurisdictions which recognize such a disclaimer. In such jurisdictions,
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this
+software may choose to accept it either as 1) Public Domain, 2) under the
+conditions of the MIT License (see below), or 3) under the terms of dual
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
@@ -0,0 +1,26 @@
+// Copyright 2016 Etix Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef __CAMERADAR_H__201605202152__
+#define __CAMERADAR_H__201605202152__
+
+// the configured options and settings for Tutorial
+#define CAMERADAR_VERSION "@cameradar_VERSION@"
+#define CAMERADAR_VERSION_MAJOR @cameradar_VERSION_MAJOR@
+#define CAMERADAR_VERSION_MINOR @cameradar_VERSION_MINOR@
+#define CAMERADAR_VERSION_PATCH @cameradar_VERSION_PATCH@
+#define CAMERADAR_VERSION_GIT_SHA1 "@CAMERADAR_VERSION_SHA1@"
+#define CAMERADAR_VERSION_BUILD "@CAMERADAR_VERSION_BUILD@"
+
+#endif // __CAMERADAR_H__201605202152__
Author	SHA1	Message	Date
Brendan LE GLAUNEC	a4ad49c1a7	Quick MySQL docker deployment & code cleaning	2016-05-24 08:56:11 +02:00
Brendan LE GLAUNEC	0ac1046138	MySQL Cache Manager & code cleanup	2016-05-23 21:22:12 +02:00
Brendan LE GLAUNEC	eef9c6f562	Deployment / CPack / Docker / Boost / Versionning	2016-05-23 21:20:56 +02:00
Brendan LE GLAUNEC	cf18d869e0	JsonCPP should now be downloaded and included properly	2016-05-23 21:19:40 +02:00
Brendan LE GLAUNEC	4017429835	Initial commit	2016-05-23 21:14:59 +02:00
Brendan LE GLAUNEC	615f14d614	Update README.md	2016-05-23 17:14:41 +02:00
Brendan LE GLAUNEC	d09b7abea9	Cloning method updated to HTTPS / TODO updated	2016-05-21 00:58:22 +02:00
Brendan LE GLAUNEC	fdb146f019	Merge pull request #7 from EtixLabs/feature/docker-deployment Deployment / CPack / Docker / Boost / Versionning	2016-05-21 00:43:11 +02:00
Brendan LE GLAUNEC	77446189dd	Deployment / CPack / Docker / Boost / Versionning	2016-05-21 00:39:14 +02:00
Brendan LE GLAUNEC	e4ba477b06	Merge pull request #6 from EtixLabs/feature/docker-deployment Updated README to add future improvement	2016-05-20 21:37:58 +02:00
Brendan LE GLAUNEC	6ae2608f8e	Updated README to add future improvement	2016-05-20 21:36:48 +02:00
Brendan LE GLAUNEC	6908c7bcac	Merge pull request #5 from EtixLabs/develop JsonCPP should now be downloaded and included properly	2016-05-20 21:33:33 +02:00
Brendan LE GLAUNEC	adbbe244b0	JsonCPP should now be downloaded and included properly	2016-05-20 21:30:36 +02:00
Brendan LE GLAUNEC	8d6de630a5	Merge pull request #4 from EtixLabs/develop Dependencies added & README updated	2016-05-20 17:03:43 +02:00
Brendan LE GLAUNEC	9aa86a5c2d	Dependencies added & README updated	2016-05-20 17:02:33 +02:00
Brendan LE GLAUNEC	201d7e31c6	Initial commit	2016-05-20 16:13:22 +02:00