version 1.1.6

* API version 1.1.4
* added /health, returns 200 (OK, for status checks)
* moved status code to a separate class
* added status.mosad.xyz reporting

.drone.yml

@@ -3,6 +3,12 @@ name: default
 
 steps:
 - name: test
-  image: gradle:jdk8
+  image: gradle:jdk11
   commands:
-  - gradle test
+  - gradle test
+
+- name: test-jdk8
+  image: gradle:jdk8
+  commands:
+  - gradle test
+

build.gradle

@@ -1,7 +1,7 @@
 
 buildscript {
     ext.kotlin_version = '1.3.50'
-    ext.spring_boot_version = '2.1.8.RELEASE'
+    ext.spring_boot_version = '2.1.9.RELEASE'
 
     repositories {
         jcenter()
@@ -48,4 +48,4 @@ compileTestKotlin {
 }
 
 group 'org.mosad'
-version '1.1.4'
+version '1.1.6'

src/main/kotlin/org/mosad/thecitadelofricks/APIController.kt

@@ -22,34 +22,41 @@
 
 package org.mosad.thecitadelofricks
 
-import org.mosad.thecitadelofricks.CacheController.Companion.courseList
-import org.mosad.thecitadelofricks.CacheController.Companion.mensaMenu
-import org.mosad.thecitadelofricks.CacheController.Companion.timetableList
+import org.mosad.thecitadelofricks.controller.CacheController
+import org.mosad.thecitadelofricks.controller.CacheController.Companion.courseList
+import org.mosad.thecitadelofricks.controller.CacheController.Companion.getLesson
+import org.mosad.thecitadelofricks.controller.CacheController.Companion.getLessonSubjectList
+import org.mosad.thecitadelofricks.controller.CacheController.Companion.getTimetable
+import org.mosad.thecitadelofricks.controller.CacheController.Companion.mensaMenu
+import org.mosad.thecitadelofricks.controller.StatusController.Companion.getStatus
+import org.mosad.thecitadelofricks.controller.StatusController.Companion.updateMensaMenuRequests
+import org.mosad.thecitadelofricks.controller.StatusController.Companion.updateTimetableRequests
+import org.mosad.thecitadelofricks.controller.StatusController.Companion.updateTotalRequests
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
-import java.net.HttpURLConnection
-import java.net.URL
 import java.time.LocalDateTime
 import java.util.*
-import java.util.stream.Collectors
 import kotlin.collections.ArrayList
-import kotlin.collections.HashSet
 
 @RestController
 class APIController {
 
     private val logger: Logger = LoggerFactory.getLogger(APIController::class.java)
-    private val cache = CacheController()
 
-    private val apiVersion = "1.1.2"
-    private val softwareVersion = "1.1.4"
-    private val startTime = System.currentTimeMillis() / 1000
+    companion object {
+        const val apiVersion = "1.1.4"
+        const val softwareVersion = "1.1.6"
+        val startTime = System.currentTimeMillis() / 1000
+    }
 
-    private var requestCount = 0
+    init {
+        CacheController() // initialize the CacheController
+    }
 
+    // TODO remove this with API version 1.2.0
     @Deprecated("courses is replaced by courseList", replaceWith = ReplaceWith("courseList()"))
     @RequestMapping("/courses")
     fun courses(): CourseList {
@@ -59,15 +66,16 @@ class APIController {
     @RequestMapping("/courseList")
     fun courseList(): CourseList {
         logger.info("courseList request at ${LocalDateTime.now()}!")
-        requestCount++
-        return  courseList
+        updateTotalRequests()
+        return courseList
     }
 
     @RequestMapping("/mensamenu")
     fun mensamenu(): MensaMenu {
         logger.info("mensamenu request at ${LocalDateTime.now()}!")
-        requestCount++
-        return  mensaMenu
+        updateTotalRequests()
+        updateMensaMenuRequests()
+        return mensaMenu
     }
 
     @RequestMapping("/timetable")
@@ -76,8 +84,9 @@ class APIController {
         @RequestParam(value = "week", defaultValue = "0") week: Int
     ): TimetableCourseWeek {
         logger.info("timetable request at ${LocalDateTime.now()}!")
-        requestCount++
-        return cache.getTimetable(courseName, week)
+        updateTotalRequests()
+        updateTimetableRequests(courseName)
+        return getTimetable(courseName, week)
     }
 
     @RequestMapping("/lessonSubjectList")
@@ -86,101 +95,31 @@ class APIController {
         @RequestParam(value = "week", defaultValue = "0") week: Int
     ): HashSet<String> {
         logger.info("lessonSubjectList request at ${LocalDateTime.now()}!")
-        requestCount++
+        updateTotalRequests()
         return getLessonSubjectList(courseName, week)
     }
 
-    @RequestMapping("/lesson")
+    @RequestMapping("/lessons")
     fun lesson(
         @RequestParam(value = "courseName", defaultValue = "AI4") courseName: String,
         @RequestParam(value = "lessonSubject", defaultValue = "Mathematik 4") lessonSubject: String,
         @RequestParam(value = "week", defaultValue = "0") week: Int
     ): ArrayList<Lesson> {
         logger.info("lesson request at ${LocalDateTime.now()}!")
-        requestCount++
+        updateTotalRequests()
         return getLesson(courseName, lessonSubject, week)
     }
 
     @RequestMapping("/status")
     fun status(): Status {
+        logger.info("status request at ${LocalDateTime.now()}!")
         return getStatus()
     }
 
-    // non direct api functions
-
-    private fun getLessonSubjectList(courseName: String, week: Int): HashSet<String> {
-        val lessonSubjectList = ArrayList<String>()
-
-        // get every lesson subject for the given week
-        val flatMap = cache.getTimetable(courseName, week).timetable.days.flatMap { it.timeslots.asIterable() }
-        flatMap.forEach {
-            it.stream().filter { x -> x.lessonSubject.isNotEmpty() }.findAny().ifPresent { x -> lessonSubjectList.add(x.lessonSubject) }
-        }
-
-        return HashSet(lessonSubjectList)
-    }
-
-    private fun getLesson(courseName: String, lessonSubject: String, week: Int): ArrayList<Lesson> {
-        val lessonList = ArrayList<Lesson>()
-
-        // get all lessons from the weeks timetable
-        val flatMap = cache.getTimetable(courseName, week).timetable.days.flatMap { it.timeslots.asIterable() }
-        flatMap.forEach {
-            it.forEach { lesson ->
-                if(lesson.lessonSubject.contains(lessonSubject)) {
-                    lessonList.add(lesson)
-                }
-            }
-
-            //it.stream().filter { x -> x.lessonSubject.contains(lessonSubject) }.findAny().ifPresent { x -> println("${x.lessonSubject}, ${x.lessonTeacher}") }
-        }
-
-        return lessonList
-    }
-
-    private fun getStatus(): Status {
-        val currentTime = System.currentTimeMillis() / 1000
-        val minutes = (currentTime - startTime) % 3600 / 60
-        val hours = (currentTime - startTime) % 86400 / 3600
-        val days = (currentTime - startTime) / 86400
-
-        val timetableListSize = timetableList.size
-        val timetableListNames = timetableList.stream().map { x -> x.meta.courseName }.collect(Collectors.toList())
-
-        var hsoCode = 999
-        var swfrCode = 999
-        logger.info("status request at ${LocalDateTime.now()}!")
-
-        try {
-            val hsoURL = URL("https://www.hs-offenburg.de/")
-            val swfrURL = URL("https://www.swfr.de/")
-
-            var connection = hsoURL.openConnection() as HttpURLConnection
-            connection.requestMethod = "HEAD"
-
-            connection.connectTimeout = 15000
-            hsoCode = connection.responseCode
-
-            connection = swfrURL.openConnection() as HttpURLConnection
-            connection.connectTimeout = 15000
-            swfrCode = connection.responseCode
-        } catch (e: Exception) {
-            logger.error("Error while fetching url response codes!", e)
-        }
-
-        return Status(
-            LocalDateTime.now(),
-            "$days days, $hours:$minutes",
-            apiVersion,
-            softwareVersion,
-            requestCount,
-            timetableListSize,
-            HashSet(timetableListNames).toString(),
-            Date(courseList.meta.updateTime * 1000),
-            Date(mensaMenu.meta.updateTime * 1000),
-            hsoCode,
-            swfrCode
-        )
+    @RequestMapping("/health")
+    fun health(): Int {
+        logger.info("health request at ${LocalDateTime.now()}!")
+        return 200
     }
 
 }

src/main/kotlin/org/mosad/thecitadelofricks/CacheController.kt

@@ -1,186 +0,0 @@
-/**
- * TheCitadelofRicks
- *
- * Copyright 2019  <seil0@mosad.xyz>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
- * MA 02110-1301, USA.
- *
- */
-
-package org.mosad.thecitadelofricks
-
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.async
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import org.mosad.thecitadelofricks.hsoparser.CourseListParser
-import org.mosad.thecitadelofricks.hsoparser.MensaParser
-import org.mosad.thecitadelofricks.hsoparser.TimetableParser
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
-import java.util.*
-import kotlin.collections.ArrayList
-import kotlin.concurrent.scheduleAtFixedRate
-
-class CacheController {
-
-    private val logger: Logger = LoggerFactory.getLogger(CacheController::class.java)
-
-    // hso parser links (hardcoded)
-    private val courseListURL = "https://www.hs-offenburg.de/studium/vorlesungsplaene/"
-    private val mensaMenuURL = "https://www.swfr.de/de/essen-trinken/speiseplaene/mensa-offenburg/"
-    private val mensaName = "Offenburg"
-
-    // cache objects
-    companion object{
-
-        lateinit var courseList: CourseList
-        lateinit var mensaMenu: MensaMenu
-
-        var timetableList = ArrayList<TimetableCourseWeek>() // this list contains all timetables
-    }
-
-    init {
-        initUpdates()
-        scheduledUpdates()
-    }
-
-    fun getTimetable(courseName: String, weekIndex: Int): TimetableCourseWeek = runBlocking {
-        val currentTime = System.currentTimeMillis() / 1000
-        var timetable = TimetableWeek()
-        var weekNumberYear = 0
-        // check if the timetable already exists and is up to date
-
-        when (timetableList.stream().filter { x -> x.meta.courseName == courseName && x.meta.weekIndex == weekIndex }.findAny().orElse(null)) {
-            // there is no such course yet, create one
-            null -> {
-                val courseLink = courseList.courses.stream().filter { x -> x.courseName == courseName }.findFirst().orElse(null).courseLink
-                val timetableLink = courseLink.replace("week=0","week=$weekIndex")
-
-                val jobTimetable = GlobalScope.async {
-                    timetable = TimetableParser().getTimeTable(timetableLink)
-                    weekNumberYear = TimetableParser().getWeekNumberYear(timetableLink)
-                }
-
-                jobTimetable.await()
-
-                timetableList.add(TimetableCourseWeek(TimetableCourseMeta(currentTime, courseName, weekIndex, weekNumberYear, timetableLink), timetable))
-                logger.info("added new timetable for $courseName, week $weekIndex")
-            }
-        }
-
-        return@runBlocking timetableList.stream().filter { x -> x.meta.courseName == courseName && x.meta.weekIndex == weekIndex }.findAny().orElse(null)
-    }
-
-    /**
-     * this function updates the courseList
-     * during the update process the old data will be returned for a API request
-     */
-    private fun asyncUpdateCourseList() = GlobalScope.launch {
-        val result = CourseListParser().getCourseLinks(courseListURL)
-        if (result != null) {
-            courseList = CourseList(CourseMeta(System.currentTimeMillis() / 1000, result.size), result)
-        }
-
-        logger.info("updated courses successful at ${Date(courseList.meta.updateTime * 1000)}")
-    }
-
-    /**
-     * this function updates the mensa menu list
-     * during the update process the old data will be returned for a API request
-     */
-    private fun asyncUpdateMensa() = GlobalScope.launch {
-        val mensaCurrentWeek = MensaParser().getMensaMenu(mensaMenuURL)
-        val mensaNextWeek = MensaParser().getMensaMenu(MensaParser().getMenuLinkNextWeek(mensaMenuURL))
-
-        // only update if we get valid data
-        if (mensaCurrentWeek != null && mensaNextWeek != null) {
-            mensaMenu = MensaMenu(MensaMeta(System.currentTimeMillis() / 1000, mensaName), mensaCurrentWeek, mensaNextWeek)
-        }
-
-        logger.info("updated mensamenu successful at ${Date(mensaMenu.meta.updateTime * 1000)}")
-    }
-
-    /**
-     * this function updates all existing timetables
-     * during the update process the old data will be returned for a API request
-     */
-    private fun asyncUpdateTimetables() = GlobalScope.launch {
-        timetableList.forEach { timetableCourse ->
-            val updateURL = timetableCourse.meta.link
-            timetableCourse.timetable = TimetableParser().getTimeTable(updateURL)
-            timetableCourse.meta.updateTime = System.currentTimeMillis() / 1000
-        }
-        logger.info("updated ${timetableList.size} timetables successful!")
-    }
-
-    /**
-     * before the APIController is up, get the data fist
-     * runBlocking: otherwise the api would return no data to requests for a few seconds after startup
-     */
-    private fun initUpdates() = runBlocking {
-        // get all courses on startup
-        val jobCourseUpdate = GlobalScope.async {
-            val result = CourseListParser().getCourseLinks(courseListURL)
-            if (result != null) {
-                courseList = CourseList(CourseMeta(System.currentTimeMillis() / 1000, result.size), result)
-            }
-        }
-
-        // get the current and next weeks mensa menus
-        val jobMensa = GlobalScope.async{
-            val mensaCurrentWeek = MensaParser().getMensaMenu(mensaMenuURL)
-            val mensaNextWeek = MensaParser().getMensaMenu(MensaParser().getMenuLinkNextWeek(mensaMenuURL))
-
-            // only update if we get valid data
-            if (mensaCurrentWeek != null && mensaNextWeek != null) {
-                mensaMenu = MensaMenu(MensaMeta(System.currentTimeMillis() / 1000, mensaName), mensaCurrentWeek, mensaNextWeek)
-            }
-        }
-
-        jobCourseUpdate.await()
-        jobMensa.await()
-
-        logger.info("init updates successful")
-    }
-
-    /**
-     * doesn't account the change between winter and summer time!
-     *
-     */
-    private fun scheduledUpdates() {
-        val currentTime = System.currentTimeMillis()
-        val initDelay24h = (86400000 - ((currentTime + 3600000) % 86400000)) + 60000
-        val initDelay3h = (10800000 - ((currentTime + 3600000) % 10800000)) + 60000
-        val initDelay1h = (3600000 - ((currentTime + 3600000) % 3600000)) + 60000
-
-        // update courseList every 24 hours (time in ms)
-        Timer().scheduleAtFixedRate(initDelay24h, 86400000) {
-            asyncUpdateCourseList()
-        }
-
-        // update all already existing timetables every 3 hours (time in ms)
-        Timer().scheduleAtFixedRate(initDelay3h, 10800000) {
-            asyncUpdateTimetables()
-        }
-
-        // update courses every hour (time in ms)
-        Timer().scheduleAtFixedRate(initDelay1h, 3600000) {
-            asyncUpdateMensa()
-        }
-    }
-
-}

src/main/kotlin/org/mosad/thecitadelofricks/DataTypes.kt

@@ -62,14 +62,17 @@ data class TimetableCourseWeek(val meta: TimetableCourseMeta, var timetable: Tim
 
 
 // data classes for the status part
+data class TimetableCounter(var courseName: String, var requests: Int)
+
 data class Status(
     val time: LocalDateTime,
     val uptime: String,
     val apiVersion: String,
     val softwareVersion: String,
     val requestCount: Int,
+    val mensaMenuRequests: Int,
+    val timetableRequests: ArrayList<TimetableCounter>,
     val timetableListSize: Int,
-    val timetableListNames: String,
     val coursesLastUpdate: Date,
     val mensaLastUpdate: Date,
     val hsoResponseCode: Int,

src/main/kotlin/org/mosad/thecitadelofricks/controller/CacheController.kt

@@ -0,0 +1,275 @@
+/**
+ * TheCitadelofRicks
+ *
+ * Copyright 2019  <seil0@mosad.xyz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ *
+ */
+
+package org.mosad.thecitadelofricks.controller
+
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.mosad.thecitadelofricks.*
+import org.mosad.thecitadelofricks.hsoparser.CourseListParser
+import org.mosad.thecitadelofricks.hsoparser.MensaParser
+import org.mosad.thecitadelofricks.hsoparser.TimetableParser
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import java.util.*
+import kotlin.collections.ArrayList
+import kotlin.concurrent.scheduleAtFixedRate
+
+class CacheController {
+
+    private val logger: Logger = LoggerFactory.getLogger(CacheController::class.java)
+
+    // hso parser links (hardcoded)
+    private val courseListURL = "https://www.hs-offenburg.de/studium/vorlesungsplaene/"
+    private val mensaMenuURL = "https://www.swfr.de/de/essen-trinken/speiseplaene/mensa-offenburg/"
+    private val mensaName = "Offenburg"
+
+    init {
+        initUpdates()
+        scheduledUpdates()
+    }
+
+    // cache objects
+    companion object{
+        private val logger: Logger = LoggerFactory.getLogger(CacheController::class.java)
+
+        lateinit var courseList: CourseList
+        lateinit var mensaMenu: MensaMenu
+        var timetableList = ArrayList<TimetableCourseWeek>() // this list contains all timetables
+
+        /**
+         * get a timetable, since they may not cached, we need to make sure it's cached, otherwise download
+         * @param courseName the name of the course to be requested
+         * @param weekIndex request week number (current week = 0)
+         * @return the timetable of a course (courseName)
+         */
+        fun getTimetable(courseName: String, weekIndex: Int): TimetableCourseWeek = runBlocking {
+            val currentTime = System.currentTimeMillis() / 1000
+            var timetable = TimetableWeek()
+            var weekNumberYear = 0
+
+            // check if the timetable already exists and is up to date
+            when (timetableList.stream().filter { x -> x.meta.courseName == courseName && x.meta.weekIndex == weekIndex }.findAny().orElse(null)) {
+                // there is no such course yet, create one
+                null -> {
+                    val courseLink = courseList.courses.stream().filter { x -> x.courseName == courseName }.findFirst().orElse(null).courseLink
+                    val timetableLink = courseLink.replace("week=0","week=$weekIndex")
+
+                    val jobTimetable = GlobalScope.async {
+                        timetable = TimetableParser().getTimeTable(timetableLink)
+                        weekNumberYear = TimetableParser().getWeekNumberYear(timetableLink)
+                    }
+
+                    jobTimetable.await()
+
+                    timetableList.add(
+                        TimetableCourseWeek(
+                            TimetableCourseMeta(
+                                currentTime,
+                                courseName,
+                                weekIndex,
+                                weekNumberYear,
+                                timetableLink
+                            ),
+                            timetable
+                        )
+                    )
+                    logger.info("added new timetable for $courseName, week $weekIndex")
+                }
+            }
+
+            return@runBlocking timetableList.stream().filter { x -> x.meta.courseName == courseName && x.meta.weekIndex == weekIndex }.findAny().orElse(null)
+        }
+
+        /**
+         * get every explicit lesson in a week
+         * @param courseName the name of the course to be requested
+         * @param weekIndex request week number (current week = 0)
+         * @return a HashSet of explicit lessons for one week
+         */
+        fun getLessonSubjectList(courseName: String, weekIndex: Int): HashSet<String> = runBlocking {
+            val lessonSubjectList = ArrayList<String>()
+
+            // get every lesson subject for the given week
+            val flatMap = getTimetable(courseName, weekIndex).timetable.days.flatMap { it.timeslots.asIterable() }
+            flatMap.forEach {
+                it.stream().filter { x -> x.lessonSubject.isNotEmpty() }.findAny().ifPresent { x -> lessonSubjectList.add(x.lessonSubject) }
+            }
+
+            return@runBlocking HashSet(lessonSubjectList)
+        }
+
+        /**
+         * get every explicit lesson in a week
+         * @param courseName the name of the course to be requested
+         * @param lessonSubject the lesson subject to be requested
+         * @param weekIndex request week number (current week = 0)
+         * @return a ArrayList of every lesson with lessonSubject for one week
+         */
+        fun getLesson(courseName: String, lessonSubject: String, weekIndex: Int): ArrayList<Lesson> {
+            val lessonList = ArrayList<Lesson>()
+
+            // get all lessons from the weeks timetable
+            val flatMap = getTimetable(courseName, weekIndex).timetable.days.flatMap { it.timeslots.asIterable() }
+            flatMap.forEach {
+                it.forEach { lesson ->
+                    if(lesson.lessonSubject.contains(lessonSubject)) {
+                        lessonList.add(lesson)
+                    }
+                }
+
+                // TODO Java 11
+                //it.stream().filter { x -> x.lessonSubject.contains(lessonSubject) }.findAny().ifPresent { x -> println("${x.lessonSubject}, ${x.lessonTeacher}") }
+            }
+
+            return lessonList
+        }
+    }
+
+    /**
+     * this function updates the courseList
+     * during the update process the old data will be returned for a API request
+     */
+    private fun asyncUpdateCourseList() = GlobalScope.launch {
+        CourseListParser().getCourseLinks(courseListURL)?.let {
+            courseList =
+                CourseList(
+                    CourseMeta(
+                        System.currentTimeMillis() / 1000,
+                        it.size
+                    ), it
+                )
+        }
+
+        logger.info("updated courses successful at ${Date(courseList.meta.updateTime * 1000)}")
+    }
+
+    /**
+     * this function updates the mensa menu list
+     * during the update process the old data will be returned for a API request
+     */
+    private fun asyncUpdateMensa() = GlobalScope.launch {
+        val mensaCurrentWeek = MensaParser().getMensaMenu(mensaMenuURL)
+        val mensaNextWeek = MensaParser().getMensaMenu(MensaParser().getMenuLinkNextWeek(mensaMenuURL))
+
+        // only update if we get valid data
+        if (mensaCurrentWeek != null && mensaNextWeek != null) {
+            mensaMenu =
+                MensaMenu(
+                    MensaMeta(
+                        System.currentTimeMillis() / 1000,
+                        mensaName
+                    ), mensaCurrentWeek, mensaNextWeek
+                )
+        }
+
+        logger.info("updated mensamenu successful at ${Date(mensaMenu.meta.updateTime * 1000)}")
+    }
+
+    /**
+     * this function updates all existing timetables
+     * during the update process the old data will be returned for a API request
+     */
+    private fun asyncUpdateTimetables() = GlobalScope.launch {
+        timetableList.forEach { timetableCourse ->
+            val updateURL = timetableCourse.meta.link
+            timetableCourse.timetable = TimetableParser().getTimeTable(updateURL)
+            timetableCourse.meta.updateTime = System.currentTimeMillis() / 1000
+        }
+        logger.info("updated ${timetableList.size} timetables successful!")
+    }
+
+    /**
+     * before the APIController is up, get the data fist
+     * runBlocking: otherwise the api would return no data to requests for a few seconds after startup
+     */
+    private fun initUpdates() = runBlocking {
+        // get all courses on startup
+        val jobCourseUpdate = GlobalScope.async {
+            CourseListParser().getCourseLinks(courseListURL)?.let {
+                courseList =
+                    CourseList(
+                        CourseMeta(
+                            System.currentTimeMillis() / 1000,
+                            it.size
+                        ), it
+                    )
+            }
+        }
+
+        // get the current and next weeks mensa menus
+        val jobMensa = GlobalScope.async{
+            val mensaCurrentWeek = MensaParser().getMensaMenu(mensaMenuURL)
+            val mensaNextWeek = MensaParser().getMensaMenu(MensaParser().getMenuLinkNextWeek(mensaMenuURL))
+
+            // only update if we get valid data
+            if (mensaCurrentWeek != null && mensaNextWeek != null) {
+                mensaMenu =
+                    MensaMenu(
+                        MensaMeta(
+                            System.currentTimeMillis() / 1000,
+                            mensaName
+                        ), mensaCurrentWeek, mensaNextWeek
+                    )
+            }
+        }
+
+        jobCourseUpdate.await()
+        jobMensa.await()
+
+        logger.info("init updates successful")
+    }
+
+    /**
+     * doesn't account the change between winter and summer time!
+     *
+     */
+    private fun scheduledUpdates() {
+        val currentTime = System.currentTimeMillis()
+        val initDelay24h = (86400000 - ((currentTime + 3600000) % 86400000)) + 60000
+        val initDelay3h = (10800000 - ((currentTime + 3600000) % 10800000)) + 60000
+        val initDelay1h = (3600000 - ((currentTime + 3600000) % 3600000)) + 60000
+
+        // update courseList every 24 hours (time in ms)
+        Timer().scheduleAtFixedRate(initDelay24h, 86400000) {
+            asyncUpdateCourseList()
+        }
+
+        // update all already existing timetables every 3 hours (time in ms)
+        Timer().scheduleAtFixedRate(initDelay3h, 10800000) {
+            asyncUpdateTimetables()
+        }
+
+        // update courses every hour (time in ms)
+        Timer().scheduleAtFixedRate(initDelay1h, 3600000) {
+            asyncUpdateMensa()
+        }
+
+        // post to status.mosad.xyz every hour
+        Timer().scheduleAtFixedRate(initDelay1h, 3600000) {
+            CachetAPIController.postTotalRequests()
+        }
+    }
+
+}

src/main/kotlin/org/mosad/thecitadelofricks/controller/CachetAPIController.kt

@@ -0,0 +1,77 @@
+/**
+ * TheCitadelofRicks
+ *
+ * Copyright 2019  <seil0@mosad.xyz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ *
+ */
+
+package org.mosad.thecitadelofricks.controller
+
+import org.mosad.thecitadelofricks.controller.StatusController.Companion.getTotalRequests
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import java.io.BufferedReader
+import java.io.IOException
+import java.io.InputStreamReader
+import java.net.HttpURLConnection
+import java.net.URL
+
+class CachetAPIController {
+
+     companion object {
+
+         private val logger: Logger = LoggerFactory.getLogger(CachetAPIController::class.java)
+         private const val baseURL = "https://status.mosad.xyz"
+         private const val apiKey = "" //TODO
+
+         private var oldTotalRequests = 0
+
+         fun postTotalRequests() {
+             try {
+                 val url = URL("$baseURL/api/v1/metrics/1/points")
+                 val jsonInputString = "{\"value\": ${getTotalRequests() -oldTotalRequests}, \"timestamp\": \"${(System.currentTimeMillis() / 1000)}\"}"
+                 oldTotalRequests = getTotalRequests()
+
+                 val con = url.openConnection() as HttpURLConnection
+                 con.requestMethod = "POST"
+                 con.setRequestProperty("Content-Type", "application/json; utf-8")
+                 con.setRequestProperty("Accept", "application/json")
+                 con.setRequestProperty("X-Cachet-Token", apiKey)
+                 con.doOutput = true
+
+                 val os = con.outputStream
+                 val input = jsonInputString.toByteArray(charset("utf-8"))
+                 os.write(input, 0, input.size)
+
+                 val br = BufferedReader(InputStreamReader(con.inputStream, "utf-8"))
+                 val response = StringBuilder()
+                 var responseLine: String?
+
+                 while (br.readLine().also { responseLine = it } != null) {
+                     response.append(responseLine!!.trim { it <= ' ' })
+                 }
+                 logger.info(response.toString())
+
+             } catch (e1: IOException) {
+                 e1.printStackTrace()
+             }
+         }
+
+     }
+
+}

src/main/kotlin/org/mosad/thecitadelofricks/controller/StatusController.kt

@@ -0,0 +1,127 @@
+/**
+ * TheCitadelofRicks
+ *
+ * Copyright 2019  <seil0@mosad.xyz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ *
+ */
+
+package org.mosad.thecitadelofricks.controller
+
+import org.mosad.thecitadelofricks.APIController.Companion.apiVersion
+import org.mosad.thecitadelofricks.APIController.Companion.softwareVersion
+import org.mosad.thecitadelofricks.APIController.Companion.startTime
+import org.mosad.thecitadelofricks.Status
+import org.mosad.thecitadelofricks.TimetableCounter
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import java.net.HttpURLConnection
+import java.net.URL
+import java.time.LocalDateTime
+import java.util.*
+import kotlin.collections.ArrayList
+
+class StatusController {
+
+    companion object {
+        private val logger: Logger = LoggerFactory.getLogger(StatusController::class.java)
+
+        private var totalRequests = 0
+        private var mensaMenuRequests = 0
+        private var timetableRequests = ArrayList<TimetableCounter>()
+
+        fun updateTotalRequests() {
+            totalRequests++
+        }
+
+        fun updateMensaMenuRequests() {
+            mensaMenuRequests++
+        }
+
+        /**
+         * if a timetable is requested update the request counter
+         */
+        fun updateTimetableRequests(courseName: String) {
+            when (timetableRequests.stream().filter { x -> x.courseName == courseName }.findAny().orElse(null)) {
+                null -> timetableRequests.add(TimetableCounter(courseName, 0))
+            }
+            timetableRequests.stream().filter { x ->x.courseName == courseName }.findFirst().ifPresent { x -> x.requests++ }
+
+            // TODO Java 11
+//        timetableRequests.stream().filter { it.courseName == courseName }.findFirst().ifPresentOrElse({
+//            it.requests++
+//        }, {
+//
+//        })
+        }
+
+        fun getTotalRequests(): Int {
+            return totalRequests
+        }
+
+        fun getMensaMenuRequests(): Int {
+            return mensaMenuRequests
+        }
+
+        fun getTimetableRequests(): ArrayList<TimetableCounter> {
+            return timetableRequests
+        }
+
+        fun getStatus(): Status {
+            val currentTime = System.currentTimeMillis() / 1000
+            val minutes = (currentTime - startTime) % 3600 / 60
+            val hours = (currentTime - startTime) % 86400 / 3600
+            val days = (currentTime - startTime) / 86400
+
+            var hsoCode = 999
+            var swfrCode = 999
+
+            try {
+                val hsoURL = URL("https://www.hs-offenburg.de/")
+                val swfrURL = URL("https://www.swfr.de/")
+
+                var connection = hsoURL.openConnection() as HttpURLConnection
+                connection.requestMethod = "HEAD"
+
+                connection.connectTimeout = 15000
+                hsoCode = connection.responseCode
+
+                connection = swfrURL.openConnection() as HttpURLConnection
+                connection.connectTimeout = 15000
+                swfrCode = connection.responseCode
+            } catch (e: Exception) {
+                logger.error("Error while fetching url response codes!", e)
+            }
+
+            return Status(
+                LocalDateTime.now(),
+                "$days days, $hours:$minutes",
+                apiVersion,
+                softwareVersion,
+                getTotalRequests(),
+                getMensaMenuRequests(),
+                getTimetableRequests(),
+                CacheController.timetableList.size,
+                Date(CacheController.courseList.meta.updateTime * 1000),
+                Date(CacheController.mensaMenu.meta.updateTime * 1000),
+                hsoCode,
+                swfrCode
+            )
+        }
+
+    }
+}