Initial commit

runLogging

+#!/bin/bash
+clear
+echo "Starting logsystem"
+cp glances.conf ~/.config/glances/glances.conf
+touch ~/Desktop/warnings.txt
+sleep 3
+sudo glances --export influxdb -q &
\ No newline at end of file

setupJenkins

+#!/bin/bash
+sudo apt update
+sudo apt install openjdk-8-jdk wget gnupg docker docker-compose
+
+wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
+sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
+
+sudo apt update
+sudo apt install jenkins
+sudo gpasswd -a jenkins docker
+sudo systemctl daemon-reload
+sudo systemctl restart docker
+sudo service jenkins start
+
+clear
+echo "Henter ut ditt Adminpassord..."
+sleep 5
+sudo cat /var/lib/jenkins/secrets/initialAdminPassword
+
+sudo service jenkins restart

setupLogging

+#!/bin/bash
+clear
+echo "Setting up logsystem"
+sudo pip install influxdb
+mkdir ~/.config/glances
+sudo docker-compose -f docker-compose-logging.yaml up -d

sql/myChat.sql

+-- Adminer 4.7.1 MySQL dump
+
+SET NAMES utf8;
+SET time_zone = '+00:00';
+SET foreign_key_checks = 0;
+SET sql_mode = 'NO_AUTO_VALUE_ON_ZERO';
+
+SET NAMES utf8mb4;
+
+DROP DATABASE IF EXISTS myChat;
+CREATE DATABASE myChat /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
+USE myChat;
+
+DROP TABLE IF EXISTS message;
+DROP TABLE IF EXISTS user_groupChat;
+DROP TABLE IF EXISTS groupChat;
+DROP TABLE IF EXISTS user;
+
+CREATE TABLE `user` (
+  userId INT(11) NOT NULL AUTO_INCREMENT,
+  username VARCHAR(64) NOT NULL UNIQUE,
+  password TEXT,
+  salt BLOB,
+  PRIMARY KEY (userId)
+)ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+CREATE TABLE groupChat(
+  groupChatId INT(11) NOT NULL AUTO_INCREMENT,
+  groupChatName VARCHAR(64) NOT NULL,
+  PRIMARY KEY (groupChatId)
+) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+CREATE TABLE user_groupChat (
+  userId INT(11) NOT NULL,
+  groupChatId INT(11) NOT NULL,
+  PRIMARY KEY (userId, groupChatId),
+  CONSTRAINT user_groupChat_ibfk_3 FOREIGN KEY (userId) REFERENCES user (userId) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT user_groupChat_ibfk_4 FOREIGN KEY (groupChatId) REFERENCES groupChat (groupChatId) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+
+CREATE TABLE message (
+  messageId INT(11) NOT NULL AUTO_INCREMENT,
+  userId1 INT(11) NOT NULL,
+  userId2 INT(11),
+  timestamp TIMESTAMP NOT NULL,
+  messageContent VARCHAR (500) NOT NULL,
+  groupChatId INT(11),
+  PRIMARY KEY (messageId),
+  KEY userId1 (userId1),
+  KEY userId2 (userId2),
+  CONSTRAINT message_ibfk_3 FOREIGN KEY (userId1) REFERENCES user (userId) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT message_ibfk_4 FOREIGN KEY (userId2) REFERENCES user (userId) ON DELETE CASCADE ON UPDATE CASCADE,
+  CONSTRAINT message_ibfk_5 foreign key (groupChatId) REFERENCES groupChat (groupChatId) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+
+
+
+
+INSERT INTO user (username) VALUES ('Ola');
+INSERT INTO user (username) VALUES ('Kari');
+
+INSERT INTO message (userId1, userId2, timestamp, messageContent) VALUES (1, 2, NOW(), 'Hei');
+-- 2019-06-17 13:40:12

src/main/java/dao/Database.java

+package dao;
+
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Class used to create Database connection
+ */
+public class Database {
+    private static Database database;
+    private static ComboPooledDataSource comboPooledDataSource;
+
+    private static String DB_CHOICE = System.getenv("DB_CHOICE");
+    private static boolean isTest = isJUnitTest();
+
+
+    private static final String IP_TO_VM = "129.241.96.191";
+
+    private static String DB_URL = "jdbc:mysql://" + ((DB_CHOICE != null) ?
+            (DB_CHOICE + ":3306/") :
+            (IP_TO_VM + ((isTest) ? ":3308/" : ":3307/")));
+
+    private static String DB_NAME = "myChat";
+    private static String DB_USERNAME = "root";
+    private static String DB_PW = "example";
+
+    private static final String DB_USE_SSL = "?useSSL=false";
+
+    /**
+     * Sets up ComboPooledDataSource to handle multiple simultaneous queries to DB
+     */
+    private Database() {
+        try {
+            comboPooledDataSource = new ComboPooledDataSource();
+            comboPooledDataSource.setJdbcUrl(DB_URL+DB_NAME+ DB_USE_SSL);
+            comboPooledDataSource.setUser(DB_USERNAME);
+            comboPooledDataSource.setPassword(DB_PW);
+
+            comboPooledDataSource.setInitialPoolSize(5);
+            comboPooledDataSource.setMinPoolSize(5);
+            comboPooledDataSource.setMaxPoolSize(200);
+            comboPooledDataSource.setAcquireIncrement(5);
+            comboPooledDataSource.setIdleConnectionTestPeriod(60);
+            comboPooledDataSource.setMaxStatements(0);
+            comboPooledDataSource.setMaxIdleTime(60);
+        } catch (Exception e) {
+            System.out.println("Database connection failed");
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Checks if there is an existing instance of Database. If not, it creates one.
+     * @return An instance of Database, either the existing one, or a newly created one.
+     */
+    public static Database instance() {
+        if (database == null) {
+            database = new Database();
+            return database;
+        } else {
+            return database;
+        }
+    }
+
+    /**
+     * Method to get a connection from the Database object.
+     * @return A connection to the Database object.
+     * @throws SQLException if failing to get connection
+     */
+    public Connection getConnection() throws SQLException {
+        return comboPooledDataSource.getConnection();
+    }
+
+    /**
+     * Check if connection is from tests or production build
+     * @return true if connection from tests
+     */
+    private static boolean isJUnitTest() {
+        StackTraceElement[] stackTraces = Thread.currentThread().getStackTrace();
+        for (StackTraceElement element : stackTraces) {
+            if (element.getClassName().startsWith("org.junit.")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Closes connections to database, makes sure that resultSets, and statements gets closed properly
+     * @param connection the connection to be closed
+     * @param preparedStatement the preparedStatement to be closed
+     * @param resultSet the resultSet to be closed
+     */
+    static void close(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet) {
+        if (resultSet != null) {
+            try {
+                resultSet.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+        if (preparedStatement != null) {
+            try {
+                preparedStatement.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+        if (connection != null) {
+            try {
+                connection.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+}
\ No newline at end of file

src/main/java/dao/GroupChatDAO.java

+package dao;
+
+import data.User;
+
+import java.util.ArrayList;
+
+public class GroupChatDAO {
+
+    //Made so that the rest of the application runs without group chats implemented.
+    public ArrayList<User> getGroupChatUsers(int groupChatId){
+        return null;
+    }
+}

src/main/java/dao/MessageDAO.java

+package dao;
+
+import data.Message;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.List;
+import java.util.TimeZone;
+
+import static dao.Database.close;
+
+
+/**
+ * Data access object for Message
+ */
+public class MessageDAO {
+
+    /**
+     * Method used to get all messages for a chat
+     * @param userId1 ID of the user the messages are sent from
+     * @param userId2 ID of the user the messages are sent to
+     * @return List of messages
+     */
+    public List<Message> getMessages(int userId1, int userId2) {
+        Connection connection = null;
+        PreparedStatement preparedStatement = null;
+        ResultSet resultSet = null;
+        List<Message> messages = new ArrayList<>();
+
+        try{
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement(
+                    "SELECT * FROM message WHERE (userId1 = ? AND userId2 = ?) OR (userId2 = ? AND userId1 = ?) ORDER BY `timestamp` ASC ");
+            preparedStatement.setInt(1, userId1);
+            preparedStatement.setInt(2, userId2);
+            preparedStatement.setInt(3, userId1);
+            preparedStatement.setInt(4, userId2);
+            resultSet = preparedStatement.executeQuery();
+
+            while(resultSet.next()){
+                Message message = new Message();
+                message.setMessageId(resultSet.getInt("messageId"));
+                message.setUserId1(resultSet.getInt("userId1"));
+                message.setUserId2(resultSet.getInt("userId2"));
+                Calendar cal = Calendar.getInstance();
+                cal.setTimeZone(TimeZone.getTimeZone("UTC"));
+                message.setTimestamp(resultSet.getTimestamp("timestamp",cal));
+                message.setMessageContent(resultSet.getString("messageContent"));
+                messages.add(message);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        } finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return messages;
+    }
+
+    /**
+     * Adds a new message to the database
+     * @param message the message to add in database
+     * @return true on success, false if not
+     */
+    public Message addMessage(Message message) {
+        Connection connection = null;
+        PreparedStatement preparedStatement = null;
+        ResultSet resultSet = null;
+
+        try {
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement(
+                    "INSERT INTO message (userId1, userId2, timestamp, messageContent) VALUES (?, ?, NOW(), ?)", Statement.RETURN_GENERATED_KEYS);
+
+            preparedStatement.setInt(1, message.getUserId1());
+            preparedStatement.setInt(2, message.getUserId2());
+            preparedStatement.setString(3, message.getMessageContent());
+
+            int result = preparedStatement.executeUpdate();
+
+            if (result == 1) {
+                resultSet = preparedStatement.getGeneratedKeys();
+                if (resultSet.next()) message.setMessageId(resultSet.getInt(1));
+            }
+        }catch (SQLIntegrityConstraintViolationException e){
+            message = new Message();
+            return message;
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return message;
+    }
+}

src/main/java/dao/UserDAO.java

+package dao;
+
+import data.User;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+import static dao.Database.close;
+
+
+/**
+ * Data access object for User
+ */
+public class UserDAO {
+
+    /**
+     * Returns a List of all registered users
+     * @return List of Users
+     */
+    public List<User> getUsers() {
+        List<User> users = new ArrayList<>();
+        PreparedStatement preparedStatement = null;
+        Connection connection = null;
+        ResultSet resultSet = null;
+        try {
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("SELECT * FROM user");
+            resultSet = preparedStatement.executeQuery();
+
+            User user;
+            while (resultSet.next()) {
+                user = new User();
+                user.setUserId(resultSet.getInt("userId"));
+                user.setUsername(resultSet.getString("username"));
+                users.add(user);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        } finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return users;
+    }
+
+    /**
+     * Returns a User object for given username
+     * @param username Username as String
+     * @return requested user object if found, null if not found
+     */
+    public User getUserByUsername(String username) {
+        Connection connection = null;
+        PreparedStatement preparedStatement = null;
+        ResultSet resultSet = null;
+        User user = null;
+        try {
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("SELECT * FROM user WHERE username=?");
+            preparedStatement.setString(1, username);
+            resultSet = preparedStatement.executeQuery();
+            user = getUserFromResultSet(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return user;
+    }
+
+    /**
+     * Returns a User object for given userId
+     * @param userId userId as int
+     * @return requested user object if found, null if not found
+     */
+    private User getUserById(int userId) {
+        Connection connection = null;
+        PreparedStatement preparedStatement = null;
+        ResultSet resultSet = null;
+        User user = null;
+        try {
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("SELECT * FROM user WHERE userId=?");
+            preparedStatement.setInt(1, userId);
+            resultSet = preparedStatement.executeQuery();
+            user = getUserFromResultSet(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }finally {
+            close(connection, preparedStatement, resultSet);
+        }
+        return user;
+    }
+
+    /**
+     * Helping method to get a User from a ResultSet
+     * @param resultSet ResultSet with the user
+     * @return User object, or null if unsuccessful
+     */
+    private User getUserFromResultSet(ResultSet resultSet){
+        User user = null;
+        try{
+            if(resultSet.next()){
+                user = new User();
+                user.setUserId(resultSet.getInt("userId"));
+                user.setUsername(resultSet.getString("username"));
+                user.setPassword(resultSet.getString("password"));
+                user.setSalt(resultSet.getBytes("salt"));
+            }
+        }catch (SQLException e){
+            e.printStackTrace();
+        } finally {
+            close(null, null, resultSet);
+        }
+        return user;
+    }
+
+    /**
+     * Adds a new user to database with default ID
+     * @param user User object
+     * @return new User or already registered user
+     */
+    public User addUser(User user) {
+        Connection connection = null;
+        PreparedStatement preparedStatement = null;
+        ResultSet resultSet = null;
+        User userFromDb = getUserByUsername(user.getUsername());
+        if(userFromDb == null){
+            try{
+                connection = Database.instance().getConnection();
+                User newUser = new User();
+                byte[] salt = generateSalt();
+                String hashedPassword = hashPassword(user.getPassword(), salt);
+
+                preparedStatement = connection.prepareStatement("INSERT INTO user (username, password, salt) VALUES (?, ?, ?)", Statement.RETURN_GENERATED_KEYS);
+                preparedStatement.setString(1, user.getUsername());
+                preparedStatement.setString(2, hashedPassword);
+                preparedStatement.setBytes(3, salt);
+                int result = preparedStatement.executeUpdate();
+
+                newUser.setUsername(user.getUsername());
+
+                if (result == 1) {
+                    resultSet = preparedStatement.getGeneratedKeys();
+                    if (resultSet.next()) newUser.setUserId(resultSet.getInt(1));
+                    return newUser;
+                }
+
+            }catch(SQLException e){
+                e.printStackTrace();
+
+            }finally{
+                close(connection, preparedStatement, resultSet);
+            }
+        }else {
+            //Validate password
+            byte[] salt = userFromDb.getSalt();
+            String hashedPassword = userFromDb.getPassword();
+
+
+            if (salt == null || hashedPassword == null) {
+                User response = new User();
+                response.setUsername(userFromDb.getUsername());
+                response.setUserId(userFromDb.getUserId());
+                return response;
+            }
+
+            String hash = hashPassword(user.getPassword(), salt);
+            if(hashedPassword.equals(hash)) {
+                User response = new User();
+                response.setUsername(userFromDb.getUsername());
+                response.setUserId(userFromDb.getUserId());
+                return response;
+            }
+        }
+        return new User();
+    }
+
+    /**
+     * Generates a salt, for hashing
+     * @return a random salt
+     */
+    public byte[] generateSalt() {
+        return null;
+    }
+
+    /**
+     * Method to hash a password with salt
+     * @param password password to be hashed
+     * @param salt salt to use when hashing
+     * @return hashedPassword, null if unsuccessful
+     */
+    public String hashPassword(String password, byte[] salt){
+        return null;
+    }
+
+    /**
+     * Edits the users username or password
+     * @param userId userId as int
+     * @param username Username as String
+     * @param password password as String, if null it should not be updated
+     * @return true if success on new username, false if not
+     */
+    public boolean editUser (int userId, String username, String password) {
+        Connection connection = null;
+        PreparedStatement preparedStatement = null;
+        boolean updatePassword = false;
+        boolean updatePasswordWithSalt = false;
+        String sql;
+        String hashedPassword = "";
+        User user = null;
+        if(password == null){
+            sql = "UPDATE user SET username = ? WHERE userId = ?";
+        }else {
+            user = getUserById(userId);
+            if(user.getPassword() == null){
+                user.setSalt(generateSalt());
+                hashedPassword = hashPassword(password, user.getSalt());
+                sql = "UPDATE user SET username = ?, password = ?, salt = ? WHERE userId = ?";
+                updatePasswordWithSalt = true;
+            }else{
+                hashedPassword = hashPassword(password, user.getSalt());
+                sql = "UPDATE user SET username = ?, password = ? WHERE userId = ?";
+                updatePassword = true;
+            }
+        }
+
+        try {
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setString(1,username);
+            if(updatePassword){
+                preparedStatement.setString(2, hashedPassword);
+                preparedStatement.setInt(3,userId);
+            }else if(updatePasswordWithSalt) {
+                preparedStatement.setString(2, hashedPassword);
+                preparedStatement.setBytes(3, user.getSalt());
+                preparedStatement.setInt(4, userId);
+            }else{
+                preparedStatement.setInt(2,userId);
+            }
+            preparedStatement.executeUpdate();
+            return true;
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+
+        } finally {
+            close(connection, preparedStatement, null);
+        }
+        return false;
+    }
+}

src/main/java/data/GroupChat.java

+package data;
+
+/**
+ * Class for the GroupChat object as saved in database
+ */
+public class GroupChat {}

src/main/java/data/Message.java

+package data;
+
+import java.sql.Timestamp;
+
+/**
+ * Class for the Message object as saved in database.
+ */
+public class Message {
+    private int messageId;
+    private int userId1;
+    private int userId2;
+    private Timestamp timestamp;
+    private String messageContent;
+    private int groupChatId;
+
+
+    public Message(){}
+
+    public Message(int userId1, int userId2, int messageId, String messageContent, Timestamp timestamp) {
+        this.messageId = messageId;
+        this.userId1 = userId1;
+        this.userId2 = userId2;
+        this.timestamp = timestamp;
+        this.messageContent = messageContent;
+    }
+
+    public int getMessageId() {
+        return messageId;
+    }
+
+    public void setMessageId(int messageId) {
+        this.messageId = messageId;
+    }
+
+    public int getUserId1() {
+        return userId1;
+    }
+
+    public void setUserId1(int userId1) {
+        this.userId1 = userId1;
+    }
+
+    public int getUserId2() {
+        return userId2;
+    }
+
+    public void setUserId2(int userId2) {
+        this.userId2 = userId2;
+    }
+
+    public Timestamp getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(Timestamp timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public String getMessageContent() {
+        return messageContent;
+    }
+
+    public void setMessageContent(String messageContent) {
+        this.messageContent = messageContent;
+    }
+
+    public void setGroupChatId(int groupChatId){
+        this.groupChatId = groupChatId;
+    }
+
+    public int getGroupChatId(){
+        return groupChatId;
+    }
+}