version bump

fixes #216 (#218 )
Update release.yml
2026-08-19 08:35:41 +02:00 · 2025-03-04 18:03:18 +01:00 · 2025-03-04 18:00:16 +01:00 · 2025-03-02 14:11:22 +01:00 · 2024-12-29 12:48:07 +01:00 · 2024-12-27 19:27:28 +01:00
224 changed files with 17376 additions and 12320 deletions
@@ -8,12 +8,12 @@ jobs:
  build:
    strategy:
      matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
+        os: [ ubuntu-latest, windows-latest, macos-13, macos-latest ]
    runs-on: ${{ matrix.os }}
    steps:
    - uses: actions/checkout@v3

-    - name: Set up JDK 21
+    - name: Set up jdk21
      uses: actions/setup-java@v3
      with:
        java-version: '21'
@@ -21,37 +21,29 @@ jobs:
        server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
        settings-path: ${{ github.workspace }} # location for the settings.xml file

-    - name: Build parent project
-      run: mvn -N -q install --file pom.xml
-
-    - name: Build Core Jar
-      run: mvn -B -q install --file vripper-core/pom.xml
-
-    - name: Build GUI Jar
-      run: mvn -B -q install --file vripper-gui/pom.xml
-
-    - name: Rename GUI Jar
-      run: mv vripper-gui/target/vripper-gui-${{ github.event.release.tag_name }}-jar-with-dependencies.jar vripper-gui/target/vripper-noarch-gui-${{ github.event.release.tag_name }}.jar
+    - name: Build gui jar
+      run: |
+        mvn -N -q install --file pom.xml
+        mvn -B -q install --file vripper-core/pom.xml
+        mvn -B -q install --file vripper-gui/pom.xml
+        mv vripper-gui/target/vripper-gui-${{ github.event.release.tag_name }}-jar-with-dependencies.jar vripper-gui/target/vripper-noarch-gui-${{ github.event.release.tag_name }}.jar

    - if: matrix.os == 'ubuntu-latest'
-      name: Release GUI Jar
+      name: Release gui Jar
      uses: softprops/action-gh-release@v1
      with:
        files: vripper-gui/target/vripper-noarch-gui-${{ github.event.release.tag_name }}.jar

    # Start building WEB jar in ubuntu only
    - if: matrix.os == 'ubuntu-latest'
-      name: Build WEB Jar
+      name: Build web Jar
      run: |
        mvn -B -q install --file vripper-web-ui/pom.xml
        mvn -B -q install --file vripper-web/pom.xml
+        mv vripper-web/target/vripper-web-${{ github.event.release.tag_name }}.jar vripper-web/target/vripper-noarch-web-${{ github.event.release.tag_name }}.jar

    - if: matrix.os == 'ubuntu-latest'
-      name: Rename WEB Jar
-      run: mv vripper-web/target/vripper-web-${{ github.event.release.tag_name }}.jar vripper-web/target/vripper-noarch-web-${{ github.event.release.tag_name }}.jar
-
-    - if: matrix.os == 'ubuntu-latest'
-      name: Release WEB Jar
+      name: Release web Jar
      uses: softprops/action-gh-release@v1
      with:
        files: vripper-web/target/vripper-noarch-web-${{ github.event.release.tag_name }}.jar
@@ -62,7 +54,7 @@ jobs:
        cp vripper-gui/target/vripper-noarch-gui-${{ github.event.release.tag_name }}.jar jpackage/jar/vripper-gui.jar
        
    - if: matrix.os == 'ubuntu-latest'
-      name: Package Linux
+      name: Package for Linux
      run: |
        cd jpackage
        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-app-image.cfg" --icon icon.png
@@ -72,7 +64,7 @@ jobs:
        mv dist/vripper_${{ github.event.release.tag_name }}-1_amd64.deb dist/vripper-linux-${{ github.event.release.tag_name }}_amd64.deb

    - if: matrix.os == 'windows-latest'
-      name: Package Windows
+      name: Package for Windows
      run: |
        cd jpackage
        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-app-image.cfg" --icon icon.ico
@@ -83,14 +75,24 @@ jobs:
        ren VRipper-${{ github.event.release.tag_name }}.exe vripper-windows-installer-${{ github.event.release.tag_name }}.exe

    - if: matrix.os == 'macos-latest'
-      name: Package macOS
+      name: Package for macOS(arm64)
      run: |
        cd jpackage
        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-app-image.cfg" --icon icon.icns
        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-macos.cfg" --type pkg
        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-macos.cfg" --type dmg
-        mv dist/VRipper-${{ github.event.release.tag_name }}.pkg dist/vripper-macos-${{ github.event.release.tag_name }}.pkg
-        mv dist/VRipper-${{ github.event.release.tag_name }}.dmg dist/vripper-macos-${{ github.event.release.tag_name }}.dmg
+        mv dist/VRipper-${{ github.event.release.tag_name }}.pkg dist/vripper-macos-${{ github.event.release.tag_name }}.arm64.pkg
+        mv dist/VRipper-${{ github.event.release.tag_name }}.dmg dist/vripper-macos-${{ github.event.release.tag_name }}.arm64.dmg
+    
+    - if: matrix.os == 'macos-13'
+      name: Package for macOS(x86_64)
+      run: |
+        cd jpackage
+        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-app-image.cfg" --icon icon.icns
+        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-macos.cfg" --type pkg
+        jpackage --app-version ${{ github.event.release.tag_name }} "@jpackage.cfg" "@jpackage-macos.cfg" --type dmg
+        mv dist/VRipper-${{ github.event.release.tag_name }}.pkg dist/vripper-macos-${{ github.event.release.tag_name }}.x86_64.pkg
+        mv dist/VRipper-${{ github.event.release.tag_name }}.dmg dist/vripper-macos-${{ github.event.release.tag_name }}.x86_64.dmg

    - if: matrix.os == 'ubuntu-latest'
      name: Zip Ubuntu portable
@@ -111,13 +113,22 @@ jobs:
        filename: 'vripper-windows-portable-${{ github.event.release.tag_name }}.zip'

    - if: matrix.os == 'macos-latest'
-      name: Zip MacOS portable
+      name: Zip macOS(arm64) portable
      uses: thedoctor0/zip-release@0.7.1
      with:
        type: 'zip'
        directory: 'jpackage/dist'
        path: 'VRipper.app'
-        filename: 'vripper-macos-portable-${{ github.event.release.tag_name }}.zip'
+        filename: 'vripper-macos-portable-${{ github.event.release.tag_name }}.arm64.zip'
+    
+    - if: matrix.os == 'macos-13'
+      name: Zip macOS(x86_64) portable
+      uses: thedoctor0/zip-release@0.7.1
+      with:
+        type: 'zip'
+        directory: 'jpackage/dist'
+        path: 'VRipper.app'
+        filename: 'vripper-macos-portable-${{ github.event.release.tag_name }}.x86_64.zip'

    - if: matrix.os == 'ubuntu-latest'
      name: Release packages for Linux
@@ -138,10 +149,19 @@ jobs:
          jpackage/dist/vripper-windows-portable-${{ github.event.release.tag_name }}.zip

    - if: matrix.os == 'macos-latest'
-      name: Release packages for macOS
+      name: Release packages for macOS(arm64)
      uses: softprops/action-gh-release@v1
      with:
        files: |
-          jpackage/dist/vripper-macos-${{ github.event.release.tag_name }}.pkg
-          jpackage/dist/vripper-macos-${{ github.event.release.tag_name }}.dmg
-          jpackage/dist/vripper-macos-portable-${{ github.event.release.tag_name }}.zip
+          jpackage/dist/vripper-macos-${{ github.event.release.tag_name }}.arm64.pkg
+          jpackage/dist/vripper-macos-${{ github.event.release.tag_name }}.arm64.dmg
+          jpackage/dist/vripper-macos-portable-${{ github.event.release.tag_name }}.arm64.zip
+          
+    - if: matrix.os == 'macos-13'
+      name: Release packages for macOS(x86_64)
+      uses: softprops/action-gh-release@v1
+      with:
+        files: |
+          jpackage/dist/vripper-macos-${{ github.event.release.tag_name }}.x86_64.pkg
+          jpackage/dist/vripper-macos-${{ github.event.release.tag_name }}.x86_64.dmg
+          jpackage/dist/vripper-macos-portable-${{ github.event.release.tag_name }}.x86_64.zip
@@ -4,4 +4,5 @@
 /**/*/build-dir
 /**/*/java-runtime
 .idea
-.vripper
+.vripper
+.flattened-pom.xml
@@ -1,25 +1,43 @@
 # VRipper!

-This is my spin for a cross-platform gallery ripper for [vipergirls.to](https://vipergirls.to).
-
+This is my spin for a cross-platform gallery ripper for [vipergirls.to](https://vipergirls.to)

 ![GitHub Image](/image.png)

+## Donation
+To support this project, you can make a donation to its current maintainer
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://buymeacoffee.com/devclaw)
+
+Or with Cryptocurrency
+
+ETH: 0xDdac82B16dC5E3D742fc915ffF583D8548A301cA
+
+BTC: bc1qcqudnkrndwyadsjwrxww42svkf8trnzx3c8vlr

 ## Requirements
-Direct access to vipergirls.to (or one of its [alternative domains](https://vipergirls.to/threads/5887340)), consider using a VPN otherwise.
+Direct access to `vipergirls.to` domain.

 ## Installing VRipper

 <img src="https://github.com/stashapp/stash/raw/develop/docs/readme_assets/windows_logo.svg" width="100%" height="75"> Windows | <img src="https://github.com/stashapp/stash/raw/develop/docs/readme_assets/mac_logo.svg" width="100%" height="75"> macOS | <img src="https://github.com/stashapp/stash/raw/develop/docs/readme_assets/linux_logo.svg" width="100%" height="75"> Linux  | <img src="https://images.vexels.com/media/users/3/166401/isolated/preview/b82aa7ac3f736dd78570dd3fa3fa9e24-java-programming-language-icon-by-vexels.png" width="100%" height="75"> Java
 :---:|:---:|:---:|:---:
-[Installer (EXE)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-windows-installer-5.5.0.exe) <br /> [Installer (MSI)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-windows-installer-5.5.0.msi) <br /> [Portable (ZIP)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-windows-portable-5.5.0.zip) | [Installer (DMG)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-macos-5.5.0.dmg) <br /> [Installer (PKG)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-macos-5.5.0.pkg) <br /> [Portable (ZIP)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-macos-portable-5.5.0.zip)  | [Linux (amd64) (DEB)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-linux-5.5.0_amd64.deb) <br /> [Linux (x86_64) (RPM)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-linux-5.5.0.x86_64.rpm) <br /> [Portable (ZIP)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-linux-portable-5.5.0.zip) | [Java GUI (noarch)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-noarch-gui-5.5.0.jar) <br /> [Java Web (noarch)](https://github.com/death-claw/vripper-project/releases/download/5.5.0/vripper-noarch-web-5.5.0.jar)
+[Installer (EXE)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-windows-installer-6.4.0.exe) <br /> [Installer (MSI)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-windows-installer-6.4.0.msi) <br /> [Portable (ZIP)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-windows-portable-6.4.0.zip) | [Installer (DMG)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-macos-6.4.0.dmg) <br /> [Installer (PKG)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-macos-6.4.0.pkg) <br /> [Portable (ZIP)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-macos-portable-6.4.0.zip)  | [Linux (amd64) (DEB)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-linux-6.4.0_amd64.deb) <br /> [Linux (x86_64) (RPM)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-linux-6.4.0.x86_64.rpm) <br /> [Portable (ZIP)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-linux-portable-6.4.0.zip) | [Java GUI (noarch)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-noarch-gui-6.4.0.jar) <br /> [Java Web (noarch)](https://github.com/death-claw/vripper-project/releases/download/6.4.0/vripper-noarch-web-6.4.0.jar)

 Source code and previous versions are available on the [Releases page](https://github.com/death-claw/vripper-project/releases).  

-Application data (application logs, settings and persisted data) is stored in `C:\USERS\<your Windows username>\vripper (Windows)` or `HOME_FOLDER/.config/vripper (Linux and macOS)`
+Application data (application logs, settings and persisted data) is stored in:  
+* Windows --> `C:\USERS\<your Windows username>\vripper` 
+* Linux and macOS --> `HOME_FOLDER/.config/vripper`


+## Important Note About Proxies
+The use of proxies within VRipper is worthless, please stop using them **for now**. You will get **403 error** codes.  
+
+**403** is a response code coming from Cloudflare to block VRipper from accessing the site, Cloudflare is doing the job it is supposed to do, which is blocking automated requests from accessing the site. 
+
+If your ISP is blocking access to `vipergirls.to` domain, consider using a VPN or [Cloudflare WARP](https://one.one.one.one/) to bypass the block.
+
 ## Supported Image Hosts
 The following hosts are supported:
 * acidimg.cc  
@@ -15,27 +15,29 @@
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <revision>5.6.0</revision>
-        <kotlin.version>1.9.22</kotlin.version>
-        <slf4j.version>2.0.12</slf4j.version>
-        <logback.version>1.5.0</logback.version>
-        <kotlinx-coroutines.version>1.8.0</kotlinx-coroutines.version>
-        <exposed.version>0.47.0</exposed.version>
+        <revision>6.4.0</revision>
+        <kotlin.version>2.0.21</kotlin.version>
+        <slf4j.version>2.0.16</slf4j.version>
+        <logback.version>1.5.12</logback.version>
+        <kotlinx-coroutines.version>1.9.0</kotlinx-coroutines.version>
+        <exposed.version>0.55.0</exposed.version>
        <snakeyaml.version>2.0</snakeyaml.version>
-        <koin.version>3.5.3</koin.version>
+        <koin.version>4.0.0</koin.version>
        <h2.version>2.2.224</h2.version>
        <htmlcleaner.version>2.29</htmlcleaner.version>
-        <failsafe.version>2.4.4</failsafe.version>
+        <failsafe.version>3.3.2</failsafe.version>
        <caffeine.version>3.1.8</caffeine.version>
        <jna-platform.version>5.14.0</jna-platform.version>
-        <kotlinx-serialization-json.version>1.6.2</kotlinx-serialization-json.version>
-        <httpclient5.version>5.3.1</httpclient5.version>
-        <commons-codec.version>1.16.1</commons-codec.version>
-        <liquibase-core.version>4.26.0</liquibase-core.version>
+        <kotlinx-serialization-json.version>1.7.3</kotlinx-serialization-json.version>
+        <httpclient5.version>5.4</httpclient5.version>
+        <httpcore5.version>5.3</httpcore5.version>
+        <commons-codec.version>1.17.1</commons-codec.version>
+        <liquibase-core.version>4.29.2</liquibase-core.version>
        <liquibase-slf4j.version>5.0.0</liquibase-slf4j.version>
        <grpc.kotlin.version>1.4.1</grpc.kotlin.version>
-        <java.grpc.version>1.62.2</java.grpc.version>
-        <protobuf.version>3.25.3</protobuf.version>
+        <java.grpc.version>1.68.1</java.grpc.version>
+        <protobuf.version>3.25.5</protobuf.version>
+        <sqlite-jdbc.version>3.47.0.0</sqlite-jdbc.version>
    </properties>
    <build>
        <plugins>
@@ -129,14 +131,19 @@
                <groupId>com.h2database</groupId>
                <version>${h2.version}</version>
            </dependency>
+            <dependency>
+                <groupId>org.xerial</groupId>
+                <artifactId>sqlite-jdbc</artifactId>
+                <version>${sqlite-jdbc.version}</version>
+            </dependency>
            <dependency>
                <artifactId>htmlcleaner</artifactId>
                <groupId>net.sourceforge.htmlcleaner</groupId>
                <version>${htmlcleaner.version}</version>
            </dependency>
            <dependency>
+                <groupId>dev.failsafe</groupId>
                <artifactId>failsafe</artifactId>
-                <groupId>net.jodah</groupId>
                <version>${failsafe.version}</version>
            </dependency>
            <dependency>
@@ -169,6 +176,16 @@
                <groupId>org.apache.httpcomponents.client5</groupId>
                <version>${httpclient5.version}</version>
            </dependency>
+            <dependency>
+                <artifactId>httpcore5</artifactId>
+                <groupId>org.apache.httpcomponents.core5</groupId>
+                <version>${httpcore5.version}</version>
+            </dependency>
+            <dependency>
+                <artifactId>httpcore5-h2</artifactId>
+                <groupId>org.apache.httpcomponents.core5</groupId>
+                <version>${httpcore5.version}</version>
+            </dependency>
            <dependency>
                <artifactId>commons-codec</artifactId>
                <groupId>commons-codec</groupId>
@@ -194,16 +211,16 @@
                <artifactId>grpc-protobuf</artifactId>
                <version>${java.grpc.version}</version>
            </dependency>
-            <dependency>
-                <groupId>com.google.protobuf</groupId>
-                <artifactId>protobuf-kotlin</artifactId>
-                <version>${protobuf.version}</version>
-            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-netty-shaded</artifactId>
                <version>${java.grpc.version}</version>
            </dependency>
+            <dependency>
+                <groupId>com.google.protobuf</groupId>
+                <artifactId>protobuf-kotlin</artifactId>
+                <version>${protobuf.version}</version>
+            </dependency>
        </dependencies>
    </dependencyManagement>
 </project>
@@ -51,6 +51,10 @@
            <artifactId>h2</artifactId>
            <groupId>com.h2database</groupId>
        </dependency>
+        <dependency>
+            <groupId>org.xerial</groupId>
+            <artifactId>sqlite-jdbc</artifactId>
+        </dependency>
        <dependency>
            <artifactId>httpclient5</artifactId>
            <groupId>org.apache.httpcomponents.client5</groupId>
@@ -65,7 +69,7 @@
        </dependency>
        <dependency>
            <artifactId>failsafe</artifactId>
-            <groupId>net.jodah</groupId>
+            <groupId>dev.failsafe</groupId>
        </dependency>
        <dependency>
            <artifactId>caffeine</artifactId>
@@ -104,6 +108,11 @@
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-kotlin</artifactId>
        </dependency>
+        <dependency>
+            <groupId>com.bucket4j</groupId>
+            <artifactId>bucket4j_jdk17-core</artifactId>
+            <version>8.14.0</version>
+        </dependency>
    </dependencies>

    <build>
@@ -132,14 +141,14 @@
                <executions>
                    <execution>
                        <id>compile</id>
-                        <phase>compile</phase>
+                        <phase>process-sources</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
-                    <jvmTarget>1.8</jvmTarget>
+                    <jvmTarget>21</jvmTarget>
                    <compilerPlugins>
                        <plugin>kotlinx-serialization</plugin>
                    </compilerPlugins>
@@ -1,10 +1,16 @@
 package me.vripper

+import me.vripper.data.repositories.ImageRepository
+import me.vripper.data.repositories.MetadataRepository
+import me.vripper.data.repositories.PostRepository
+import me.vripper.data.repositories.ThreadRepository
+import me.vripper.data.repositories.impl.ImageRepositoryImpl
+import me.vripper.data.repositories.impl.MetadataRepositoryImpl
+import me.vripper.data.repositories.impl.PostRepositoryImpl
+import me.vripper.data.repositories.impl.ThreadRepositoryImpl
 import me.vripper.download.DownloadService
 import me.vripper.event.EventBus
 import me.vripper.host.*
-import me.vripper.repositories.*
-import me.vripper.repositories.impl.*
 import me.vripper.services.*
 import org.koin.core.qualifier.named
 import org.koin.dsl.bind
@@ -17,11 +23,14 @@ val coreModule = module {
    single<SettingsService> {
        SettingsService(get())
    }
+    single<LogService> {
+        LogService(get())
+    }
    single<ImageRepository> {
        ImageRepositoryImpl()
    }
-    single<PostDownloadStateRepository> {
-        PostDownloadStateRepositoryImpl()
+    single<PostRepository> {
+        PostRepositoryImpl()
    }
    single<MetadataRepository> {
        MetadataRepositoryImpl()
@@ -29,11 +38,8 @@ val coreModule = module {
    single<ThreadRepository> {
        ThreadRepositoryImpl()
    }
-    single<LogRepository> {
-        LogRepositoryImpl(get())
-    }
    single<DataTransaction> {
-        DataTransaction(get(), get(), get(), get(), get(), get(), get())
+        DataTransaction(get(), get(), get(), get(), get(), get())
    }
    single<RetryPolicyService> {
        RetryPolicyService(get(), get())
@@ -55,15 +61,15 @@ val coreModule = module {
    }

    single<AppEndpointService> {
-        AppEndpointService(get(), get(), get(), get(), get())
+        AppEndpointService(get(), get(), get(), get(), get(), get())
    }

    single((named("localAppEndpointService"))) {
-        AppEndpointService(get(), get(), get(), get(), get())
+        AppEndpointService(get(), get(), get(), get(), get(), get())
    } bind IAppEndpointService::class

    single<MetadataService> {
-        MetadataService(get(), get(), get(), get())
+        MetadataService(get(), get())
    }
    single {
        AcidimgHost(get(), get(), get())
@@ -0,0 +1,16 @@
+package me.vripper
+
+import ch.qos.logback.classic.spi.ILoggingEvent
+import ch.qos.logback.core.AppenderBase
+import org.apache.commons.collections4.queue.CircularFifoQueue
+
+class RingAppender : AppenderBase<ILoggingEvent>() {
+
+    object Static {
+        val events = CircularFifoQueue<ILoggingEvent>()
+    }
+
+    override fun append(event: ILoggingEvent) {
+        Static.events.offer(event)
+    }
+}
@@ -1,9 +1,9 @@
-package me.vripper.repositories
+package me.vripper.data.repositories

 import me.vripper.entities.ImageEntity
 import java.util.*

-interface ImageRepository {
+internal interface ImageRepository {
    fun save(imageEntity: ImageEntity): ImageEntity
    fun save(imageEntityList: List<ImageEntity>)
    fun deleteAllByPostId(postId: Long)
@@ -1,9 +1,9 @@
-package me.vripper.repositories
+package me.vripper.data.repositories

 import me.vripper.entities.MetadataEntity
 import java.util.*

-interface MetadataRepository {
+internal interface MetadataRepository {
    fun save(metadataEntity: MetadataEntity): MetadataEntity
    fun findByPostId(postId: Long): Optional<MetadataEntity>
    fun deleteByPostId(postId: Long): Int
@@ -1,12 +1,11 @@
-package me.vripper.repositories
+package me.vripper.data.repositories

 import me.vripper.entities.PostEntity
-import java.util.*

-interface PostDownloadStateRepository {
+internal interface PostRepository {
    fun save(postEntities: List<PostEntity>): List<PostEntity>
-    fun findByPostId(postId: Long): Optional<PostEntity>
-    fun findById(id: Long): Optional<PostEntity>
+    fun findByPostId(postId: Long): PostEntity?
+    fun findById(id: Long): PostEntity?
    fun findCompleted(): List<Long>
    fun findAll(): List<PostEntity>
    fun existByPostId(postId: Long): Boolean
@@ -1,9 +1,9 @@
-package me.vripper.repositories
+package me.vripper.data.repositories

 import me.vripper.entities.ThreadEntity
 import java.util.*

-interface ThreadRepository {
+internal interface ThreadRepository {
    fun save(threadEntity: ThreadEntity): ThreadEntity
    fun update(threadEntity: ThreadEntity)
    fun findByThreadId(threadId: Long): Optional<ThreadEntity>
@@ -1,16 +1,16 @@
-package me.vripper.repositories.impl
+package me.vripper.data.repositories.impl

+import me.vripper.data.repositories.ImageRepository
+import me.vripper.data.tables.ImageTable
 import me.vripper.entities.ImageEntity
-import me.vripper.entities.domain.Status
-import me.vripper.repositories.ImageRepository
-import me.vripper.tables.ImageTable
+import me.vripper.entities.Status
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.TransactionManager
 import java.sql.Connection
 import java.util.*

-class ImageRepositoryImpl : ImageRepository {
+internal class ImageRepositoryImpl : ImageRepository {
    override fun save(imageEntity: ImageEntity): ImageEntity {
        val id = ImageTable.insertAndGetId {
            it[downloaded] = imageEntity.downloaded
@@ -47,21 +47,21 @@ class ImageRepositoryImpl : ImageRepository {
    }

    override fun findByPostId(postId: Long): List<ImageEntity> {
-        return ImageTable.select {
+        return ImageTable.selectAll().where {
            ImageTable.postId eq postId
        }.map(this::transform)
    }

    override fun countError(): Int {
        return ImageTable
-            .slice(ImageTable.id)
-            .select { ImageTable.status eq Status.ERROR.name }
+            .select(ImageTable.id)
+            .where { ImageTable.status eq Status.ERROR.name }
            .count().toInt()
    }

    override fun findByPostIdAndIsNotCompleted(postId: Long): List<ImageEntity> {
        return ImageTable
-            .select {
+            .selectAll().where {
                (ImageTable.postId eq postId) and (ImageTable.status neq Status.FINISHED.name)
            }.map(this::transform)
    }
@@ -79,13 +79,13 @@ class ImageRepositoryImpl : ImageRepository {
    }

    override fun findByPostIdAndIsError(postId: Long): List<ImageEntity> {
-        return ImageTable.select {
+        return ImageTable.selectAll().where {
            (ImageTable.postId eq postId) and (ImageTable.status eq Status.ERROR.name)
        }.map(this::transform)
    }

    override fun findById(id: Long): Optional<ImageEntity> {
-        val result = ImageTable.select {
+        val result = ImageTable.selectAll().where {
            ImageTable.id eq id
        }.map(this::transform)
        return if (result.isEmpty()) {
@@ -122,7 +122,7 @@ class ImageRepositoryImpl : ImageRepository {

    override fun deleteAllByPostId(postIds: List<Long>) {
        val conn = TransactionManager.current().connection.connection as Connection
-        conn.prepareStatement("CREATE LOCAL TEMPORARY TABLE IMAGES_DELETE(POST_ID BIGINT PRIMARY KEY)")
+        conn.prepareStatement("CREATE TEMPORARY TABLE IMAGES_DELETE(POST_ID BIGINT PRIMARY KEY)")
            .use {
                it.execute()
            }
@@ -140,7 +140,7 @@ class ImageRepositoryImpl : ImageRepository {
                it.execute()
            }

-        conn.prepareStatement("TRUNCATE TABLE IMAGES_DELETE").use {
+        conn.prepareStatement("DELETE FROM IMAGES_DELETE").use {
            it.execute()
        }
    }
@@ -1,20 +1,20 @@
-package me.vripper.repositories.impl
+package me.vripper.data.repositories.impl

 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import me.vripper.data.repositories.MetadataRepository
+import me.vripper.data.tables.MetadataTable
 import me.vripper.entities.MetadataEntity
-import me.vripper.repositories.MetadataRepository
-import me.vripper.tables.MetadataTable
 import org.jetbrains.exposed.sql.ResultRow
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.deleteWhere
 import org.jetbrains.exposed.sql.insert
-import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
 import org.jetbrains.exposed.sql.transactions.TransactionManager
 import java.sql.Connection
 import java.util.*

-class MetadataRepositoryImpl: MetadataRepository {
+internal class MetadataRepositoryImpl : MetadataRepository {

    override fun save(metadataEntity: MetadataEntity): MetadataEntity {
        MetadataTable.insert {
@@ -27,7 +27,7 @@ class MetadataRepositoryImpl: MetadataRepository {

    override fun findByPostId(postId: Long): Optional<MetadataEntity> {

-        val result = MetadataTable.select {
+        val result = MetadataTable.selectAll().where {
            MetadataTable.postId eq postId
        }.map(::transform)

@@ -50,7 +50,7 @@ class MetadataRepositoryImpl: MetadataRepository {

    override fun deleteAllByPostId(postIds: List<Long>) {
        val conn = TransactionManager.current().connection.connection as Connection
-        conn.prepareStatement("CREATE LOCAL TEMPORARY TABLE METADATA_DELETE(POST_ID BIGINT PRIMARY KEY)")
+        conn.prepareStatement("CREATE TEMPORARY TABLE METADATA_DELETE(POST_ID BIGINT PRIMARY KEY)")
            .use {
                it.execute()
            }
@@ -68,7 +68,7 @@ class MetadataRepositoryImpl: MetadataRepository {
                it.execute()
            }

-        conn.prepareStatement("TRUNCATE TABLE METADATA_DELETE").use {
+        conn.prepareStatement("DELETE FROM METADATA_DELETE").use {
            it.execute()
        }
    }
@@ -1,17 +1,16 @@
-package me.vripper.repositories.impl
+package me.vripper.data.repositories.impl

+import me.vripper.data.repositories.PostRepository
+import me.vripper.data.tables.PostTable
 import me.vripper.entities.PostEntity
-import me.vripper.entities.domain.Status
-import me.vripper.repositories.PostDownloadStateRepository
-import me.vripper.tables.PostTable
+import me.vripper.entities.Status
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.transactions.TransactionManager
 import java.sql.Connection
-import java.util.*

-class PostDownloadStateRepositoryImpl :
-    PostDownloadStateRepository {
+internal class PostRepositoryImpl :
+    PostRepository {

    private val delimiter = ";"

@@ -37,33 +36,24 @@ class PostDownloadStateRepositoryImpl :
        }.map(::transform)
    }

-    override fun findByPostId(postId: Long): Optional<PostEntity> {
-        val result = PostTable.select {
+    override fun findByPostId(postId: Long): PostEntity? {
+        val result = PostTable.selectAll().where {
            PostTable.postId eq postId
        }.map(::transform)
-        return if (result.isEmpty()) {
-            Optional.empty()
-        } else {
-            Optional.of(result.first())
-        }
+        return result.firstOrNull()
    }

    override fun findCompleted(): List<Long> {
-        return PostTable.slice(PostTable.postId).select {
+        return PostTable.select(PostTable.postId).where {
            (PostTable.status eq Status.FINISHED.name) and (PostTable.done greaterEq PostTable.total)
        }.map { it[PostTable.postId] }
    }

-    override fun findById(id: Long): Optional<PostEntity> {
-        val result = PostTable.select {
+    override fun findById(id: Long): PostEntity? {
+        val result = PostTable.selectAll().where {
            PostTable.id eq id
        }.map { transform(it) }
-
-        return if (result.isEmpty()) {
-            Optional.empty()
-        } else {
-            Optional.of(result.first())
-        }
+        return result.firstOrNull()
    }

    override fun findAll(): List<PostEntity> {
@@ -71,7 +61,7 @@ class PostDownloadStateRepositoryImpl :
    }

    override fun existByPostId(postId: Long): Boolean {
-        return PostTable.slice(PostTable.id).select { PostTable.postId eq postId }.count() > 0
+        return PostTable.select(PostTable.id).where { PostTable.postId eq postId }.count() > 0
    }

    override fun setDownloadingToStopped(): Int {
@@ -118,15 +108,14 @@ class PostDownloadStateRepositoryImpl :
    }

    override fun findMaxRank(): Int? {
-        return PostTable.slice(PostTable.rank.max())
-            .selectAll()
+        return PostTable.select(PostTable.rank.max())
            .firstOrNull()
            ?.get(PostTable.rank.max())
    }

    override fun deleteAll(postIds: List<Long>) {
        val conn = TransactionManager.current().connection.connection as Connection
-        conn.prepareStatement("CREATE LOCAL TEMPORARY TABLE POSTS_DELETE(POST_ID BIGINT PRIMARY KEY)")
+        conn.prepareStatement("CREATE TEMPORARY TABLE POSTS_DELETE(POST_ID BIGINT PRIMARY KEY)")
            .use {
                it.execute()
            }
@@ -144,7 +133,7 @@ class PostDownloadStateRepositoryImpl :
                it.execute()
            }

-        conn.prepareStatement("TRUNCATE TABLE POSTS_DELETE").use {
+        conn.prepareStatement("DELETE FROM POSTS_DELETE").use {
            it.execute()
        }
    }
@@ -156,7 +145,7 @@ class PostDownloadStateRepositoryImpl :
    }

    override fun findAllNonCompletedPostIds(): List<Long> {
-        return PostTable.slice(PostTable.postId).select {
+        return PostTable.select(PostTable.postId).where {
            PostTable.status neq Status.FINISHED.name
        }.map { it[PostTable.postId] }
    }
@@ -1,13 +1,13 @@
-package me.vripper.repositories.impl
+package me.vripper.data.repositories.impl

+import me.vripper.data.repositories.ThreadRepository
+import me.vripper.data.tables.ThreadTable
 import me.vripper.entities.ThreadEntity
-import me.vripper.repositories.ThreadRepository
-import me.vripper.tables.ThreadTable
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import java.util.*

-class ThreadRepositoryImpl : ThreadRepository {
+internal class ThreadRepositoryImpl : ThreadRepository {

    override fun save(threadEntity: ThreadEntity): ThreadEntity {
        val id = ThreadTable.insertAndGetId {
@@ -27,7 +27,7 @@ class ThreadRepositoryImpl : ThreadRepository {
    }

    override fun findByThreadId(threadId: Long): Optional<ThreadEntity> {
-        val result = ThreadTable.select {
+        val result = ThreadTable.selectAll().where {
            ThreadTable.threadId eq threadId
        }.map(this::transform)
        return if (result.isEmpty()) {
@@ -42,7 +42,7 @@ class ThreadRepositoryImpl : ThreadRepository {
    }

    override fun findById(id: Long): Optional<ThreadEntity> {
-        val result = ThreadTable.select {
+        val result = ThreadTable.selectAll().where {
            ThreadTable.id eq id
        }.map(this::transform)
        return if (result.isEmpty()) {
@@ -1,8 +1,8 @@
-package me.vripper.tables
+package me.vripper.data.tables

 import org.jetbrains.exposed.dao.id.LongIdTable

-object ImageTable : LongIdTable(name = "IMAGE", columnName = "ID") {
+internal object ImageTable : LongIdTable(name = "IMAGE", columnName = "ID") {
    val downloaded = long("DOWNLOADED")
    val host = byte("HOST")
    val index = integer("INDEX")
@@ -12,5 +12,5 @@ object ImageTable : LongIdTable(name = "IMAGE", columnName = "ID") {
    val size = long("SIZE")
    val url = varchar("URL", 200)
    val thumbUrl = varchar("THUMB_URL", 200)
-    val postIdRef = long("POST_ID_REF").references(PostTable.id, fkName = "IMAGE_POST_ID_REF_POST_ID_FK")
+    val postIdRef = long("POST_ID_REF").references(id, fkName = "IMAGE_POST_ID_REF_POST_ID_FK")
 }
@@ -1,8 +1,8 @@
-package me.vripper.tables
+package me.vripper.data.tables

 import org.jetbrains.exposed.sql.Table

-object MetadataTable : Table(name = "METADATA") {
+internal object MetadataTable : Table(name = "METADATA") {
    val postId = long("POST_ID")
    val data = varchar("DATA", 1_000_000)
 }
@@ -1,10 +1,10 @@
-package me.vripper.tables
+package me.vripper.data.tables

 import org.jetbrains.exposed.dao.id.LongIdTable
 import org.jetbrains.exposed.sql.javatime.datetime
 import java.time.LocalDateTime

-object PostTable : LongIdTable(name = "POST", columnName = "ID") {
+internal object PostTable : LongIdTable(name = "POST", columnName = "ID") {
    val done = integer("DONE")
    val hosts = varchar("HOSTS", 255)
    val outputPath = varchar("OUTPUT_PATH", 260)
@@ -1,8 +1,8 @@
-package me.vripper.tables
+package me.vripper.data.tables

 import org.jetbrains.exposed.dao.id.LongIdTable

-object ThreadTable : LongIdTable("THREAD", columnName = "ID") {
+internal object ThreadTable : LongIdTable("THREAD", columnName = "ID") {
    val total = integer("TOTAL").default(0)
    val url = varchar("URL", 200)
    val threadId = long("THREAD_ID")
@@ -1,13 +1,11 @@
 package me.vripper.download

-import kotlinx.coroutines.CoroutineScope
+import dev.failsafe.Failsafe
+import dev.failsafe.RetryPolicy
 import kotlinx.coroutines.Runnable
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
 import me.vripper.entities.ImageEntity
-import me.vripper.entities.LogEntryEntity
 import me.vripper.entities.PostEntity
-import me.vripper.entities.domain.Status
+import me.vripper.entities.Status
 import me.vripper.event.ErrorCountEvent
 import me.vripper.event.EventBus
 import me.vripper.event.QueueStateEvent
@@ -19,16 +17,13 @@ import me.vripper.services.DataTransaction
 import me.vripper.services.RetryPolicyService
 import me.vripper.services.SettingsService
 import me.vripper.services.VGAuthService
-import me.vripper.utilities.GLOBAL_EXECUTOR
-import me.vripper.utilities.formatToString
-import net.jodah.failsafe.Failsafe
-import net.jodah.failsafe.RetryPolicy
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.utilities.downloadRunner
 import org.jetbrains.exposed.sql.transactions.transaction
-import java.util.concurrent.CompletableFuture
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock

-class DownloadService(
+internal class DownloadService(
    private val settingsService: SettingsService,
    private val dataTransaction: DataTransaction,
    private val retryPolicyService: RetryPolicyService,
@@ -36,12 +31,11 @@ class DownloadService(
    private val eventBus: EventBus
 ) {
    private val maxPoolSize: Int = 24
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()
    private val running: MutableMap<Byte, MutableList<ImageDownloadRunnable>> = mutableMapOf()
    private val pending: MutableMap<Byte, MutableList<ImageDownloadRunnable>> = mutableMapOf()
    private val lock = ReentrantLock()
    private val condition = lock.newCondition()
-    private val coroutineScope = CoroutineScope(SupervisorJob())

    init {
        Thread.ofVirtual().name("Download Loop").unstarted(Runnable {
@@ -51,14 +45,14 @@ class DownloadService(
                lock.withLock {
                    candidates.addAll(getCandidates(candidateCount()))
                    candidates.forEach {
-                        if (canRun(it.context.imageEntity.host)) {
+                        if (canRun(it.imageEntity.host)) {
                            accepted.add(it)
-                            running[it.context.imageEntity.host]!!.add(it)
-                            log.debug("${it.context.imageEntity.url} accepted to run")
+                            running[it.imageEntity.host]!!.add(it)
+                            log.debug("${it.imageEntity.url} accepted to run")
                        }
                    }
                    accepted.forEach {
-                        pending[it.context.imageEntity.host]?.remove(it)
+                        pending[it.imageEntity.host]?.remove(it)
                        scheduleForDownload(it)
                    }
                    accepted.clear()
@@ -76,14 +70,10 @@ class DownloadService(
    fun stop(postIds: List<Long> = emptyList()) {
        if (postIds.isNotEmpty()) {
            stopInternal(postIds)
-            coroutineScope.launch {
-                eventBus.publishEvent(StoppedEvent(postIds))
-            }
+            eventBus.publishEvent(StoppedEvent(postIds))
        } else {
            stopAll()
-            coroutineScope.launch {
-                eventBus.publishEvent(StoppedEvent(listOf(-1)))
-            }
+            eventBus.publishEvent(StoppedEvent(listOf(-1)))
        }
    }

@@ -91,8 +81,9 @@ class DownloadService(
        if (postEntityIds.isNotEmpty()) {
            restart(postEntityIds.associateWith { dataTransaction.findByPostIdAndIsNotCompleted(it.postId) })
        } else {
-            restart(dataTransaction.findAllPosts()
-                .associateWith { dataTransaction.findByPostIdAndIsNotCompleted(it.postId) })
+            restart(
+                dataTransaction.findAllPosts()
+                    .associateWith { dataTransaction.findByPostIdAndIsNotCompleted(it.postId) })
        }
    }

@@ -129,10 +120,6 @@ class DownloadService(
                )
            }

-            toProcess.keys.forEach {
-                vgAuthService.leaveThanks(it)
-            }
-

            toProcess.entries.forEach { (post, images) ->
                images.forEach { image ->
@@ -152,17 +139,20 @@ class DownloadService(
    }

    private fun isPending(postId: Long): Boolean {
-        return pending.values.flatten().any { it.context.imageEntity.postId == postId }
+        return pending.values.flatten().any { it.imageEntity.postId == postId }
    }

    private fun isRunning(postId: Long): Boolean {
-        return running.values.flatten().any { it.context.imageEntity.postId == postId }
+        return running.values.flatten().any { it.imageEntity.postId == postId }
    }

    private fun stopAll() {
        lock.withLock {
            pending.values.clear()
            running.values.flatten().forEach { obj: ImageDownloadRunnable -> obj.stop() }
+            while (running.values.flatten().count { !it.completed } > 0) {
+                Thread.sleep(100)
+            }
            dataTransaction.findAllNonCompletedPostIds().forEach {
                dataTransaction.stopImagesByPostIdAndIsNotCompleted(it)
                dataTransaction.finishPost(it)
@@ -174,11 +164,16 @@ class DownloadService(
        lock.withLock {
            for (postId in postIds) {
                pending.values.forEach { pending ->
-                    pending.removeIf { it.context.imageEntity.postId == postId }
+                    pending.removeIf { it.imageEntity.postId == postId }
                }
                running.values.flatten()
-                    .filter { p: ImageDownloadRunnable -> p.context.imageEntity.postId == postId }
+                    .filter { p: ImageDownloadRunnable -> p.imageEntity.postId == postId }
                    .forEach { obj: ImageDownloadRunnable -> obj.stop() }
+                while (running.values.flatten()
+                        .count { !it.completed && it.imageEntity.postId == postId } > 0
+                ) {
+                    Thread.sleep(100)
+                }
            }
            postIds.forEach {
                dataTransaction.stopImagesByPostIdAndIsNotCompleted(it)
@@ -213,7 +208,7 @@ class DownloadService(

            val list: List<ImageDownloadRunnable> =
                pending[host]!!.sortedWith(Comparator.comparingInt<ImageDownloadRunnable> { it.postRank }
-                    .thenComparingInt { it.context.imageEntity.index })
+                    .thenComparingInt { it.imageEntity.index })

            for (imageDownloadRunnable in list) {
                val count = hostIntegerMap[host] ?: 0
@@ -229,59 +224,42 @@ class DownloadService(
    }

    private fun scheduleForDownload(imageDownloadRunnable: ImageDownloadRunnable) {
-        log.debug("Scheduling a job for ${imageDownloadRunnable.context.imageEntity.url}")
-        CompletableFuture.runAsync({
-            coroutineScope.launch {
-                eventBus.publishEvent(QueueStateEvent(QueueState(runningCount(), pendingCount())))
+        log.debug("Scheduling a job for ${imageDownloadRunnable.imageEntity.url}")
+        eventBus.publishEvent(QueueStateEvent(QueueState(runningCount(), pendingCount())))
+        Failsafe.with<Any, RetryPolicy<Any>>(retryPolicyService.buildRetryPolicy("Failed to download ${imageDownloadRunnable.imageEntity.url}: "))
+            .with(downloadRunner)
+            .onFailure {
+                log.error(
+                    "Failed to download ${imageDownloadRunnable.imageEntity.url} after ${it.attemptCount} tries",
+                    it.exception
+                )
+                val image = imageDownloadRunnable.imageEntity
+                image.status = Status.ERROR
+                dataTransaction.updateImage(image)
            }
-            Failsafe.with<Any, RetryPolicy<Any>>(retryPolicyService.buildRetryPolicyForDownload())
-                .onFailure {
-                    try {
-                        dataTransaction.saveLog(
-                            LogEntryEntity(
-                                type = LogEntryEntity.Type.DOWNLOAD,
-                                status = LogEntryEntity.Status.ERROR,
-                                message = "Failed to download ${imageDownloadRunnable.context.imageEntity.url}\n ${it.failure.formatToString()}"
-                            )
+            .onComplete {
+                afterJobFinish(imageDownloadRunnable)
+                eventBus.publishEvent(
+                    QueueStateEvent(
+                        QueueState(
+                            runningCount(), pendingCount()
                        )
-                    } catch (exp: Exception) {
-                        log.error("Failed to save event", exp)
-                    }
-                    log.error(
-                        "Failed to download ${imageDownloadRunnable.context.imageEntity.url} after ${it.attemptCount} tries",
-                        it.failure
                    )
-                    val image = imageDownloadRunnable.context.imageEntity
-                    image.status = Status.ERROR
-                    dataTransaction.updateImage(image)
-                }.onComplete {
-                    afterJobFinish(imageDownloadRunnable)
-                    coroutineScope.launch {
-                        eventBus.publishEvent(
-                            QueueStateEvent(
-                                QueueState(
-                                    runningCount(), pendingCount()
-                                )
-                            )
-                        )
-                    }
-                    coroutineScope.launch {
-                        eventBus.publishEvent(ErrorCountEvent(ErrorCount(dataTransaction.countImagesInError())))
-                    }
-                    log.debug(
-                        "Finished downloading ${imageDownloadRunnable.context.imageEntity.url}"
-                    )
-                }.run(imageDownloadRunnable::run)
-        }, GLOBAL_EXECUTOR)
+                )
+                eventBus.publishEvent(ErrorCountEvent(ErrorCount(dataTransaction.countImagesInError())))
+                log.debug(
+                    "Finished downloading ${imageDownloadRunnable.imageEntity.url}"
+                )
+            }.runAsync(imageDownloadRunnable)
    }

    private fun afterJobFinish(imageDownloadRunnable: ImageDownloadRunnable) {
        lock.withLock {
-            val image = imageDownloadRunnable.context.imageEntity
+            val image = imageDownloadRunnable.imageEntity
            running[image.host]!!.remove(imageDownloadRunnable)
            if (!isPending(image.postId) && !isRunning(
                    image.postId
-                ) && !imageDownloadRunnable.context.stopped
+                ) && !imageDownloadRunnable.stopped
            ) {
                dataTransaction.finishPost(image.postId, true)
            }
@@ -1,5 +1,6 @@
 package me.vripper.download

+import kotlinx.coroutines.*
 import me.vripper.entities.ImageEntity
 import me.vripper.model.Settings
 import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase
@@ -7,11 +8,22 @@ import org.apache.hc.client5.http.cookie.BasicCookieStore
 import org.apache.hc.client5.http.protocol.HttpClientContext
 import org.koin.core.component.KoinComponent

-class ImageDownloadContext(val imageEntity: ImageEntity, val settings: Settings) : KoinComponent {
-
+internal class ImageDownloadContext(val imageEntity: ImageEntity, val settings: Settings) : KoinComponent {
+    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private val jobs = mutableListOf<Job>()
    val httpContext: HttpClientContext =
        HttpClientContext.create().apply { cookieStore = BasicCookieStore() }
    val requests = mutableListOf<HttpUriRequestBase>()
    val postId = imageEntity.postIdRef
-    var stopped = false
+
+    fun cancelCoroutines() {
+        runBlocking {
+            coroutineScope.cancel()
+            jobs.forEach { job -> job.cancelAndJoin() }
+        }
+    }
+
+    fun launchCoroutine(block: suspend CoroutineScope.() -> Unit): Job {
+        return coroutineScope.launch(block = block).also { job -> jobs.add(job) }
+    }
 }
@@ -1,19 +1,20 @@
 package me.vripper.download

-import kotlinx.coroutines.*
+import dev.failsafe.function.CheckedRunnable
 import me.vripper.entities.ImageEntity
-import me.vripper.entities.domain.Status
+import me.vripper.entities.Status
 import me.vripper.exception.DownloadException
 import me.vripper.exception.HostException
 import me.vripper.host.DownloadedImage
 import me.vripper.host.Host
 import me.vripper.host.ImageMimeType
 import me.vripper.model.Settings
-import me.vripper.services.*
+import me.vripper.services.DataTransaction
+import me.vripper.services.VGAuthService
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.PathUtils.getExtension
 import me.vripper.utilities.PathUtils.getFileNameWithoutExtension
 import me.vripper.utilities.PathUtils.sanitize
-import net.jodah.failsafe.function.CheckedRunnable
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
 import java.io.IOException
@@ -24,32 +25,29 @@ import java.util.*
 import kotlin.io.path.Path
 import kotlin.io.path.pathString

-class ImageDownloadRunnable(
-    private val imageEntity: ImageEntity, val postRank: Int, private val settings: Settings
+internal class ImageDownloadRunnable(
+    val imageEntity: ImageEntity, val postRank: Int, private val settings: Settings
 ) : KoinComponent, CheckedRunnable {
-    private val log by me.vripper.delegate.LoggerDelegate()
-
+    private val log by LoggerDelegate()
    private val dataTransaction: DataTransaction by inject()
+    private val vgauthService: VGAuthService by inject()
    private val hosts: List<Host> = getKoin().getAll()
+    var completed = false
+    var stopped = false

-    val context: ImageDownloadContext = ImageDownloadContext(imageEntity, settings)
-    private var stopped: Boolean
-        get() = context.stopped
-        set(value) {
-            context.stopped = value
-        }
+    private lateinit var context: ImageDownloadContext

-    @Throws(DownloadException::class)
    fun download() {
        try {
            imageEntity.status = Status.DOWNLOADING
            imageEntity.downloaded = 0
            dataTransaction.updateImage(imageEntity)
            synchronized(imageEntity.postId.toString().intern()) {
-                val post = dataTransaction.findPostById(context.postId).orElseThrow()
+                val post = dataTransaction.findPostById(context.postId)
                if (post.status != Status.DOWNLOADING) {
                    post.status = Status.DOWNLOADING
                    dataTransaction.updatePost(post)
+                    vgauthService.leaveThanks(post)
                }
            }
            log.debug("Getting image url and name from ${imageEntity.url} using ${imageEntity.host}")
@@ -58,7 +56,7 @@ class ImageDownloadRunnable(
            log.debug("Resolved name for ${imageEntity.url}: ${downloadedImage.name}")
            log.debug("Downloaded image {} to {}", imageEntity.url, downloadedImage.path)
            synchronized(imageEntity.postId.toString().intern()) {
-                val post = dataTransaction.findPostById(context.postId).orElseThrow()
+                val post = dataTransaction.findPostById(context.postId)
                val downloadDirectory = Path(post.downloadDirectory, post.folderName).pathString
                checkImageTypeAndRename(
                    downloadDirectory, downloadedImage, imageEntity.index
@@ -123,12 +121,24 @@ class ImageDownloadRunnable(
        }
    }

-    @Throws(Exception::class)
    override fun run() {
-        if (stopped) {
-            return
+        context = ImageDownloadContext(imageEntity, settings)
+        try {
+            if (stopped) {
+                return
+            }
+            download()
+        } finally {
+            completed = true
+            context.cancelCoroutines()
        }
-        download()
+    }
+
+    fun stop() {
+        stopped = true
+        context.requests.forEach { it.abort() }
+        context.cancelCoroutines()
+        dataTransaction.updateImage(context.imageEntity)
    }

    override fun equals(other: Any?): Boolean {
@@ -141,9 +151,4 @@ class ImageDownloadRunnable(
    override fun hashCode(): Int {
        return Objects.hash(imageEntity.id)
    }
-
-    fun stop() {
-        context.requests.forEach { it.abort() }
-        stopped = true
-    }
 }
@@ -1,7 +1,8 @@
 package me.vripper.entities

-import me.vripper.entities.domain.Status
+import kotlinx.serialization.Serializable

+@Serializable
 data class ImageEntity(
    val id: Long = -1,
    val postId: Long,
@@ -1,22 +1,14 @@
 package me.vripper.entities

-import java.time.LocalDateTime
+import kotlinx.serialization.Serializable

+@Serializable
 data class LogEntryEntity(
-    val id: Long = -1,
-    val type: Type,
-    val status: Status,
-    val time: LocalDateTime = LocalDateTime.now(),
-    val message: String,
-) {
-
-    enum class Type(val stringValue: String) {
-        POST("Post"), THREAD("Thread"), THANKS("Thanks"), METADATA("Metadata"), SCAN("Scan"), DOWNLOAD(
-            "Download"
-        )
-    }
-
-    enum class Status(val stringValue: String) {
-        PENDING("Pending"), PROCESSING("Processing"), DONE("Done"), ERROR("Error")
-    }
-}
+    val sequence: Long,
+    val timestamp: String,
+    val threadName: String,
+    val loggerName: String,
+    val levelString: String,
+    val formattedMessage: String,
+    val throwable: String,
+)
@@ -2,6 +2,7 @@ package me.vripper.entities

 import kotlinx.serialization.Serializable

+@Serializable
 data class MetadataEntity(val postId: Long, val data: Data) {
    @Serializable
    data class Data(
@@ -1,8 +1,10 @@
 package me.vripper.entities

-import me.vripper.entities.domain.Status
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
 import java.time.LocalDateTime

+@Serializable
 data class PostEntity(
    val id: Long = -1,
    val postTitle: String,
@@ -15,7 +17,7 @@ data class PostEntity(
    val total: Int,
    val hosts: Set<String>,
    val downloadDirectory: String,
-    val addedOn: LocalDateTime = LocalDateTime.now(),
+    @Contextual val addedOn: LocalDateTime = LocalDateTime.now(),
    var folderName: String,
    var status: Status = Status.STOPPED,
    var done: Int = 0,
@@ -1,4 +1,4 @@
-package me.vripper.entities.domain
+package me.vripper.entities

 enum class Status(val stringValue: String) {
    PENDING("Pending"), DOWNLOADING("Downloading"), FINISHED("Finished"), ERROR("Error"), STOPPED("Stopped")
@@ -1,5 +1,8 @@
 package me.vripper.entities

+import kotlinx.serialization.Serializable
+
+@Serializable
 data class ThreadEntity(
    val id: Long = -1,
    val title: String,
@@ -21,7 +21,5 @@ data class ErrorCountEvent(val errorCount: ErrorCount)
 data class SettingsUpdateEvent(val settings: Settings)
 data class MetadataUpdateEvent(val metadataEntity: MetadataEntity)
 data class LogCreateEvent(val logEntryEntity: LogEntryEntity)
-data class LogUpdateEvent(val logEntryEntity: LogEntryEntity)
-data class LogDeleteEvent(val deleted: List<Long>)
 data class LoadingTasks(val loading: Boolean)
 data class StoppedEvent(val postIds: List<Long>)
@@ -1,14 +1,15 @@
 package me.vripper.event

+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow

 object EventBus {

-    private val _events = MutableSharedFlow<Any>()
+    private val _events = MutableSharedFlow<Any>(0, Int.MAX_VALUE, BufferOverflow.DROP_OLDEST)
    val events = _events.asSharedFlow()

-    suspend fun publishEvent(event: Any) {
-        _events.emit(event)
+    fun publishEvent(event: Any) {
+        _events.tryEmit(event)
    }
 }
@@ -3,8 +3,11 @@ package me.vripper.host
 import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
-import me.vripper.services.*
+import me.vripper.services.DataTransaction
+import me.vripper.services.DownloadSpeedService
+import me.vripper.services.HTTPService
 import me.vripper.utilities.HtmlUtils
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.apache.hc.client5.http.classic.methods.HttpPost
 import org.apache.hc.client5.http.entity.UrlEncodedFormEntity
@@ -12,12 +15,12 @@ import org.apache.hc.core5.http.message.BasicNameValuePair
 import org.w3c.dom.Document
 import org.w3c.dom.Node

-class AcidimgHost(
+internal class AcidimgHost(
    private val httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("acidimg.cc", 0, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -45,7 +48,7 @@ class AcidimgHost(
                )
            )
        }.also { context.requests.add(it) }
-        log.debug(String.format("Requesting %s", httpPost))
+        log.debug(String.format("Requesting %s", httpPost.uri))
        val doc = try {
            httpService.client.execute(
                httpPost, context.httpContext
@@ -4,17 +4,18 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node
 import java.util.*

-class DPicMeHost(
+internal class DPicMeHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("dpic.me", 1, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -1,10 +1,17 @@
 package me.vripper.host

+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.runBlocking
 import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.DownloadException
 import me.vripper.exception.HostException
-import me.vripper.services.*
+import me.vripper.services.DataTransaction
+import me.vripper.services.DownloadSpeedService
+import me.vripper.services.HTTPService
 import me.vripper.utilities.HtmlUtils
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.PathUtils.getFileNameWithoutExtension
 import org.apache.hc.client5.http.classic.methods.HttpGet
 import org.apache.hc.client5.http.classic.methods.HttpHead
@@ -12,17 +19,19 @@ import org.apache.hc.core5.http.ClassicHttpResponse
 import org.apache.hc.core5.http.Header
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.w3c.dom.Document
+import java.io.BufferedOutputStream
 import java.nio.file.Files
 import java.nio.file.Path
+import kotlin.Throws

-abstract class Host(
+internal abstract class Host(
    val hostName: String,
    val hostId: Byte,
    private val httpService: HTTPService,
    private val dataTransaction: DataTransaction,
    private val downloadSpeedService: DownloadSpeedService
 ) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    companion object {
        private const val READ_BUFFER_SIZE = 8192
@@ -94,10 +103,10 @@ abstract class Host(
            "vripper_",
            ".tmp"
        )
-        return Files.newOutputStream(tempImage).use { fos ->
+        return BufferedOutputStream(Files.newOutputStream(tempImage)).use { bos ->
            val image = context.imageEntity
            synchronized(image.postId.toString().intern()) {
-                val post = dataTransaction.findPostById(context.postId).orElseThrow()
+                val post = dataTransaction.findPostById(context.postId)
                val size = if (image.size < 0) {
                    response.entity.contentLength
                } else {
@@ -118,14 +127,23 @@ abstract class Host(
            )
            val buffer = ByteArray(READ_BUFFER_SIZE)
            var read: Int
-            while (response.entity.content.read(buffer, 0, READ_BUFFER_SIZE)
-                    .also { read = it } != -1 && !context.stopped
+            val reporterJob = context.launchCoroutine {
+                while (isActive) {
+                    dataTransaction.updateImage(image, false)
+                    delay(100)
+                }
+            }
+            while (response.entity.content.read(buffer)
+                    .also { read = it } != -1
            ) {
-                fos.write(buffer, 0, read)
+                bos.write(buffer, 0, read)
                image.downloaded += read
-                dataTransaction.updateImage(image)
                downloadSpeedService.reportDownloadedBytes(read.toLong())
            }
+            runBlocking {
+                reporterJob.cancelAndJoin()
+            }
+            dataTransaction.updateImage(image)
            Pair(tempImage, mimeType)
        }
    }
@@ -5,6 +5,7 @@ import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
 import me.vripper.utilities.HtmlUtils
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.apache.hc.client5.http.impl.cookie.BasicClientCookie
 import org.w3c.dom.Document
@@ -14,12 +15,12 @@ import java.time.LocalDateTime
 import java.time.ZoneId
 import java.util.*

-class ImageBamHost(
+internal class ImageBamHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("imagebam.com", 2, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,17 +4,18 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node
 import java.util.*

-class ImageTwistHost(
+internal class ImageTwistHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("imagetwist.com", 3, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -5,16 +5,17 @@ import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
 import me.vripper.utilities.HtmlUtils
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node

-class ImageVenueHost(
+internal class ImageVenueHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("imagevenue.com", 4, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,15 +4,16 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document

-class ImageZillaHost(
+internal class ImageZillaHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("imagezilla.net", 5, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,16 +4,17 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node

-class ImgSpiceHost(
+internal class ImgSpiceHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("imgspice.com", 7, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,16 +4,17 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node

-class ImgboxHost(
+internal class ImgboxHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("imgbox.com", 6, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -6,6 +6,7 @@ import me.vripper.exception.HtmlProcessorException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
 import me.vripper.utilities.HtmlUtils
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.apache.hc.client5.http.classic.methods.HttpPost
 import org.apache.hc.client5.http.entity.UrlEncodedFormEntity
@@ -14,12 +15,12 @@ import org.w3c.dom.Document
 import org.w3c.dom.Node
 import java.io.IOException

-class ImxHost(
+internal class ImxHost(
    private val httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("imx.to", 8, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -5,18 +5,19 @@ import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
 import me.vripper.utilities.HtmlUtils
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node
 import java.net.URI
 import java.net.URISyntaxException

-class PimpandhostHost(
+internal class PimpandhostHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("pimpandhost.com", 9, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,16 +4,17 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node

-class PixRouteHost(
+internal class PixRouteHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("pixroute.com", 11, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,16 +4,17 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node

-class PixhostHost(
+internal class PixhostHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("pixhost.to", 10, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,15 +4,16 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document

-class PixxxelsHost(
+internal class PixxxelsHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("pixxxels.cc", 12, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,17 +4,18 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node
 import java.util.*

-class PostImgHost(
+internal class PostImgHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("postimg.cc", 13, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,16 +4,17 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node

-class TurboImageHost(
+internal class TurboImageHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("turboimagehost.com", 14, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -4,17 +4,18 @@ import me.vripper.download.ImageDownloadContext
 import me.vripper.exception.HostException
 import me.vripper.exception.XpathException
 import me.vripper.services.*
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.XpathUtils
 import org.w3c.dom.Document
 import org.w3c.dom.Node
 import java.util.*

-class ViprImHost(
+internal class ViprImHost(
    httpService: HTTPService,
    dataTransaction: DataTransaction,
    downloadSpeedService: DownloadSpeedService,
 ) : Host("vipr.im", 15, httpService, dataTransaction, downloadSpeedService) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()

    @Throws(HostException::class)
    override fun resolve(
@@ -11,6 +11,7 @@ open class OnStartupListener : KoinComponent {

    open fun run() {
        dataTransaction.setDownloadingToStopped()
+        dataTransaction.stopImagesByPostIdAndIsNotCompleted()
        metadataService.init()
    }
 }
@@ -1,3 +1,6 @@
 package me.vripper.model

+import kotlinx.serialization.Serializable
+
+@Serializable
 data class DownloadSpeed(val speed: Long)
@@ -1,3 +1,6 @@
 package me.vripper.model

+import kotlinx.serialization.Serializable
+
+@Serializable
 data class ErrorCount(val count: Int)
@@ -1,10 +1,13 @@
 package me.vripper.model

-import me.vripper.entities.domain.Status
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
+import me.vripper.entities.Status
 import java.time.LocalDateTime
 import kotlin.io.path.Path
 import kotlin.io.path.pathString

+@Serializable
 data class Post(
    val id: Long = -1,
    val postTitle: String,
@@ -17,7 +20,7 @@ data class Post(
    val total: Int,
    val hosts: Set<String>,
    val downloadDirectory: String,
-    val addedOn: LocalDateTime = LocalDateTime.now(),
+    @Contextual val addedOn: LocalDateTime = LocalDateTime.now(),
    var folderName: String,
    var status: Status = Status.STOPPED,
    var done: Int = 0,
@@ -28,7 +31,5 @@ data class Post(
    val postedBy: String,
    val resolvedNames: List<String>
 ) {
-    fun getDownloadFolder(): String {
-        return Path(downloadDirectory, folderName).pathString
-    }
+    fun getDownloadFolder() = Path(downloadDirectory, folderName).pathString
 }
@@ -1,5 +1,8 @@
 package me.vripper.model

+import kotlinx.serialization.Serializable
+
+@Serializable
 data class QueueState(
    val running: Int,
    val remaining: Int
@@ -1,6 +1,9 @@
 package me.vripper.model

 import kotlinx.serialization.Serializable
+import me.vripper.utilities.ApplicationProperties.VRIPPER_DIR
+import java.nio.file.Files
+import kotlin.io.path.pathString

@Serializable
 data class Settings(
@@ -17,11 +20,13 @@ data class ViperSettings(
    val password: String = "",
    val thanks: Boolean = false,
    val host: String = "https://vipergirls.to",
+    val requestLimit: Long = 4,
+    val fetchMetadata: Boolean = false,
 )

@Serializable
 data class DownloadSettings(
-    val downloadPath: String = System.getProperty("user.home"),
+    val downloadPath: String = VRIPPER_DIR.resolve("downloads").also { Files.createDirectories(it) }.pathString,
    val autoStart: Boolean = true,
    val autoQueueThreshold: Int = 1,
    val forceOrder: Boolean = false,
@@ -41,7 +46,7 @@ data class ConnectionSettings(

@Serializable
 data class SystemSettings(
-    val tempPath: String = System.getProperty("java.io.tmpdir"),
+    val tempPath: String = VRIPPER_DIR.resolve("temp").also { Files.createDirectories(it) }.pathString,
    val enableClipboardMonitoring: Boolean = false,
    val clipboardPollingRate: Int = 500,
    val maxEventLog: Int = 1_000,
@@ -1,5 +0,0 @@
-package me.vripper.parser
-
-import me.vripper.host.Host
-
-data class ImageItem(val mainLink: String, val thumbLink: String, val host: Host)
@@ -1,14 +0,0 @@
-package me.vripper.repositories
-
-import me.vripper.entities.LogEntryEntity
-import java.util.*
-
-interface LogRepository {
-    fun save(logEntryEntity: LogEntryEntity): LogEntryEntity
-    fun update(logEntryEntity: LogEntryEntity)
-    fun findAll(): List<LogEntryEntity>
-    fun findById(id: Long): Optional<LogEntryEntity>
-
-    fun deleteOldest(): List<Long>
-    fun deleteAll()
-}
@@ -1,74 +0,0 @@
-package me.vripper.repositories.impl
-
-import me.vripper.entities.LogEntryEntity
-import me.vripper.repositories.LogRepository
-import me.vripper.services.SettingsService
-import me.vripper.tables.LogTable
-import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.notInSubQuery
-import java.util.*
-
-class LogRepositoryImpl(val settingsService: SettingsService) : LogRepository {
-
-    @Synchronized
-    override fun save(logEntryEntity: LogEntryEntity): LogEntryEntity {
-        val id = LogTable.insertAndGetId {
-            it[type] = logEntryEntity.type.name
-            it[status] = logEntryEntity.status.name
-            it[time] = logEntryEntity.time
-            it[message] = logEntryEntity.message.take(500)
-        }.value
-        return logEntryEntity.copy(id = id)
-    }
-
-    override fun update(logEntryEntity: LogEntryEntity) {
-        LogTable.update({ LogTable.id eq logEntryEntity.id }) {
-            it[type] = logEntryEntity.type.name
-            it[status] = logEntryEntity.status.name
-            it[message] = logEntryEntity.message.take(500)
-        }
-    }
-
-    override fun findById(id: Long): Optional<LogEntryEntity> {
-        val result = LogTable.select {
-            LogTable.id eq id
-        }.map(::transform)
-
-        return if (result.isEmpty()) {
-            Optional.empty()
-        } else {
-            Optional.of(result.first())
-        }
-    }
-
-    override fun findAll(): List<LogEntryEntity> {
-        return LogTable.selectAll().map(::transform)
-    }
-
-    override fun deleteOldest(): List<Long> {
-        val sub = LogTable.slice(LogTable.id).selectAll().orderBy(LogTable.time to SortOrder.DESC)
-            .limit(settingsService.settings.systemSettings.maxEventLog)
-        val ids = LogTable.select { LogTable.id notInSubQuery sub }.map { it[LogTable.id].value }
-        LogTable.deleteWhere { LogTable.id notInSubQuery sub }
-        return ids
-    }
-
-    override fun deleteAll() {
-        LogTable.deleteAll()
-    }
-
-    private fun transform(resultRow: ResultRow): LogEntryEntity {
-        val id = resultRow[LogTable.id].value
-        val type = LogEntryEntity.Type.valueOf(resultRow[LogTable.type])
-        val status = LogEntryEntity.Status.valueOf(resultRow[LogTable.status])
-        val time = resultRow[LogTable.time]
-        val message = resultRow[LogTable.message]
-        return LogEntryEntity(
-            id,
-            type,
-            status,
-            time,
-            message
-        )
-    }
-}
@@ -2,19 +2,22 @@ package me.vripper.services

 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.time.sample
+import kotlinx.serialization.json.Json
 import me.vripper.download.DownloadService
-import me.vripper.entities.LogEntryEntity
-import me.vripper.entities.PostEntity
+import me.vripper.entities.*
 import me.vripper.event.*
 import me.vripper.exception.PostParseException
 import me.vripper.model.*
-import me.vripper.tasks.AddPostRunnable
-import me.vripper.tasks.ThreadLookupRunnable
+import me.vripper.tasks.AddPostTask
+import me.vripper.tasks.ThreadLookupTask
 import me.vripper.utilities.ApplicationProperties
-import me.vripper.utilities.GLOBAL_EXECUTOR
+import me.vripper.utilities.ApplicationProperties.VRIPPER_DIR
+import me.vripper.utilities.LoggerDelegate
 import me.vripper.utilities.PathUtils
+import me.vripper.utilities.taskRunner
+import org.h2.jdbc.JdbcSQLNonTransientConnectionException
+import java.sql.DriverManager
 import java.time.Duration
-import java.util.concurrent.CompletableFuture
 import java.util.concurrent.locks.ReentrantLock
 import java.util.regex.Pattern
 import kotlin.concurrent.withLock
@@ -22,15 +25,16 @@ import kotlin.io.path.Path
 import kotlin.io.path.exists
 import kotlin.jvm.optionals.getOrNull

-class AppEndpointService(
+internal class AppEndpointService(
    private val downloadService: DownloadService,
    private val dataTransaction: DataTransaction,
    private val threadCacheService: ThreadCacheService,
    private val settingsService: SettingsService,
    private val vgAuthService: VGAuthService,
+    private val logService: LogService,
 ) : IAppEndpointService {
-    private val log by me.vripper.delegate.LoggerDelegate()

+    private val log by LoggerDelegate()
    private val lock = ReentrantLock()

    override suspend fun scanLinks(postLinks: String) {
@@ -38,10 +42,10 @@ class AppEndpointService(
            if (postLinks.isBlank()) {
                return
            }
-            val urlList = postLinks.split(Pattern.compile("\\r?\\n")).dropLastWhile { it.isEmpty() }.map { it.trim() }
+            val urlList = postLinks.split(Pattern.compile("\\r?\\n")).dropLastWhile { it.isBlank() }.map { it.trim() }
                .filter { it.isNotEmpty() }
            for (link in urlList) {
-                log.debug("Starting to process thread: $link")
+                log.debug("Scanning: $link")
                if (!link.startsWith(settingsService.settings.viperSettings.host)) {
                    continue
                }
@@ -54,27 +58,20 @@ class AppEndpointService(
                    threadId = m.group(1).toLong()
                    postId = m.group(4)?.toLong()
                    if (postId == null) {
-                        CompletableFuture.runAsync(
-                            ThreadLookupRunnable(
+                        taskRunner.submit(
+                            ThreadLookupTask(
                                threadId, settingsService.settings
-                            ), GLOBAL_EXECUTOR
+                            )
                        )
                    } else {
-                        CompletableFuture.runAsync(
-                            AddPostRunnable(
+                        taskRunner.submit(
+                            AddPostTask(
                                listOf(ThreadPostId(threadId, postId))
-                            ), GLOBAL_EXECUTOR
+                            )
                        )
                    }
                } else {
-                    log.error("Cannot retrieve thread id from URL $link")
-                    dataTransaction.saveLog(
-                        LogEntryEntity(
-                            type = LogEntryEntity.Type.SCAN,
-                            status = LogEntryEntity.Status.ERROR,
-                            message = "Invalid link $link, link is missing the threadId"
-                        )
-                    )
+                    log.error("Invalid link $link, link is missing the threadId")
                    continue
                }
            }
@@ -83,15 +80,13 @@ class AppEndpointService(

    override suspend fun restartAll(posIds: List<Long>) {
        lock.withLock {
-            downloadService.restartAll(posIds.map { dataTransaction.findPostByPostId(it) }.filter { it.isPresent }
-                .map { it.get() })
+            downloadService.restartAll(posIds.filter { dataTransaction.exists(it) }
+                .map { dataTransaction.findPostByPostId(it) })
        }
    }

    override suspend fun download(posts: List<ThreadPostId>) {
-        CompletableFuture.runAsync(
-            AddPostRunnable(posts), GLOBAL_EXECUTOR
-        )
+        taskRunner.submit(AddPostTask(posts))
    }

    override suspend fun stopAll(postIdList: List<Long>) {
@@ -172,12 +167,6 @@ class AppEndpointService(
        }
    }

-    override suspend fun logClear() {
-        lock.withLock {
-            dataTransaction.deleteAllLogs()
-        }
-    }
-
    override suspend fun renameToFirst(postIds: List<Long>) {
        postIds.forEach { postId ->
            dataTransaction
@@ -188,20 +177,29 @@ class AppEndpointService(
        }
    }

+    override fun ready(): Boolean {
+        return true
+    }
+
    override suspend fun rename(postId: Long, newName: String) {
-        CompletableFuture.runAsync({
+        taskRunner.submit {
            synchronized(postId.toString().intern()) {
-                dataTransaction.findPostByPostId(postId).ifPresent { post ->
-                    if (Path(post.downloadDirectory, post.folderName).exists()) {
-                        PathUtils.rename(
-                            dataTransaction.findImagesByPostId(postId), post.downloadDirectory, post.folderName, newName
-                        )
+                if (dataTransaction.exists(postId)) {
+                    dataTransaction.findPostByPostId(postId).let { post ->
+                        if (Path(post.downloadDirectory, post.folderName).exists()) {
+                            PathUtils.rename(
+                                dataTransaction.findImagesByPostId(postId),
+                                post.downloadDirectory,
+                                post.folderName,
+                                newName
+                            )
+                        }
+                        post.folderName = PathUtils.sanitize(newName)
+                        dataTransaction.updatePost(post)
                    }
-                    post.folderName = PathUtils.sanitize(newName)
-                    dataTransaction.updatePost(post)
                }
            }
-        }, GLOBAL_EXECUTOR)
+        }
    }

    override fun onNewPosts(): Flow<Post> =
@@ -255,38 +253,27 @@ class AppEndpointService(
    }

    override suspend fun findPost(postId: Long): Post {
-        return mapper(dataTransaction.findPostByPostId(postId).orElseThrow())
+        return mapper(dataTransaction.findPostByPostId(postId))
    }

    override suspend fun findImagesByPostId(postId: Long): List<Image> {
        return dataTransaction.findImagesByPostId(postId)
    }

-    override fun onUpdateImages(postId: Long): Flow<Image> = EventBus.events.filterIsInstance(ImageEvent::class).map {
-        it.imageEntities.filter { imageEntity: Image -> imageEntity.postId == postId }
-    }.filter { it.isNotEmpty() }.flatMapConcat { it.asFlow() }
+    override fun onUpdateImagesByPostId(postId: Long): Flow<Image> =
+        EventBus.events.filterIsInstance(ImageEvent::class).map {
+            it.imageEntities.filter { imageEntity: Image -> imageEntity.postId == postId }
+        }.filter { it.isNotEmpty() }.flatMapConcat { it.asFlow() }

+    override fun onUpdateImages(): Flow<Image> =
+        EventBus.events.filterIsInstance(ImageEvent::class).flatMapConcat { it.imageEntities.asFlow() }

    override fun onStopped(): Flow<Long> =
        EventBus.events.filterIsInstance(StoppedEvent::class).flatMapConcat { it.postIds.asFlow() }

-
-    override suspend fun findAllLogs(): List<LogEntry> {
-        return dataTransaction.findAllLogs()
-    }
-
    override fun onNewLog() = EventBus.events.filterIsInstance(LogCreateEvent::class).map { it.logEntryEntity }

-
-    override fun onUpdateLog() = EventBus.events.filterIsInstance(LogUpdateEvent::class).map {
-        it.logEntryEntity
-    }
-
-
-    override fun onDeleteLogs(): Flow<Long> = EventBus.events.filterIsInstance(LogDeleteEvent::class).flatMapConcat {
-        it.deleted.asFlow()
-    }
-
+    override suspend fun initLogger() = logService.init()

    override fun onNewThread(): Flow<Thread> =
        EventBus.events.filterIsInstance(ThreadCreateEvent::class).map { it.threadEntity }
@@ -307,8 +294,8 @@ class AppEndpointService(
        return dataTransaction.findAllThreads()
    }

-    override fun onDownloadSpeed(): Flow<Long> =
-        EventBus.events.filterIsInstance(DownloadSpeedEvent::class).map { it.downloadSpeed.speed }
+    override fun onDownloadSpeed(): Flow<DownloadSpeed> =
+        EventBus.events.filterIsInstance(DownloadSpeedEvent::class).map { it.downloadSpeed }

    override fun onVGUserUpdate(): Flow<String> =
        EventBus.events.filterIsInstance(VGUserLoginEvent::class).map { it.username }
@@ -316,8 +303,8 @@ class AppEndpointService(
    override fun onQueueStateUpdate(): Flow<QueueState> =
        EventBus.events.filterIsInstance(QueueStateEvent::class).map { it.queueState }

-    override fun onErrorCountUpdate(): Flow<Int> =
-        EventBus.events.filterIsInstance(ErrorCountEvent::class).map { it.errorCount.count }
+    override fun onErrorCountUpdate(): Flow<ErrorCount> =
+        EventBus.events.filterIsInstance(ErrorCountEvent::class).map { it.errorCount }

    override fun onTasksRunning(): Flow<Boolean> =
        EventBus.events.filterIsInstance(LoadingTasks::class).sample(Duration.ofMillis(500)).map { it.loading }
@@ -335,4 +322,145 @@ class AppEndpointService(

    override suspend fun getVersion(): String = ApplicationProperties.VERSION

+    override suspend fun dbMigration(): String {
+
+        val conn = try {
+            DriverManager
+                .getConnection("jdbc:h2:file:$VRIPPER_DIR/vripper;DB_CLOSE_DELAY=-1;IFEXISTS=TRUE")
+        } catch (_: JdbcSQLNonTransientConnectionException) {
+            return "Old database not found, nothing to do"
+        }
+
+        var postsCount = 0;
+        var threadCount = 0;
+
+        conn.use { conn ->
+            conn.prepareStatement("select * from post").use {
+                it.executeQuery().use {
+                    while (it.next()) {
+                        val done = it.getInt("DONE")
+                        val hosts = it.getString("HOSTS")
+                        val outputPath = it.getString("OUTPUT_PATH")
+                        val postId = it.getLong("POST_ID")
+                        val status = it.getString("STATUS")
+                        val threadId = it.getLong("THREAD_ID")
+                        val postTitle = it.getString("POST_TITLE")
+                        val threadTitle = it.getString("THREAD_TITLE")
+                        val forum = it.getString("FORUM")
+                        val total = it.getInt("TOTAL")
+                        val size = it.getLong("SIZE")
+                        val downloaded = it.getLong("DOWNLOADED")
+                        val url = it.getString("URL")
+                        val token = it.getString("TOKEN")
+                        val addedAt = it.getTimestamp("ADDED_AT")
+                        val folderName = it.getString("FOLDER_NAME") ?: ""
+
+                        val exists = dataTransaction.exists(postId)
+                        if (exists) {
+                            continue
+                        }
+
+                        val post = PostEntity(
+                            postTitle = postTitle,
+                            threadTitle = threadTitle,
+                            forum = forum,
+                            url = url,
+                            token = token,
+                            postId = postId,
+                            threadId = threadId,
+                            total = total,
+                            hosts = hosts.split(";").dropLastWhile { it.isEmpty() }.toSet(),
+                            downloadDirectory = outputPath,
+                            addedOn = addedAt.toLocalDateTime(),
+                            folderName = folderName,
+                            status = Status.valueOf(status),
+                            done = done,
+                            size = size,
+                            downloaded = downloaded,
+                        )
+
+                        val images = mutableListOf<ImageEntity>()
+
+                        // load images
+                        conn.prepareStatement("select * from image where post_id = ?").use { statement ->
+                            statement.setLong(1, postId)
+                            statement.executeQuery().use { set ->
+                                while (set.next()) {
+                                    val downloaded = set.getLong("DOWNLOADED")
+                                    val host = set.getByte("HOST")
+                                    val index = set.getInt("INDEX")
+                                    val status = Status.valueOf(set.getString("STATUS"))
+                                    val size = set.getLong("SIZE")
+                                    val url = set.getString("URL")
+                                    val thumbUrl = set.getString("THUMB_URL")
+                                    val fileName = set.getString("FILENAME") ?: ""
+
+                                    ImageEntity(
+                                        postId = postId,
+                                        url = url,
+                                        thumbUrl = thumbUrl,
+                                        host = host,
+                                        index = index,
+                                        size = size,
+                                        downloaded = downloaded,
+                                        status = status,
+                                        filename = fileName,
+                                    ).also { images.add(it) }
+                                }
+                            }
+                        }
+
+                        dataTransaction.saveAndNotify(post, images)
+
+                        //load meta
+                        conn.prepareStatement("select * from metadata where post_id = ?").use { statement ->
+                            statement.setLong(1, postId)
+                            statement.executeQuery().use { set ->
+                                if (set.next()) {
+                                    val data = Json.decodeFromString(set.getString("DATA")) as MetadataEntity.Data
+                                    val metadata = MetadataEntity(
+                                        postId = postId,
+                                        data = data
+                                    )
+                                    dataTransaction.saveMetadata(metadata)
+                                }
+                            }
+                        }
+                        postsCount++
+                    }
+                }
+            }
+
+            conn.prepareStatement("select * from thread").use { statement ->
+                statement.executeQuery().use { set ->
+                    while (set.next()) {
+                        val total = set.getInt("TOTAL")
+                        val url = set.getString("URL")
+                        val threadId = set.getLong("THREAD_ID")
+                        val title = set.getString("TITLE")
+
+                        if (dataTransaction.findThreadByThreadId(threadId).isPresent) {
+                            continue
+                        }
+
+                        val threadEntity = ThreadEntity(
+                            title = title,
+                            link = url,
+                            threadId = threadId,
+                            total = total,
+                        )
+
+                        dataTransaction.save(threadEntity)
+                        threadCount++
+                    }
+                }
+            }
+        }
+
+        return if (postsCount == 0 && threadCount == 0) {
+            "Nothing to do, everything was imported"
+        } else {
+            "Successfully imported $postsCount posts and $threadCount threads"
+        }
+    }
 }
@@ -1,89 +1,106 @@
 package me.vripper.services

-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
+import com.github.benmanes.caffeine.cache.Caffeine
+import com.github.benmanes.caffeine.cache.LoadingCache
+import me.vripper.data.repositories.ImageRepository
+import me.vripper.data.repositories.MetadataRepository
+import me.vripper.data.repositories.PostRepository
+import me.vripper.data.repositories.ThreadRepository
 import me.vripper.entities.*
-import me.vripper.entities.domain.Status
 import me.vripper.event.*
 import me.vripper.model.ErrorCount
-import me.vripper.parser.PostItem
-import me.vripper.repositories.*
 import me.vripper.utilities.PathUtils
 import me.vripper.utilities.PathUtils.sanitize
+import me.vripper.vgapi.PostItem
 import org.jetbrains.exposed.sql.transactions.transaction
 import java.util.*
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
 import kotlin.io.path.pathString

-class DataTransaction(
+internal class DataTransaction(
    private val settingsService: SettingsService,
-    private val postDownloadStateRepository: PostDownloadStateRepository,
+    private val postRepository: PostRepository,
    private val imageRepository: ImageRepository,
    private val threadRepository: ThreadRepository,
    private val metadataRepository: MetadataRepository,
-    private val logRepository: LogRepository,
    private val eventBus: EventBus,
 ) {

-    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private val nextRank = AtomicInteger(transaction { getQueuePosition() }?.plus(1) ?: 0)
+    private val postEntityIdCache: LoadingCache<Long, PostEntity> =
+        Caffeine.newBuilder().expireAfterAccess(5, TimeUnit.MINUTES).build { id ->
+            transaction { postRepository.findById(id) }
+        }
+
+    private val postPostIdCache: LoadingCache<Long, PostEntity> =
+        Caffeine.newBuilder().expireAfterAccess(5, TimeUnit.MINUTES).build { id ->
+            transaction { postRepository.findByPostId(id) }
+        }

    private fun save(postEntities: List<PostEntity>): List<PostEntity> {
-        return transaction { postDownloadStateRepository.save(postEntities) }
+        return transaction { postRepository.save(postEntities) }
+    }
+
+    fun saveAndNotify(postEntity: PostEntity, images: List<ImageEntity>) {
+        val savedPost = transaction {
+            val savedPost =
+                postRepository.save(listOf(postEntity.copy(rank = nextRank.andIncrement))).first()
+            save(images.map { it.copy(postIdRef = savedPost.id) })
+            savedPost
+        }
+        eventBus.publishEvent(PostCreateEvent(listOf(savedPost)))
    }

    fun updatePosts(postEntities: List<PostEntity>) {
-        transaction { postDownloadStateRepository.update(postEntities) }
-        coroutineScope.launch {
-            eventBus.publishEvent(PostUpdateEvent(postEntities))
+        transaction { postRepository.update(postEntities) }
+        postEntities.forEach { postEntity ->
+            postPostIdCache.put(postEntity.postId, postEntity)
+            postEntityIdCache.put(postEntity.id, postEntity)
        }
+        eventBus.publishEvent(PostUpdateEvent(postEntities))
    }

    fun updatePost(postEntity: PostEntity) {
-        transaction { postDownloadStateRepository.update(postEntity) }
-        coroutineScope.launch {
-            eventBus.publishEvent(PostUpdateEvent(listOf(postEntity)))
-        }
+        transaction { postRepository.update(postEntity) }
+        postPostIdCache.put(postEntity.postId, postEntity)
+        postEntityIdCache.put(postEntity.id, postEntity)
+        eventBus.publishEvent(PostUpdateEvent(listOf(postEntity)))
    }

    fun save(threadEntity: ThreadEntity) {
        val savedThread = transaction { threadRepository.save(threadEntity) }
-        coroutineScope.launch {
-            eventBus.publishEvent(ThreadCreateEvent(savedThread))
-        }
+        eventBus.publishEvent(ThreadCreateEvent(savedThread))
    }

    fun update(threadEntity: ThreadEntity) {
        transaction { threadRepository.update(threadEntity) }
-        coroutineScope.launch {
-            eventBus.publishEvent(ThreadUpdateEvent(threadEntity))
-        }
+        eventBus.publishEvent(ThreadUpdateEvent(threadEntity))
    }

    fun updateImages(imageEntities: List<ImageEntity>) {
        transaction { imageRepository.update(imageEntities) }
-        coroutineScope.launch {
-            eventBus.publishEvent(ImageEvent(imageEntities))
-        }
+        eventBus.publishEvent(ImageEvent(imageEntities))
    }

-    fun updateImage(imageEntity: ImageEntity) {
-        transaction { imageRepository.update(imageEntity) }
-        coroutineScope.launch {
-            eventBus.publishEvent(ImageEvent(listOf(imageEntity)))
+    fun updateImage(imageEntity: ImageEntity, persist: Boolean = true) {
+        if (persist) {
+            transaction {
+                imageRepository.update(imageEntity)
+            }
        }
+        eventBus.publishEvent(ImageEvent(listOf(imageEntity)))
    }

    fun exists(postId: Long): Boolean {
-        return transaction { postDownloadStateRepository.existByPostId(postId) }
+        if (postPostIdCache.getIfPresent(postId) != null) {
+            return true
+        }
+        return transaction { postRepository.existByPostId(postId) }
    }

    @Synchronized
    fun newPosts(postItems: List<PostItem>): List<PostEntity> {
-        var queuePosition = transaction {
-            getQueuePosition()?.plus(1) ?: 0
-        }
-
        val posts = postItems.associate { postItem ->
            val postEntity = PostEntity(
                postTitle = postItem.title,
@@ -95,7 +112,7 @@ class DataTransaction(
                hosts = postItem.hosts.map { "${it.first} (${it.second})" }.toSet(),
                threadTitle = postItem.threadTitle,
                forum = postItem.forum,
-                rank = queuePosition++,
+                rank = nextRank.andIncrement,
                downloadDirectory = PathUtils.calculateDownloadPath(
                    postItem.forum,
                    postItem.threadTitle,
@@ -127,14 +144,12 @@ class DataTransaction(
            }
            savedPosts
        }
-        coroutineScope.launch {
-            eventBus.publishEvent(PostCreateEvent(savedPosts))
-        }
+        eventBus.publishEvent(PostCreateEvent(savedPosts))
        return savedPosts
    }

    private fun getQueuePosition(): Int? {
-        return postDownloadStateRepository.findMaxRank()
+        return postRepository.findMaxRank()
    }

    private fun save(imageEntities: List<ImageEntity>) {
@@ -142,7 +157,7 @@ class DataTransaction(
    }

    fun finishPost(postId: Long, automatic: Boolean = false) {
-        val post = findPostByPostId(postId).orElseThrow()
+        val post = findPostByPostId(postId)
        val imagesInErrorStatus = findByPostIdAndIsError(post.postId)
        if (imagesInErrorStatus.isNotEmpty()) {
            post.status = Status.ERROR
@@ -173,27 +188,24 @@ class DataTransaction(
        transaction {
            metadataRepository.deleteAllByPostId(postIds)
            imageRepository.deleteAllByPostId(postIds)
-            postDownloadStateRepository.deleteAll(postIds)
+            postRepository.deleteAll(postIds)
            sortPostsByRank()
        }
-
-        coroutineScope.launch {
-            eventBus.publishEvent(PostDeleteEvent(postIds = postIds))
-        }
-        coroutineScope.launch {
-            eventBus.publishEvent(ErrorCountEvent(ErrorCount(countImagesInError())))
+        postIds.forEach { postId ->
+            postPostIdCache.get(postId)?.let { postEntityIdCache.invalidate(it.id) }
+            postPostIdCache.invalidate(postId)
        }
+        eventBus.publishEvent(PostDeleteEvent(postIds = postIds))
+        eventBus.publishEvent(ErrorCountEvent(ErrorCount(countImagesInError())))
    }

    fun removeThread(threadId: Long) {
        transaction { threadRepository.deleteByThreadId(threadId) }
-        coroutineScope.launch {
-            eventBus.publishEvent(ThreadDeleteEvent(threadId))
-        }
+        eventBus.publishEvent(ThreadDeleteEvent(threadId))
    }

    fun clearCompleted(): List<Long> {
-        val completed = transaction { postDownloadStateRepository.findCompleted() }
+        val completed = transaction { postRepository.findCompleted() }
        remove(completed)
        return completed
    }
@@ -210,39 +222,43 @@ class DataTransaction(
        transaction { imageRepository.stopByPostIdAndIsNotCompleted(postId) }
    }

+    fun stopImagesByPostIdAndIsNotCompleted() {
+        transaction { imageRepository.stopByPostIdAndIsNotCompleted() }
+    }
+
    fun saveMetadata(metadataEntity: MetadataEntity) {
        transaction { metadataRepository.save(metadataEntity) }
-        coroutineScope.launch {
-            eventBus.publishEvent(MetadataUpdateEvent(metadataEntity))
-        }
+        eventBus.publishEvent(MetadataUpdateEvent(metadataEntity))
    }

    fun clearQueueLinks() {
        transaction { threadRepository.deleteAll() }
-        coroutineScope.launch {
-            eventBus.publishEvent(ThreadClearEvent())
-        }
+        eventBus.publishEvent(ThreadClearEvent())
    }

    @Synchronized
    fun sortPostsByRank() {
-        val postEntities = findAllPosts().sortedWith(Comparator.comparing(PostEntity::addedOn))
+        val postsToUpdate = mutableListOf<PostEntity>()
+        val postEntities = findAllPosts().sortedWith(Comparator.comparing(PostEntity::rank))
        for (i in postEntities.indices) {
-            postEntities[i].rank = i
+            if (postEntities[i].rank != i) {
+                postsToUpdate.add(postEntities[i].copy(rank = i))
+            }
        }
-        updatePosts(postEntities)
+        updatePosts(postsToUpdate)
+        nextRank.set(transaction { getQueuePosition() }?.plus(1) ?: 0)
    }

    fun setDownloadingToStopped() {
-        transaction { postDownloadStateRepository.setDownloadingToStopped() }
+        transaction { postRepository.setDownloadingToStopped() }
    }

    fun findAllPosts(): List<PostEntity> {
-        return transaction { postDownloadStateRepository.findAll() }
+        return transaction { postRepository.findAll() }
    }

-    fun findPostById(id: Long): Optional<PostEntity> {
-        return transaction { postDownloadStateRepository.findById(id) }
+    fun findPostById(id: Long): PostEntity {
+        return postEntityIdCache.get(id) ?: throw NoSuchElementException("Post with id = $id does not exist")
    }

    fun findImagesByPostId(postId: Long): List<ImageEntity> {
@@ -271,46 +287,16 @@ class DataTransaction(
        return transaction { imageRepository.countError() }
    }

-    fun findPostByPostId(postId: Long): Optional<PostEntity> {
-        return transaction { postDownloadStateRepository.findByPostId(postId) }
+    fun findPostByPostId(postId: Long): PostEntity {
+        return postPostIdCache.get(postId) ?: throw NoSuchElementException("Post with postId = $postId does not exist")
    }

    fun findThreadByThreadId(threadId: Long): Optional<ThreadEntity> {
        return transaction { threadRepository.findByThreadId(threadId) }
    }

-    fun saveLog(logEntryEntity: LogEntryEntity): LogEntryEntity {
-        val pair = transaction {
-            val saved = logRepository.save(logEntryEntity)
-            val deleted = logRepository.deleteOldest()
-            Pair(saved, deleted)
-        }
-        coroutineScope.launch {
-            eventBus.publishEvent(LogCreateEvent(pair.first))
-        }
-        coroutineScope.launch {
-            eventBus.publishEvent(LogDeleteEvent(pair.second))
-        }
-        return pair.first
-    }
-
-    fun updateLog(logEntryEntity: LogEntryEntity) {
-        transaction { logRepository.update(logEntryEntity) }
-        coroutineScope.launch {
-            eventBus.publishEvent(LogUpdateEvent(logEntryEntity))
-        }
-    }
-
-    fun deleteAllLogs() {
-        transaction { logRepository.deleteAll() }
-    }
-
-    fun findAllLogs(): List<LogEntryEntity> {
-        return transaction { logRepository.findAll() }
-    }
-
    fun findAllNonCompletedPostIds(): List<Long> {
-        return transaction { postDownloadStateRepository.findAllNonCompletedPostIds() }
+        return transaction { postRepository.findAllNonCompletedPostIds() }
    }

    fun findMetadataByPostId(postId: Long): Optional<MetadataEntity> {
@@ -8,7 +8,7 @@ import me.vripper.event.QueueStateEvent
 import me.vripper.model.DownloadSpeed
 import java.util.concurrent.atomic.AtomicLong

-class DownloadSpeedService(
+internal class DownloadSpeedService(
    private val eventBus: EventBus,
 ) {

@@ -30,7 +30,6 @@ class DownloadSpeedService(
                            while (isActive) {
                                delay(DOWNLOAD_POLL_RATE.toLong())
                                val newValue = bytesCount.getAndSet(0)
-
                                eventBus.publishEvent(DownloadSpeedEvent(DownloadSpeed(((newValue * 1000) / DOWNLOAD_POLL_RATE))))
                            }
                        }
@@ -14,10 +14,9 @@ import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager
 import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder
 import org.apache.hc.core5.pool.PoolConcurrencyPolicy
 import org.apache.hc.core5.pool.PoolReusePolicy
-import org.apache.hc.core5.util.TimeValue
 import org.apache.hc.core5.util.Timeout

-class HTTPService(
+internal class HTTPService(
    private val eventBus: EventBus,
    settingsService: SettingsService
 ) {
@@ -41,8 +40,10 @@ class HTTPService(
        buildConnectionPool()
        buildClientBuilder()
        coroutineScope.launch {
-            pcm.closeIdle(TimeValue.ofSeconds(60))
-            delay(15000)
+            while (isActive) {
+                pcm.closeExpired()
+                delay(60_000)
+            }
        }
        coroutineScope.launch {
            eventBus
@@ -64,8 +65,8 @@ class HTTPService(

    private fun buildConnectionPool() {
        pcm = PoolingHttpClientConnectionManagerBuilder.create()
-            .setPoolConcurrencyPolicy(PoolConcurrencyPolicy.STRICT)
-            .setConnPoolPolicy(PoolReusePolicy.LIFO)
+            .setPoolConcurrencyPolicy(PoolConcurrencyPolicy.LAX)
+            .setConnPoolPolicy(PoolReusePolicy.FIFO)
            .setDefaultConnectionConfig(cc)
            .setMaxConnTotal(Int.MAX_VALUE)
            .setMaxConnPerRoute(Int.MAX_VALUE)
@@ -83,7 +84,6 @@ class HTTPService(
        cc = ConnectionConfig.custom()
            .setConnectTimeout(Timeout.ofSeconds(connectionTimeout.toLong()))
            .setSocketTimeout(Timeout.ofSeconds(connectionTimeout.toLong()))
-            .setTimeToLive(TimeValue.ofMinutes(10))
            .build()
    }

@@ -17,13 +17,10 @@ interface IAppEndpointService {
    fun onDeletePosts(): Flow<Long>
    fun onUpdateMetadata(): Flow<Metadata>
    suspend fun findImagesByPostId(postId: Long): List<Image>
-    fun onUpdateImages(postId: Long): Flow<Image>
+    fun onUpdateImagesByPostId(postId: Long): Flow<Image>
+    fun onUpdateImages(): Flow<Image>
    fun onStopped(): Flow<Long>
-    suspend fun logClear()
-    suspend fun findAllLogs(): List<LogEntry>
    fun onNewLog(): Flow<LogEntry>
-    fun onUpdateLog(): Flow<LogEntry>
-    fun onDeleteLogs(): Flow<Long>
    fun onNewThread(): Flow<Thread>
    fun onUpdateThread(): Flow<Thread>
    fun onDeleteThread(): Flow<Long>
@@ -33,10 +30,10 @@ interface IAppEndpointService {
    suspend fun threadClear()
    suspend fun grab(threadId: Long): List<PostSelection>
    suspend fun download(posts: List<ThreadPostId>)
-    fun onDownloadSpeed(): Flow<Long>
+    fun onDownloadSpeed(): Flow<DownloadSpeed>
    fun onVGUserUpdate(): Flow<String>
    fun onQueueStateUpdate(): Flow<QueueState>
-    fun onErrorCountUpdate(): Flow<Int>
+    fun onErrorCountUpdate(): Flow<ErrorCount>
    fun onTasksRunning(): Flow<Boolean>
    suspend fun getSettings(): Settings
    suspend fun saveSettings(settings: Settings)
@@ -45,4 +42,7 @@ interface IAppEndpointService {
    suspend fun loggedInUser(): String
    suspend fun getVersion(): String
    suspend fun renameToFirst(postIds: List<Long>)
+    fun ready(): Boolean
+    suspend fun dbMigration(): String
+    suspend fun initLogger()
 }
@@ -0,0 +1,49 @@
+package me.vripper.services
+
+import kotlinx.coroutines.*
+import me.vripper.RingAppender
+import me.vripper.entities.LogEntryEntity
+import me.vripper.event.EventBus
+import me.vripper.event.LogCreateEvent
+import me.vripper.utilities.StackTraceElementUtils
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+
+class LogService(private val eventBus: EventBus) {
+    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
+    private var job: Job? = null
+
+    fun init() {
+        if (job != null) {
+            return
+        }
+        job = coroutineScope.launch {
+            while (isActive) {
+                while (!RingAppender.Static.events.isEmpty()) {
+                    RingAppender.Static.events.poll()?.also { loggingEvent ->
+                        eventBus.publishEvent(
+                            LogCreateEvent(
+                                LogEntryEntity(
+                                    loggingEvent.sequenceNumber,
+                                    loggingEvent.instant.atZone(ZoneId.systemDefault()).toLocalDateTime()
+                                        .format(dateTimeFormatter),
+                                    loggingEvent.threadName,
+                                    loggingEvent.loggerName,
+                                    loggingEvent.level.levelStr,
+                                    loggingEvent.formattedMessage,
+                                    loggingEvent.throwableProxy?.let { throwableProxy ->
+                                        StackTraceElementUtils.format(
+                                            throwableProxy
+                                        )
+                                    } ?: ""
+                                )
+                            )
+                        )
+                    }
+                }
+                delay(777)
+            }
+        }
+    }
+}
@@ -1,113 +1,29 @@
 package me.vripper.services

-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.withPermit
-import me.vripper.entities.MetadataEntity
-import me.vripper.exception.DownloadException
-import me.vripper.exception.VripperException
-import me.vripper.utilities.HtmlUtils
-import me.vripper.utilities.RequestLimit
-import me.vripper.utilities.Tasks
-import me.vripper.utilities.XpathUtils
-import org.apache.hc.client5.http.classic.methods.HttpGet
-import org.apache.hc.core5.net.URIBuilder
-import org.w3c.dom.Node
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.stream.Collectors
+import me.vripper.tasks.FetchMetadataTask
+import me.vripper.utilities.taskRunner

-class MetadataService(
-    private val httpService: HTTPService,
-    private val settingsService: SettingsService,
+internal class MetadataService(
    private val dataTransaction: DataTransaction,
-    private val vgAuthService: VGAuthService,
+    private val settingsService: SettingsService,
 ) {

-    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-    private val dictionary: List<String> = mutableListOf("download", "link", "rapidgator", "filefactory", "filefox")
-
    fun init() {
+        if (!settingsService.settings.viperSettings.fetchMetadata) {
+            return
+        }
        dataTransaction.findAllPosts().filter { dataTransaction.findMetadataByPostId(it.postId).isEmpty }
            .map { it.postId }.forEach(::fetchMetadata)
    }

    fun fetchMetadata(postId: Long) {
-        Tasks.increment()
-        coroutineScope.launch {
-            RequestLimit.semaphore.withPermit {
-                try {
-                    val httpGet = HttpGet(URIBuilder(settingsService.settings.viperSettings.host + "/threads/").also {
-                        it.setParameter(
-                            "p", postId.toString()
-                        )
-                    }.build())
-
-                    val metadataEntity = httpService.client.execute(httpGet, vgAuthService.context) {
-                        if (it.code / 100 != 2) {
-                            throw DownloadException("Unexpected response code '${it.code}' for $httpGet")
-                        }
-                        val document = HtmlUtils.clean(it.entity.content)
-                        val postNode: Node = XpathUtils.getAsNode(
-                            document,
-                            "//li[@id='post_$postId']/div[contains(@class, 'postdetails')]",
-
-                            ) ?: throw VripperException("Unable to find post #'$postId'")
-
-                        val postedBy: String = XpathUtils.getAsNode(
-                            postNode, "./div[contains(@class, 'userinfo')]//a[contains(@class, 'username')]//font"
-                        )?.textContent?.trim()
-                            ?: throw VripperException("Unable to find the poster for post #'$postId'")
-
-
-                        val node: Node = XpathUtils.getAsNode(
-                            document, java.lang.String.format("//div[@id='post_message_%s']", postId)
-                        ) ?: throw VripperException("Unable to locate post content")
-                        val titles = findTitleInContent(node)
-                        MetadataEntity(postId, MetadataEntity.Data(postedBy, titles))
-                    }
-                    try {
-                        dataTransaction.saveMetadata(metadataEntity)
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    }
-                } finally {
-                    Tasks.decrement()
-                }
-            }
-        }
-    }
-
-    private fun findTitleInContent(node: Node): List<String> {
-        val altTitle: MutableList<String> = mutableListOf()
-        findTitle(node, altTitle, AtomicBoolean(true))
-        return altTitle.stream().distinct().collect(Collectors.toList())
-    }
-
-    private fun findTitle(node: Node, altTitle: MutableList<String>, keepGoing: AtomicBoolean) {
-        if (!keepGoing.get()) {
+        if (!settingsService.settings.viperSettings.fetchMetadata) {
            return
        }
-        if (node.nodeName == "a" || node.nodeName == "img") {
-            keepGoing.set(false)
-            return
-        }
-        if (node.nodeType == Node.ELEMENT_NODE) {
-            for (i in 0 until node.childNodes.length) {
-                val item = node.childNodes.item(i)
-                findTitle(item, altTitle, keepGoing)
-                if (!keepGoing.get()) {
-                    return
-                }
-            }
-        } else if (node.nodeType == Node.TEXT_NODE) {
-            val text = node.textContent.trim()
-            if (text.isNotBlank() && dictionary.stream().noneMatch { e ->
-                    text.lowercase().contains(e.lowercase())
-                }) {
-                altTitle.add(text)
-            }
-        }
+        taskRunner.submit(
+            FetchMetadataTask(
+                postId
+            )
+        )
    }
 }
@@ -1,5 +1,6 @@
 package me.vripper.services

+import dev.failsafe.RetryPolicy
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -7,14 +8,13 @@ import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.launch
 import me.vripper.event.EventBus
 import me.vripper.event.SettingsUpdateEvent
-import net.jodah.failsafe.RetryPolicy
-import net.jodah.failsafe.event.ExecutionAttemptedEvent
+import me.vripper.utilities.LoggerDelegate
 import java.time.temporal.ChronoUnit

-class RetryPolicyService(
+internal class RetryPolicyService(
    val eventBus: EventBus, settingsService: SettingsService
 ) {
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()
    private var maxAttempts: Int = settingsService.settings.connectionSettings.maxAttempts
    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

@@ -28,16 +28,10 @@ class RetryPolicyService(
        }
    }

-    fun <T> buildRetryPolicyForDownload(): RetryPolicy<T> {
-        return RetryPolicy<T>().withDelay(2, 5, ChronoUnit.SECONDS).withMaxAttempts(maxAttempts).onFailedAttempt {
-                log.warn("#${it.attemptCount} tries failed", it.lastFailure)
-            }
-    }
-
-    fun <T> buildGenericRetryPolicy(): RetryPolicy<T> {
-        return RetryPolicy<T>().withDelay(2, 5, ChronoUnit.SECONDS).withMaxAttempts(maxAttempts)
-            .onFailedAttempt { e: ExecutionAttemptedEvent<T> ->
-                log.warn("#${e.attemptCount} tries failed", e.lastFailure)
-            }
+    fun <T> buildRetryPolicy(message: String): RetryPolicy<T> {
+        return RetryPolicy.builder<T>().withDelay(2, 5, ChronoUnit.SECONDS).withMaxAttempts(maxAttempts)
+            .onFailedAttempt {
+                log.warn(message + "#${it.attemptCount} tries failed", it.lastException)
+            }.build()
    }
 }
@@ -1,9 +1,5 @@
 package me.vripper.services

-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.decodeFromStream
@@ -12,6 +8,7 @@ import me.vripper.event.SettingsUpdateEvent
 import me.vripper.exception.ValidationException
 import me.vripper.model.Settings
 import me.vripper.utilities.ApplicationProperties.VRIPPER_DIR
+import me.vripper.utilities.LoggerDelegate
 import org.apache.commons.codec.digest.DigestUtils
 import java.io.FileWriter
 import java.nio.file.*
@@ -19,11 +16,10 @@ import kotlin.io.path.readText

 class SettingsService(private val eventBus: EventBus) {

-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()
    private val configPath = VRIPPER_DIR.resolve("config.json")
    private val customProxiesPath = VRIPPER_DIR.resolve("proxies.json")
    private val proxies: MutableSet<String> = HashSet()
-    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

    private val json = Json {
        encodeDefaults = true
@@ -39,10 +35,7 @@ class SettingsService(private val eventBus: EventBus) {
    private fun init() {
        loadViperProxies()
        restore()
-        coroutineScope.launch {
-            eventBus.publishEvent(SettingsUpdateEvent(settings))
-        }
-
+        eventBus.publishEvent(SettingsUpdateEvent(settings))
    }

    private fun loadViperProxies() {
@@ -57,7 +50,7 @@ class SettingsService(private val eventBus: EventBus) {
                            customProxiesPath.readText()
                        )
                    } catch (e: Exception) {
-                        e.printStackTrace()
+                        log.error("Failed to read custom proxies", e)
                        emptyList()
                    }
                } else {
@@ -100,9 +93,7 @@ class SettingsService(private val eventBus: EventBus) {
        }
        this.settings = settings.copy(viperSettings = viperSettings)
        save()
-        coroutineScope.launch {
-            eventBus.publishEvent(SettingsUpdateEvent(this@SettingsService.settings))
-        }
+        eventBus.publishEvent(SettingsUpdateEvent(this@SettingsService.settings))
    }

    private fun restore() {
@@ -111,7 +102,7 @@ class SettingsService(private val eventBus: EventBus) {
                settings = json.decodeFromString(configPath.readText())
            }
        } catch (e: Exception) {
-            log.error("Failed restore user settings", e)
+            log.error("Failed to restore user settings", e)
            settings = Settings()
        }
        if (!proxies.contains(settings.viperSettings.host)) {
@@ -197,5 +188,11 @@ class SettingsService(private val eventBus: EventBus) {
                "Invalid clipboard monitoring polling rate settings, values must be >= 500"
            )
        }
+
+        if (settings.viperSettings.requestLimit < 1 || settings.viperSettings.requestLimit > 6) {
+            throw ValidationException(
+                "Invalid request rate limit, values must be in [1,6]"
+            )
+        }
    }
 }
@@ -2,19 +2,19 @@ package me.vripper.services

 import com.github.benmanes.caffeine.cache.Caffeine
 import com.github.benmanes.caffeine.cache.LoadingCache
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.filterIsInstance
-import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.launch
 import me.vripper.event.EventBus
 import me.vripper.event.SettingsUpdateEvent
-import me.vripper.parser.ThreadItem
-import me.vripper.parser.ThreadLookupAPIParser
-import me.vripper.utilities.RequestLimit
-import java.util.*
+import me.vripper.vgapi.ThreadItem
+import me.vripper.vgapi.ThreadLookupAPIParser
 import java.util.concurrent.ExecutionException
 import java.util.concurrent.TimeUnit

-class ThreadCacheService(val eventBus: EventBus) {
+internal class ThreadCacheService(val eventBus: EventBus) {

    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

@@ -28,11 +28,7 @@ class ThreadCacheService(val eventBus: EventBus) {

    private val cache: LoadingCache<Long, ThreadItem> =
        Caffeine.newBuilder().expireAfterWrite(20, TimeUnit.MINUTES).build { threadId ->
-            runBlocking {
-                RequestLimit.semaphore.withPermit {
-                    ThreadLookupAPIParser(threadId).parse()
-                }
-            }
+            ThreadLookupAPIParser(threadId).parse()
        }

    @Throws(ExecutionException::class)
@@ -11,8 +11,9 @@ import me.vripper.event.SettingsUpdateEvent
 import me.vripper.event.VGUserLoginEvent
 import me.vripper.exception.VripperException
 import me.vripper.model.Settings
-import me.vripper.tasks.LeaveThanksRunnable
-import me.vripper.utilities.GLOBAL_EXECUTOR
+import me.vripper.tasks.LeaveThanksTask
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.utilities.taskRunner
 import org.apache.hc.client5.http.classic.methods.HttpPost
 import org.apache.hc.client5.http.cookie.BasicCookieStore
 import org.apache.hc.client5.http.cookie.Cookie
@@ -20,15 +21,14 @@ import org.apache.hc.client5.http.entity.UrlEncodedFormEntity
 import org.apache.hc.client5.http.protocol.HttpClientContext
 import org.apache.hc.core5.http.io.entity.EntityUtils
 import org.apache.hc.core5.http.message.BasicNameValuePair
-import java.util.concurrent.CompletableFuture

-class VGAuthService(
+internal class VGAuthService(
    private val cm: HTTPService,
    private val settingsService: SettingsService,
    private val eventBus: EventBus
 ) {
    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
-    private val log by me.vripper.delegate.LoggerDelegate()
+    private val log by LoggerDelegate()
    val context: HttpClientContext = HttpClientContext.create()
    var loggedUser = ""

@@ -50,10 +50,7 @@ class VGAuthService(
            log.debug("Authentication option is disabled")
            context.cookieStore.clear()
            loggedUser = ""
-            coroutineScope.launch {
-                eventBus.publishEvent(VGUserLoginEvent(loggedUser))
-            }
-
+            eventBus.publishEvent(VGUserLoginEvent(loggedUser))
            return
        }
        val username = settings.viperSettings.username
@@ -62,11 +59,7 @@ class VGAuthService(
            log.error("Cannot authenticate with ViperGirls credentials, username or password is empty")
            context.cookieStore.clear()
            loggedUser = ""
-
-            coroutineScope.launch {
-                eventBus.publishEvent(VGUserLoginEvent(loggedUser))
-            }
-
+            eventBus.publishEvent(VGUserLoginEvent(loggedUser))
            return
        }
        val postAuth = HttpPost(settings.viperSettings.host + "/login.php?do=login").also {
@@ -78,10 +71,6 @@ class VGAuthService(
                    BasicNameValuePair("vb_login_md5password", password)
                )
            )
-            it.addHeader("Referer", settings.viperSettings.host)
-            it.addHeader(
-                "Host", settings.viperSettings.host.replace("https://", "").replace("http://", "")
-            )
        }

        try {
@@ -103,11 +92,7 @@ class VGAuthService(
        } catch (e: Exception) {
            context.cookieStore.clear()
            loggedUser = ""
-
-            coroutineScope.launch {
-                eventBus.publishEvent(VGUserLoginEvent(loggedUser))
-            }
-
+            eventBus.publishEvent(VGUserLoginEvent(loggedUser))
            log.error(
                "Failed to authenticate user with " + settings.viperSettings.host, e
            )
@@ -115,15 +100,12 @@ class VGAuthService(
        }
        authenticated = true
        loggedUser = username
-
-        coroutineScope.launch {
-            eventBus.publishEvent(VGUserLoginEvent(loggedUser))
-        }
+        eventBus.publishEvent(VGUserLoginEvent(loggedUser))
    }

    fun leaveThanks(postEntity: PostEntity) {
-        CompletableFuture.runAsync(
-            LeaveThanksRunnable(postEntity, authenticated, context), GLOBAL_EXECUTOR
+        taskRunner.submit(
+            LeaveThanksTask(postEntity, authenticated, context)
        )
    }
 }
@@ -1,11 +0,0 @@
-package me.vripper.tables
-
-import org.jetbrains.exposed.dao.id.LongIdTable
-import org.jetbrains.exposed.sql.javatime.datetime
-
-object LogTable : LongIdTable(name = "LOG", columnName = "ID") {
-    val type = varchar("TYPE", 8)
-    val status = varchar("STATUS", 10)
-    val time = datetime("TIME")
-    val message = varchar("MESSAGE", 500)
-}
@@ -1,23 +1,19 @@
 package me.vripper.tasks

-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.sync.withPermit
 import me.vripper.download.DownloadService
-import me.vripper.entities.LogEntryEntity
 import me.vripper.model.ThreadPostId
-import me.vripper.parser.PostItem
-import me.vripper.parser.PostLookupAPIParser
 import me.vripper.services.DataTransaction
 import me.vripper.services.MetadataService
 import me.vripper.services.SettingsService
 import me.vripper.services.ThreadCacheService
-import me.vripper.utilities.RequestLimit
-import me.vripper.utilities.Tasks
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.vgapi.PostItem
+import me.vripper.vgapi.PostLookupAPIParser
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject

-class AddPostRunnable(private val items: List<ThreadPostId>) : KoinComponent, Runnable {
-    private val log by me.vripper.delegate.LoggerDelegate()
+internal class AddPostTask(private val items: List<ThreadPostId>) : KoinComponent, Runnable {
+    private val log by LoggerDelegate()
    private val dataTransaction: DataTransaction by inject()
    private val settingsService: SettingsService by inject()
    private val downloadService: DownloadService by inject()
@@ -34,49 +30,33 @@ class AddPostRunnable(private val items: List<ThreadPostId>) : KoinComponent, Ru
                }

                val link =
-                    "https://${settingsService.settings.viperSettings.host}/threads/$threadId?p=$postId&viewfull=1#post$postId"
+                    "${settingsService.settings.viperSettings.host}/threads/$threadId?p=$postId&viewfull=1#post$postId"

                val cachedThread = threadCacheService.getIfPresent(threadId)
-                val threadItem = cachedThread ?: runBlocking {
-                    RequestLimit.semaphore.withPermit {
-                        PostLookupAPIParser(
-                            threadId, postId
-                        ).parse()
-                    }
-                }
+                val threadItem = cachedThread ?:
+                    PostLookupAPIParser(
+                        threadId, postId
+                    ).parse()
+

                if (threadItem == null) {
-                    dataTransaction.saveLog(
-                        LogEntryEntity(
-                            type = LogEntryEntity.Type.POST,
-                            status = LogEntryEntity.Status.ERROR,
-                            message = "Failed to load $link"
-                        )
-                    )
+                    log.error("Failed to load $link")
                    continue
                } else {
                    if (threadItem.error.isNotBlank()) {
-                        dataTransaction.saveLog(
-                            LogEntryEntity(
-                                type = LogEntryEntity.Type.POST,
-                                status = LogEntryEntity.Status.ERROR,
-                                message = "Error loading $link: ${threadItem.error}"
-                            )
-                        )
+                        log.error("Error loading $link: ${threadItem.error}")
                        continue
                    } else if (threadItem.postItemList.isEmpty()) {
-                        dataTransaction.saveLog(
-                            LogEntryEntity(
-                                type = LogEntryEntity.Type.POST,
-                                status = LogEntryEntity.Status.ERROR,
-                                message = "Nothing found for $link"
-                            )
-                        )
+                        log.error("Nothing found for $link")
                        continue
                    }
                }

-                val postItem = threadItem.postItemList.first()
+                val postItem = threadItem.postItemList.firstOrNull { it.postId == postId }
+                if (postItem == null) {
+                    log.error("Unable to load $link")
+                    continue
+                }
                toProcess.add(postItem)
            }

@@ -0,0 +1,110 @@
+package me.vripper.tasks
+
+import me.vripper.entities.MetadataEntity
+import me.vripper.exception.DownloadException
+import me.vripper.exception.VripperException
+import me.vripper.services.DataTransaction
+import me.vripper.services.HTTPService
+import me.vripper.services.SettingsService
+import me.vripper.services.VGAuthService
+import me.vripper.utilities.HtmlUtils
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.utilities.RequestLimit
+import me.vripper.utilities.XpathUtils
+import org.apache.hc.client5.http.classic.methods.HttpGet
+import org.apache.hc.core5.http.io.entity.EntityUtils
+import org.apache.hc.core5.net.URIBuilder
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import org.w3c.dom.Node
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.stream.Collectors
+
+internal class FetchMetadataTask(
+    private val postId: Long,
+) : KoinComponent, Runnable {
+    private val dictionary: List<String> = mutableListOf("download", "link", "rapidgator", "filefactory", "filefox")
+    private val log by LoggerDelegate()
+    private val settingsService: SettingsService by inject()
+    private val vgAuthService: VGAuthService by inject()
+    private val httpService: HTTPService by inject()
+    private val dataTransaction: DataTransaction by inject()
+
+    override fun run() {
+        try {
+            if (!settingsService.settings.viperSettings.fetchMetadata) {
+                log.debug("Fetching metadata is disabled")
+                return
+            }
+            Tasks.increment()
+            val httpGet = HttpGet(URIBuilder(settingsService.settings.viperSettings.host + "/threads/").also {
+                it.setParameter(
+                    "p", postId.toString()
+                )
+            }.build())
+
+            RequestLimit.getPermit(1)
+            log.debug("Requesting {}", httpGet.uri)
+            val response = httpService.client.execute(httpGet, vgAuthService.context) {
+                if (it.code / 100 != 2) {
+                    throw DownloadException("Unexpected response code '${it.code}' for $httpGet")
+                }
+                EntityUtils.toString(it.entity)
+            }
+
+            val document = HtmlUtils.clean(response)
+            val postNode: Node = XpathUtils.getAsNode(
+                document,
+                "//li[@id='post_$postId']/div[contains(@class, 'postdetails')]",
+
+                ) ?: throw VripperException("Unable to find post #'$postId'")
+
+            val postedBy: String = XpathUtils.getAsNode(
+                postNode, "./div[contains(@class, 'userinfo')]//a[contains(@class, 'username')]//font"
+            )?.textContent?.trim()
+                ?: throw VripperException("Unable to find the poster for post #'$postId'")
+
+
+            val node: Node = XpathUtils.getAsNode(
+                document, java.lang.String.format("//div[@id='post_message_%s']", postId)
+            ) ?: throw VripperException("Unable to locate post content")
+            val titles = findTitleInContent(node)
+            val metadataEntity = MetadataEntity(postId, MetadataEntity.Data(postedBy, titles))
+            dataTransaction.saveMetadata(metadataEntity)
+        } finally {
+            Tasks.decrement()
+        }
+    }
+
+    private fun findTitleInContent(node: Node): List<String> {
+        val altTitle: MutableList<String> = mutableListOf()
+        findTitle(node, altTitle, AtomicBoolean(true))
+        return altTitle.stream().distinct().collect(Collectors.toList())
+    }
+
+    private fun findTitle(node: Node, altTitle: MutableList<String>, keepGoing: AtomicBoolean) {
+        if (!keepGoing.get()) {
+            return
+        }
+        if (node.nodeName == "a" || node.nodeName == "img") {
+            keepGoing.set(false)
+            return
+        }
+        if (node.nodeType == Node.ELEMENT_NODE) {
+            for (i in 0 until node.childNodes.length) {
+                val item = node.childNodes.item(i)
+                findTitle(item, altTitle, keepGoing)
+                if (!keepGoing.get()) {
+                    return
+                }
+            }
+        } else if (node.nodeType == Node.TEXT_NODE) {
+            val text = node.textContent.trim()
+            if (text.isNotBlank() && dictionary.stream().noneMatch { e ->
+                    text.lowercase().contains(e.lowercase())
+                }) {
+                altTitle.add(text)
+            }
+        }
+    }
+}
@@ -1,71 +0,0 @@
-package me.vripper.tasks
-
-import me.vripper.entities.LogEntryEntity
-import me.vripper.entities.LogEntryEntity.Status.ERROR
-import me.vripper.entities.PostEntity
-import me.vripper.services.DataTransaction
-import me.vripper.services.HTTPService
-import me.vripper.services.SettingsService
-import me.vripper.utilities.Tasks
-import me.vripper.utilities.formatToString
-import org.apache.hc.client5.http.classic.methods.HttpPost
-import org.apache.hc.client5.http.entity.UrlEncodedFormEntity
-import org.apache.hc.client5.http.protocol.HttpClientContext
-import org.apache.hc.core5.http.message.BasicNameValuePair
-import org.koin.core.component.KoinComponent
-import org.koin.core.component.inject
-
-class LeaveThanksRunnable(
-    private val postEntity: PostEntity,
-    private val authenticated: Boolean,
-    private val context: HttpClientContext
-) : KoinComponent, Runnable {
-    private val log by me.vripper.delegate.LoggerDelegate()
-    private val cm: HTTPService by inject()
-    private val settingsService: SettingsService by inject()
-    private val dataTransaction: DataTransaction by inject()
-
-    override fun run() {
-        try {
-            Tasks.increment()
-            if (!settingsService.settings.viperSettings.login || !authenticated) {
-                return
-            }
-            if (!settingsService.settings.viperSettings.thanks) {
-                return
-            }
-
-            val postThanks =
-                HttpPost("${settingsService.settings.viperSettings.host}/post_thanks.php").also {
-                    it.entity = UrlEncodedFormEntity(
-                        listOf(
-                            BasicNameValuePair("do", "post_thanks_add"),
-                            BasicNameValuePair("using_ajax", "1"),
-                            BasicNameValuePair("p", postEntity.postId.toString()),
-                            BasicNameValuePair("securitytoken", postEntity.token)
-                        )
-                    )
-                    it.addHeader("Referer", settingsService.settings.viperSettings.host)
-                    it.addHeader(
-                        "Host",
-                        settingsService.settings.viperSettings.host.replace("https://", "")
-                            .replace("http://", "")
-                    )
-                }
-            cm.client.execute(postThanks, context) { }
-        } catch (e: Exception) {
-            val error = "Failed to leave a thanks for $postEntity"
-            log.error(error, e)
-            dataTransaction.saveLog(
-                LogEntryEntity(
-                    type = LogEntryEntity.Type.THANKS, status = ERROR, message = """
-                $error
-                ${e.formatToString()}
-                """.trimIndent()
-                )
-            )
-        } finally {
-            Tasks.decrement()
-        }
-    }
-}
@@ -0,0 +1,57 @@
+package me.vripper.tasks
+
+import me.vripper.entities.PostEntity
+import me.vripper.exception.VripperException
+import me.vripper.services.HTTPService
+import me.vripper.services.SettingsService
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.utilities.RequestLimit
+import org.apache.hc.client5.http.classic.methods.HttpPost
+import org.apache.hc.client5.http.entity.UrlEncodedFormEntity
+import org.apache.hc.client5.http.protocol.HttpClientContext
+import org.apache.hc.core5.http.message.BasicNameValuePair
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+
+internal class LeaveThanksTask(
+    private val postEntity: PostEntity,
+    private val authenticated: Boolean,
+    private val context: HttpClientContext
+) : KoinComponent, Runnable {
+    private val log by LoggerDelegate()
+    private val cm: HTTPService by inject()
+    private val settingsService: SettingsService by inject()
+
+    override fun run() {
+        try {
+            Tasks.increment()
+            if (!settingsService.settings.viperSettings.login || !authenticated) {
+                return
+            }
+            if (!settingsService.settings.viperSettings.thanks) {
+                return
+            }
+            val postThanks = HttpPost("${settingsService.settings.viperSettings.host}/post_thanks.php").also {
+                it.entity = UrlEncodedFormEntity(
+                    listOf(
+                        BasicNameValuePair("do", "post_thanks_add"),
+                        BasicNameValuePair("using_ajax", "1"),
+                        BasicNameValuePair("p", postEntity.postId.toString()),
+                        BasicNameValuePair("securitytoken", postEntity.token)
+                    )
+                )
+            }
+            RequestLimit.getPermit(1)
+            log.debug("Requesting {}", postThanks.uri)
+            cm.client.execute(postThanks, context) { response ->
+                if (response.code / 100 != 2) {
+                    throw VripperException("Unexpected response code '${response.code}' for $postThanks")
+                }
+            }
+        } catch (e: Exception) {
+            log.error("Failed to leave a thanks for $postEntity", e)
+        } finally {
+            Tasks.decrement()
+        }
+    }
+}
@@ -0,0 +1,28 @@
+package me.vripper.tasks
+
+import me.vripper.event.EventBus
+import me.vripper.event.LoadingTasks
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+
+internal object Tasks : KoinComponent {
+
+    private val eventBus: EventBus by inject()
+    private var current = 0
+
+    @Synchronized
+    fun increment() {
+        if (current == 0) {
+            eventBus.publishEvent(LoadingTasks(true))
+        }
+        current += 1
+    }
+
+    @Synchronized
+    fun decrement() {
+        current -= 1
+        if (current == 0) {
+            eventBus.publishEvent(LoadingTasks(false))
+        }
+    }
+}
@@ -1,96 +0,0 @@
-package me.vripper.tasks
-
-import kotlinx.coroutines.runBlocking
-import me.vripper.entities.LogEntryEntity
-import me.vripper.entities.LogEntryEntity.Status.ERROR
-import me.vripper.entities.ThreadEntity
-import me.vripper.model.Settings
-import me.vripper.model.ThreadPostId
-import me.vripper.parser.ThreadItem
-import me.vripper.services.AppEndpointService
-import me.vripper.services.DataTransaction
-import me.vripper.services.SettingsService
-import me.vripper.services.ThreadCacheService
-import me.vripper.utilities.GLOBAL_EXECUTOR
-import me.vripper.utilities.Tasks
-import me.vripper.utilities.formatToString
-import org.koin.core.component.KoinComponent
-import org.koin.core.component.inject
-import java.util.concurrent.CompletableFuture
-
-class ThreadLookupRunnable(private val threadId: Long, private val settings: Settings) : KoinComponent, Runnable {
-    private val log by me.vripper.delegate.LoggerDelegate()
-    private val dataTransaction by inject<DataTransaction>()
-    private val settingsService by inject<SettingsService>()
-    private val threadCacheService by inject<ThreadCacheService>()
-    private val appEndpointService by inject<AppEndpointService>()
-    private val link: String = "${settingsService.settings.viperSettings.host}/threads/$threadId"
-
-    override fun run() {
-        try {
-            Tasks.increment()
-            if (dataTransaction.findThreadByThreadId(threadId).isEmpty) {
-                val threadLookupResult = threadCacheService[threadId]
-                if (threadLookupResult.error.isNotBlank()) {
-                    dataTransaction.saveLog(
-                        LogEntryEntity(
-                            type = LogEntryEntity.Type.THREAD,
-                            status = LogEntryEntity.Status.ERROR,
-                            message = "Error loading $link: ${threadLookupResult.error}"
-                        )
-                    )
-                    return
-                }
-                if (threadLookupResult.postItemList.isEmpty()) {
-                    dataTransaction.saveLog(
-                        LogEntryEntity(
-                            type = LogEntryEntity.Type.THREAD,
-                            status = LogEntryEntity.Status.ERROR,
-                            message = "Nothing found for $link"
-                        )
-                    )
-                    return
-                }
-                try {
-                    dataTransaction.save(
-                        ThreadEntity(
-                            title = threadLookupResult.title,
-                            link = link,
-                            threadId = threadId,
-                            total = threadLookupResult.postItemList.size
-                        )
-                    )
-                    autostart(threadLookupResult)
-                } catch (e: Exception) {
-                    e.printStackTrace()
-                }
-            }
-        } catch (e: Exception) {
-            val error = "Error when processing $link"
-            log.error(error, e)
-            dataTransaction.saveLog(
-                LogEntryEntity(
-                    type = LogEntryEntity.Type.THREAD, status = ERROR, message = """
-                $error
-                ${e.formatToString()}
-                """.trimIndent()
-                )
-            )
-        } finally {
-            Tasks.decrement()
-        }
-    }
-
-    private fun autostart(lookupResult: ThreadItem) {
-        if (lookupResult.postItemList.size <= settings.downloadSettings.autoQueueThreshold) {
-            runBlocking {
-                appEndpointService.threadRemove(listOf(lookupResult.threadId))
-            }
-            CompletableFuture.runAsync(AddPostRunnable(lookupResult.postItemList.map {
-                ThreadPostId(
-                    it.threadId, it.postId
-                )
-            }), GLOBAL_EXECUTOR)
-        }
-    }
-}
@@ -0,0 +1,60 @@
+package me.vripper.tasks
+
+import me.vripper.entities.ThreadEntity
+import me.vripper.model.Settings
+import me.vripper.model.ThreadPostId
+import me.vripper.services.DataTransaction
+import me.vripper.services.SettingsService
+import me.vripper.services.ThreadCacheService
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.utilities.taskRunner
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+
+internal class ThreadLookupTask(private val threadId: Long, private val settings: Settings) : KoinComponent, Runnable {
+    private val log by LoggerDelegate()
+    private val dataTransaction by inject<DataTransaction>()
+    private val settingsService by inject<SettingsService>()
+    private val threadCacheService by inject<ThreadCacheService>()
+    private val link: String = "${settingsService.settings.viperSettings.host}/threads/$threadId"
+
+    override fun run() {
+        try {
+            Tasks.increment()
+            if (dataTransaction.findThreadByThreadId(threadId).isEmpty) {
+                val threadLookupResult = threadCacheService[threadId]
+                if (threadLookupResult.error.isNotBlank()) {
+                    log.error("Error loading $link: ${threadLookupResult.error}")
+                    return
+                }
+                if (threadLookupResult.postItemList.isEmpty()) {
+                    log.error("Nothing found for $link")
+                    return
+                }
+
+                if (threadLookupResult.postItemList.size <= settings.downloadSettings.autoQueueThreshold) {
+                    taskRunner.submit(
+                        AddPostTask(threadLookupResult.postItemList.map {
+                            ThreadPostId(
+                                it.threadId, it.postId
+                            )
+                        })
+                    )
+                } else {
+                        dataTransaction.save(
+                            ThreadEntity(
+                                title = threadLookupResult.title,
+                                link = link,
+                                threadId = threadId,
+                                total = threadLookupResult.postItemList.size
+                            )
+                        )
+                }
+            }
+        } catch (e: Exception) {
+            log.error("Error when processing $link", e)
+        } finally {
+            Tasks.decrement()
+        }
+    }
+}
@@ -1,4 +1,4 @@
-package me.vripper.listeners
+package me.vripper.utilities

 import me.vripper.utilities.ApplicationProperties.VRIPPER_DIR
 import java.io.RandomAccessFile
@@ -7,24 +7,25 @@ import kotlin.io.path.pathString
 import kotlin.system.exitProcess

 object AppLock {
-    fun exclusiveLock() {
+    fun exclusiveLock(): Boolean {
        val lock = VRIPPER_DIR.resolve("lock")
        try {
            val randomFile = RandomAccessFile(lock.pathString, "rw")
            val channel = randomFile.channel
            val fileLock = channel.tryLock()
            if (fileLock == null) {
-                System.err.println("Another instance is already running in ${lock.parent.pathString}")
-                exitProcess(-1)
+                return false
            } else {
                Runtime.getRuntime().addShutdownHook(Thread {
                    fileLock.release()
                    channel.close()
                    Files.deleteIfExists(lock)
                })
+                return true
            }
        } catch (e: Exception) {
-            println(e.toString())
+            e.printStackTrace()
+            exitProcess(-1)
        }
    }
 }
@@ -35,7 +35,7 @@ object ApplicationProperties {

    fun latestVersion(): String {
        val request = HttpRequest.newBuilder()
-            .uri(URI.create("https://api.github.com/repos/death-claw/vripper-project/releases/latest")).build()
+            .uri(URI.create("https://api.github.com/repos/dev-claw/vripper-project/releases/latest")).build()
        return HttpClient.newHttpClient().use {
            val response = it.send(request, HttpResponse.BodyHandlers.ofString())
            if (response.statusCode() / 100 != 2) {
@@ -0,0 +1,37 @@
+package me.vripper.utilities
+
+import liquibase.Contexts
+import liquibase.LabelExpression
+import liquibase.Liquibase
+import liquibase.database.DatabaseFactory
+import liquibase.database.jvm.JdbcConnection
+import liquibase.resource.ClassLoaderResourceAccessor
+import org.jetbrains.exposed.sql.Database
+import org.jetbrains.exposed.sql.transactions.TransactionManager
+import java.sql.Connection
+
+object DatabaseManager {
+    private var database: Database? = null
+
+    fun connect() {
+        database =
+            Database.connect("jdbc:sqlite:${ApplicationProperties.VRIPPER_DIR}/vripper.db")
+                .also { update(it.connector.invoke().connection as Connection) }
+    }
+
+    fun disconnect() {
+        database?.let { TransactionManager.closeAndUnregister(it) }
+    }
+
+    fun update(connection: Connection) {
+        connection.use { cn ->
+            val database: liquibase.database.Database = DatabaseFactory.getInstance()
+                .findCorrectDatabaseImplementation(JdbcConnection(cn))
+            Liquibase(
+                "db.changelog-master.xml", ClassLoaderResourceAccessor(), database
+            ).use { liquibase ->
+                liquibase.update(Contexts(), LabelExpression())
+            }
+        }
+    }
+}
@@ -1,29 +0,0 @@
-package me.vripper.utilities
-
-import liquibase.Contexts
-import liquibase.LabelExpression
-import liquibase.Liquibase
-import liquibase.database.Database
-import liquibase.database.DatabaseFactory
-import liquibase.database.jvm.JdbcConnection
-import liquibase.resource.ClassLoaderResourceAccessor
-import me.vripper.utilities.ApplicationProperties.VRIPPER_DIR
-import java.sql.DriverManager
-
-object DbUtils {
-
-    fun update() {
-        val connection =
-            DriverManager.getConnection("jdbc:h2:file:$VRIPPER_DIR/vripper;DB_CLOSE_DELAY=-1;")
-
-        connection.use { cn ->
-            val database: Database = DatabaseFactory.getInstance()
-                .findCorrectDatabaseImplementation(JdbcConnection(cn))
-            Liquibase(
-                "db.changelog-master.xml", ClassLoaderResourceAccessor(), database
-            ).use { liquibase ->
-                liquibase.update(Contexts(), LabelExpression())
-            }
-        }
-    }
-}
@@ -7,11 +7,12 @@ import org.htmlcleaner.HtmlCleaner
 import org.w3c.dom.Document
 import java.io.InputStream

-object HtmlUtils {
+internal object HtmlUtils {
+
    @Throws(HtmlProcessorException::class)
    fun clean(htmlContent: InputStream): Document {
        return try {
-            htmlContent.use {
+            htmlContent.use { stream ->
                val clean = HtmlCleaner().clean(htmlContent)
                DomSerializer(CleanerProperties()).createDOM(clean)
            }
@@ -19,4 +20,15 @@ object HtmlUtils {
            throw HtmlProcessorException(e)
        }
    }
+
+    @Throws(HtmlProcessorException::class)
+    fun clean(htmlContent: String): Document {
+        return try {
+            val clean = HtmlCleaner().clean(htmlContent)
+            DomSerializer(CleanerProperties()).createDOM(clean)
+
+        } catch (e: Exception) {
+            throw HtmlProcessorException(e)
+        }
+    }
 }
@@ -1,4 +1,4 @@
-package me.vripper.delegate
+package me.vripper.utilities

 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -11,8 +11,8 @@ import kotlin.io.path.Path
 import kotlin.io.path.listDirectoryEntries


-object PathUtils {
-    private val log by me.vripper.delegate.LoggerDelegate()
+internal object PathUtils {
+    private val log by LoggerDelegate()
    private val imageExtensions = listOf("bmp", "gif", "jpg", "jpeg", "png", "webp")


@@ -54,7 +54,7 @@ object PathUtils {
                try {
                    Files.delete(currentDownloadDirectory)
                } catch (e: Exception) {
-                    e.printStackTrace()
+                    log.error("Failed to delete directory $currentDownloadDirectory", e)
                }
            }
        } catch (e: IOException) {
@@ -1,7 +1,42 @@
 package me.vripper.utilities

-import kotlinx.coroutines.sync.Semaphore
+import io.github.bucket4j.Bucket
+import io.github.bucket4j.BucketConfiguration
+import io.github.bucket4j.TokensInheritanceStrategy
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.launch
+import me.vripper.event.EventBus
+import me.vripper.event.SettingsUpdateEvent
+import me.vripper.services.SettingsService
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import java.time.Duration

-object RequestLimit {
-    val semaphore: Semaphore = Semaphore(6)
+internal object RequestLimit : KoinComponent {
+    private val coroutineScope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    private val settingsService: SettingsService by inject()
+    private val eventBus: EventBus by inject()
+    private val bucket: Bucket = Bucket.builder().addLimit {
+        it.capacity(settingsService.settings.viperSettings.requestLimit)
+            .refillGreedy(settingsService.settings.viperSettings.requestLimit, Duration.ofSeconds(1))
+    }.build()
+
+    init {
+        coroutineScope.launch {
+            eventBus.events.filterIsInstance(SettingsUpdateEvent::class).collectLatest { event ->
+                bucket.replaceConfiguration(BucketConfiguration.builder().addLimit {
+                    it.capacity(event.settings.viperSettings.requestLimit)
+                        .refillGreedy(event.settings.viperSettings.requestLimit, Duration.ofSeconds(1))
+                }.build(), TokensInheritanceStrategy.RESET)
+            }
+        }
+    }
+
+    fun getPermit(tokens: Long) {
+        bucket.asBlocking().consume(tokens)
+    }
 }
@@ -0,0 +1,24 @@
+package me.vripper.utilities
+
+import ch.qos.logback.classic.spi.IThrowableProxy
+
+object StackTraceElementUtils {
+    fun format(throwable: IThrowableProxy): String {
+        val sb = StringBuilder()
+        sb.appendLine(throwable.className + ": " + throwable.message)
+        stackTraceElementFormat(throwable, sb)
+        return sb.toString()
+
+    }
+
+    private fun stackTraceElementFormat(throwable: IThrowableProxy, sb: StringBuilder) {
+        throwable.stackTraceElementProxyArray.forEach {
+            sb.appendLine("\t" + it.steAsString)
+        }
+
+        if (throwable.cause != null) {
+            sb.appendLine("Caused by: " + throwable.cause.className + ": " + throwable.cause.message)
+            stackTraceElementFormat(throwable.cause, sb)
+        }
+    }
+}
@@ -1,37 +0,0 @@
-package me.vripper.utilities
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import me.vripper.event.EventBus
-import me.vripper.event.LoadingTasks
-import org.koin.core.component.KoinComponent
-import org.koin.core.component.inject
-
-object Tasks : KoinComponent {
-
-    private val eventBus: EventBus by inject()
-    private var current = 0
-    private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
-
-    @Synchronized
-    fun increment() {
-        if (current == 0) {
-            coroutineScope.launch {
-                eventBus.publishEvent(LoadingTasks(true))
-            }
-        }
-        current += 1
-    }
-
-    @Synchronized
-    fun decrement() {
-        current -= 1
-        if (current == 0) {
-            coroutineScope.launch {
-                eventBus.publishEvent(LoadingTasks(false))
-            }
-        }
-    }
-}
@@ -1,6 +0,0 @@
-package me.vripper.utilities
-
-import java.util.concurrent.ExecutorService
-import java.util.concurrent.Executors
-
-val GLOBAL_EXECUTOR: ExecutorService = Executors.newCachedThreadPool()
@@ -0,0 +1,7 @@
+package me.vripper.utilities
+
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+val taskRunner: ExecutorService = Executors.newFixedThreadPool(6)
+val downloadRunner: ExecutorService = Executors.newVirtualThreadPerTaskExecutor()
@@ -6,7 +6,7 @@ import org.w3c.dom.NodeList
 import javax.xml.xpath.XPathConstants
 import javax.xml.xpath.XPathFactory

-object XpathUtils {
+internal object XpathUtils {
    private val xpath = XPathFactory.newInstance().newXPath()

    @Throws(XpathException::class)
@@ -0,0 +1,5 @@
+package me.vripper.vgapi
+
+import me.vripper.host.Host
+
+internal data class ImageItem(val mainLink: String, val thumbLink: String, val host: Host)
@@ -1,6 +1,6 @@
-package me.vripper.parser
+package me.vripper.vgapi

-data class PostItem(
+internal data class PostItem(
    val threadId: Long,
    val threadTitle: String,
    val postId: Long,
@@ -1,27 +1,30 @@
-package me.vripper.parser
+package me.vripper.vgapi

-import me.vripper.entities.LogEntryEntity
+import dev.failsafe.Failsafe
+import dev.failsafe.function.CheckedSupplier
 import me.vripper.exception.DownloadException
 import me.vripper.exception.PostParseException
-import me.vripper.services.*
-import me.vripper.utilities.Tasks
-import me.vripper.utilities.formatToString
-import net.jodah.failsafe.Failsafe
-import net.jodah.failsafe.function.CheckedSupplier
-import org.apache.hc.client5.http.classic.HttpClient
+import me.vripper.services.HTTPService
+import me.vripper.services.RetryPolicyService
+import me.vripper.services.SettingsService
+import me.vripper.services.VGAuthService
+import me.vripper.tasks.Tasks
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.utilities.RequestLimit
 import org.apache.hc.client5.http.classic.methods.HttpGet
+import org.apache.hc.core5.http.io.entity.EntityUtils
 import org.apache.hc.core5.net.URIBuilder
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
+import java.io.ByteArrayInputStream
 import javax.xml.parsers.SAXParserFactory

-class PostLookupAPIParser(private val threadId: Long, private val postId: Long) : KoinComponent {
-    private val log by me.vripper.delegate.LoggerDelegate()
+internal class PostLookupAPIParser(private val threadId: Long, private val postId: Long) : KoinComponent {
+    private val log by LoggerDelegate()
    private val settingsService: SettingsService by inject()
    private val retryPolicyService: RetryPolicyService by inject()
    private val httpService: HTTPService by inject()
    private val vgAuthService: VGAuthService by inject()
-    private val dataTransaction: DataTransaction by inject()

    @Throws(PostParseException::class)
    fun parse(): ThreadItem? {
@@ -33,33 +36,28 @@ class PostLookupAPIParser(private val threadId: Long, private val postId: Long)
                )
            }.build())
        val threadLookupAPIResponseHandler = ThreadLookupAPIResponseHandler()
-        log.debug("Requesting {}", httpGet)
        Tasks.increment()
        return try {
-            Failsafe.with(retryPolicyService.buildGenericRetryPolicy<Any>()).onFailure {
+            Failsafe.with(retryPolicyService.buildRetryPolicy<Any>("Failed to parse $httpGet: ")).onFailure {
                log.error(
-                    "parsing failed for thread $threadId, post $postId", it.failure
-                )
-                dataTransaction.saveLog(
-                    LogEntryEntity(
-                        type = LogEntryEntity.Type.POST, status = LogEntryEntity.Status.ERROR, message = """
-                    Failed to process thread $threadId, post $postId
-                    ${it.failure.formatToString()}
-                    """.trimIndent()
-                    )
+                    "Failed to process thread $threadId, post $postId", it.exception
                )
            }.get(CheckedSupplier {
-                val connection: HttpClient = httpService.client
-                connection.execute(
+                RequestLimit.getPermit(1)
+                log.debug("Requesting {}", httpGet.uri)
+                httpService.client.execute(
                    httpGet, vgAuthService.context
                ) { response ->
                    if (response.code / 100 != 2) {
                        throw DownloadException("Unexpected response code '${response.code}' for $httpGet")
                    }
-                    factory.newSAXParser()
-                        .parse(response.entity.content, threadLookupAPIResponseHandler)
-                    threadLookupAPIResponseHandler.result
+                    ByteArrayInputStream(EntityUtils.toByteArray(response.entity)).use {
+                        factory.newSAXParser()
+                            .parse(it, threadLookupAPIResponseHandler)
+                        threadLookupAPIResponseHandler.result
+                    }
                }
+
            })
        } catch (e: Exception) {
            throw PostParseException(e)
@@ -1,6 +1,6 @@
-package me.vripper.parser
+package me.vripper.vgapi

-data class ThreadItem(
+internal data class ThreadItem(
    val threadId: Long,
    val title: String,
    val securityToken: String,
@@ -1,28 +1,30 @@
-package me.vripper.parser
+package me.vripper.vgapi

-import me.vripper.entities.LogEntryEntity
+import dev.failsafe.Failsafe
+import dev.failsafe.function.CheckedSupplier
 import me.vripper.exception.DownloadException
 import me.vripper.exception.PostParseException
-import me.vripper.services.*
-import me.vripper.utilities.Tasks
-import me.vripper.utilities.formatToString
-import net.jodah.failsafe.Failsafe
-import net.jodah.failsafe.function.CheckedSupplier
+import me.vripper.services.HTTPService
+import me.vripper.services.RetryPolicyService
+import me.vripper.services.SettingsService
+import me.vripper.services.VGAuthService
+import me.vripper.tasks.Tasks
+import me.vripper.utilities.LoggerDelegate
+import me.vripper.utilities.RequestLimit
 import org.apache.hc.client5.http.classic.methods.HttpGet
+import org.apache.hc.core5.http.io.entity.EntityUtils
 import org.apache.hc.core5.net.URIBuilder
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
-import java.io.BufferedInputStream
-import java.util.*
+import java.io.ByteArrayInputStream
 import javax.xml.parsers.SAXParserFactory

-class ThreadLookupAPIParser(private val threadId: Long) : KoinComponent {
-    private val log by me.vripper.delegate.LoggerDelegate()
+internal class ThreadLookupAPIParser(private val threadId: Long) : KoinComponent {
+    private val log by LoggerDelegate()
    private val cm: HTTPService by inject()
    private val retryPolicyService: RetryPolicyService by inject()
    private val vgAuthService: VGAuthService by inject()
    private val settingsService: SettingsService by inject()
-    private val dataTransaction: DataTransaction by inject()

    @Throws(PostParseException::class)
    fun parse(): ThreadItem {
@@ -35,34 +37,29 @@ class ThreadLookupAPIParser(private val threadId: Long) : KoinComponent {
                )
            }.build())
        val threadLookupAPIResponseHandler = ThreadLookupAPIResponseHandler()
-        log.debug("Requesting {}", httpGet)
        Tasks.increment()
        return try {
-            Failsafe.with(retryPolicyService.buildGenericRetryPolicy<Any>()).onFailure {
+            Failsafe.with(retryPolicyService.buildRetryPolicy<Any>("Failed to parse $httpGet: ")).onFailure {
                log.error(
-                    "parsing failed for thread $threadId",
-                    it.failure
-                )
-                dataTransaction.saveLog(
-                    LogEntryEntity(
-                        type = LogEntryEntity.Type.THREAD, status = LogEntryEntity.Status.ERROR, message = """
-                    Failed to process thread $threadId
-                    ${it.failure.formatToString()}
-                    """.trimIndent()
-                    )
+                    "Failed to process thread $threadId",
+                    it.exception
                )
            }.get(CheckedSupplier {
+                RequestLimit.getPermit(1)
+                log.debug("Requesting {}", httpGet.uri)
                cm.client.execute(
                    httpGet, vgAuthService.context
                ) { response ->
                    if (response.code / 100 != 2) {
                        throw DownloadException("Unexpected response code '${response.code}' for $httpGet")
                    }
-                    factory.newSAXParser().parse(
-                        BufferedInputStream(response.entity.content),
-                        threadLookupAPIResponseHandler
-                    )
-                    threadLookupAPIResponseHandler.result
+                    ByteArrayInputStream(EntityUtils.toByteArray(response.entity)).use {
+                        factory.newSAXParser().parse(
+                            it,
+                            threadLookupAPIResponseHandler
+                        )
+                        threadLookupAPIResponseHandler.result
+                    }
                }
            })
        } catch (e: Exception) {
@@ -1,4 +1,4 @@
-package me.vripper.parser
+package me.vripper.vgapi

 import me.vripper.host.Host
 import me.vripper.services.SettingsService
@@ -7,7 +7,7 @@ import org.koin.core.component.inject
 import org.xml.sax.Attributes
 import org.xml.sax.helpers.DefaultHandler

-class ThreadLookupAPIResponseHandler : KoinComponent, DefaultHandler() {
+internal class ThreadLookupAPIResponseHandler : KoinComponent, DefaultHandler() {
    private val supportedHosts: List<Host> = getKoin().getAll()
    private val settingsService: SettingsService by inject()
    private var error: String = ""
@@ -6,7 +6,6 @@ import "image.proto";
 import "images.proto";
 import "metadata.proto";
 import "log.proto";
-import "logs.proto";
 import "thread.proto";
 import "threads.proto";
 import "settings.proto";
@@ -76,6 +75,9 @@ message LoggedInUser {
 message Version {
  string version = 1;
 }
+message DBMigrationResponse {
+  string message = 1;
+}

 service EndpointService {
  rpc scanLinks (Links) returns (EmptyResponse) {}
@@ -87,7 +89,8 @@ service EndpointService {
  rpc stopAll (IdList) returns (EmptyResponse) {}
  rpc findPost (Id) returns (Post) {}
  rpc findImagesByPostId (Id) returns (Images) {}
-  rpc onUpdateImages (Id) returns (stream Image) {}
+  rpc onUpdateImagesByPostId (Id) returns (stream Image) {}
+  rpc onUpdateImages (EmptyRequest) returns (stream Image) {}
  rpc onDownloadSpeed (EmptyRequest) returns (stream DownloadSpeed) {}
  rpc onVGUserUpdate (EmptyRequest) returns (stream VGUser) {}
  rpc onQueueStateUpdate (EmptyRequest) returns (stream QueueState) {}
@@ -99,11 +102,7 @@ service EndpointService {
  rpc rename (Rename) returns (EmptyResponse) {}
  rpc renameToFirst (RenameToFirst) returns (EmptyResponse) {}
  rpc onStopped (EmptyRequest) returns (stream Id) {}
-  rpc logClear (EmptyRequest) returns (EmptyResponse) {}
-  rpc findAllLogs (EmptyRequest) returns (Logs) {}
  rpc onNewLog (EmptyRequest) returns (stream Log) {}
-  rpc onUpdateLog (EmptyRequest) returns (stream Log) {}
-  rpc onDeleteLogs (EmptyRequest) returns (stream Id) {}
  rpc onNewThread (EmptyRequest) returns (stream Thread) {}
  rpc onUpdateThread (EmptyRequest) returns (stream Thread) {}
  rpc onDeleteThread (EmptyRequest) returns (stream Id) {}
@@ -119,4 +118,6 @@ service EndpointService {
  rpc onUpdateSettings (EmptyRequest) returns (stream Settings) {}
  rpc loggedInUser (EmptyRequest) returns (LoggedInUser) {}
  rpc getVersion (EmptyRequest) returns (Version) {}
+  rpc dbMigration (EmptyRequest) returns (DBMigrationResponse) {}
+  rpc initLogger (EmptyRequest) returns (EmptyResponse) {}
 }
@@ -2,9 +2,11 @@ syntax = "proto3";
 option java_package = "me.vripper.proto";

 message Log {
-  int64 id = 1;
-  string type = 2;
-  string status = 3;
-  string time = 4;
-  string message = 5;
+  int64 sequence = 1;
+  string timestamp = 2;
+  string threadName = 3;
+  string loggerName = 4;
+  string levelString = 5;
+  string formattedMessage = 6;
+  string throwable = 7;
 }
@@ -1,7 +0,0 @@
-syntax = "proto3";
-option java_package = "me.vripper.proto";
-import "log.proto";
-
-message Logs {
-  repeated Log logs = 1;
-}
@@ -7,6 +7,8 @@ message ViperSettings {
  string password = 3;
  bool thanks = 4;
  string host = 5;
+  int64 requestLimit = 6;
+  bool fetchMetadata = 7;
 }

 message DownloadSettings {
@@ -1,172 +1,145 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <databaseChangeLog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
-  xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.4.xsd">
-  <changeSet author="death-claw" id="0001">
-    <createTable tableName="POST">
-      <column autoIncrement="true" name="ID" type="BIGINT">
-        <constraints nullable="false" primaryKey="true" primaryKeyName="POST_PK"/>
-      </column>
-      <column name="DONE" type="INT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="HOSTS" type="VARCHAR(70)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="OUTPUT_PATH" type="VARCHAR(260)"/>
-      <column name="POST_ID" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="STATUS" type="VARCHAR(15)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="THREAD_ID" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="POST_TITLE" type="VARCHAR(255)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="THREAD_TITLE" type="VARCHAR(255)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="FORUM" type="VARCHAR(255)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="TOTAL" type="INT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="SIZE" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="DOWNLOADED" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="URL" type="VARCHAR(200)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="TOKEN" type="VARCHAR(51)">
-        <constraints nullable="false"/>
-      </column>
-      <column defaultValueComputed="CURRENT_TIMESTAMP" name="ADDED_AT" type="TIMESTAMP">
-        <constraints nullable="false"/>
-      </column>
-      <column defaultValue="0" name="RANK" type="INT">
-        <constraints nullable="false"/>
-      </column>
-    </createTable>
-  </changeSet>
-  <changeSet author="death-claw" id="0002">
-    <createTable tableName="IMAGE">
-      <column autoIncrement="true" name="ID" type="BIGINT">
-        <constraints nullable="false" primaryKey="true" primaryKeyName="IMAGE_PK"/>
-      </column>
-      <column name="DOWNLOADED" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="HOST" type="TINYINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="INDEX" type="INT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="POST_ID" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="STATUS" type="VARCHAR(15)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="SIZE" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="URL" type="VARCHAR(200)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="THUMB_URL" type="VARCHAR(200)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="POST_ID_REF" type="BIGINT">
-        <constraints foreignKeyName="IMAGE_POST_ID_REF_POST_ID_FK" nullable="false"
-          references="POST(ID)"/>
-      </column>
-    </createTable>
-  </changeSet>
-  <changeSet author="death-claw" id="0003">
-    <createTable tableName="THREAD">
-      <column autoIncrement="true" name="ID" type="BIGINT">
-        <constraints nullable="false" primaryKey="true" primaryKeyName="THREAD_PK"/>
-      </column>
-      <column name="TOTAL" type="INT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="URL" type="VARCHAR(200)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="THREAD_ID" type="BIGINT">
-        <constraints nullable="false"/>
-      </column>
-      <column name="TITLE" type="VARCHAR(255)">
-        <constraints nullable="false"/>
-      </column>
-    </createTable>
-  </changeSet>
-  <changeSet author="death-claw" id="0004">
-    <createTable tableName="LOG">
-      <column autoIncrement="true" name="ID" type="BIGINT">
-        <constraints nullable="false" primaryKey="true" primaryKeyName="EVENT_PK"/>
-      </column>
-      <column name="TYPE" type="VARCHAR(8)">
-        <constraints nullable="false"/>
-      </column>
-      <column name="STATUS" type="VARCHAR(10)">
-        <constraints nullable="false"/>
-      </column>
-      <column defaultValueComputed="CURRENT_TIMESTAMP" name="TIME" type="TIMESTAMP">
-        <constraints nullable="false"/>
-      </column>
-      <column name="MESSAGE" type="VARCHAR(500)">
-        <constraints nullable="false"/>
-      </column>
-    </createTable>
-  </changeSet>
-  <changeSet author="vripper" id="0005">
-    <createIndex indexName="IMAGE_POST_ID_IDX" tableName="IMAGE">
-      <column name="POST_ID"/>
-    </createIndex>
-    <createIndex indexName="IMAGE_STATUS_IDX" tableName="IMAGE">
-      <column name="STATUS"/>
-    </createIndex>
-    <createIndex indexName="POST_POST_ID_IDX" tableName="POST">
-      <column name="POST_ID"/>
-    </createIndex>
-    <createIndex indexName="POST_STATUS_IDX" tableName="POST">
-      <column name="STATUS"/>
-    </createIndex>
-    <createIndex indexName="THREAD_THREAD_ID_IDX" tableName="THREAD">
-      <column name="THREAD_ID"/>
-    </createIndex>
-  </changeSet>
-  <changeSet id="0006" author="vripper">
-    <addColumn tableName="POST">
-      <column name="FOLDER_NAME" type="VARCHAR(260)" afterColumn="OUTPUT_PATH" defaultValue=""/>
-    </addColumn>
-  </changeSet>
-  <changeSet author="vripper" id="0007">
-    <createTable tableName="METADATA">
-      <column name="POST_ID" type="BIGINT">
-        <constraints unique="true" nullable="false"/>
-      </column>
-      <column name="DATA" type="VARCHAR">
-        <constraints nullable="true"/>
-      </column>
-    </createTable>
-  </changeSet>
-  <changeSet author="vripper" id="0008">
-    <addColumn tableName="IMAGE">
-      <column name="FILENAME" type="VARCHAR(260)" afterColumn="STATUS" defaultValue=""/>
-    </addColumn>
-  </changeSet>
-  <changeSet id="0009" author="vripper">
-    <addUniqueConstraint tableName="POST" columnNames="POST_ID" constraintName="POST__POST_ID_UQ"/>
-    <addUniqueConstraint tableName="THREAD" columnNames="THREAD_ID" constraintName="THREAD__THREAD_ID_UQ"/>
-  </changeSet>
+                   xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.4.xsd">
+    <changeSet author="vripper" id="0001">
+        <createTable tableName="POST">
+            <column autoIncrement="true" name="ID" type="INTEGER">
+                <constraints nullable="false" primaryKey="true" primaryKeyName="POST_PK"/>
+            </column>
+            <column name="DONE" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="HOSTS" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="OUTPUT_PATH" type="TEXT"/>
+            <column name="POST_ID" type="INTEGER">
+                <constraints unique="true" nullable="false"/>
+            </column>
+            <column name="STATUS" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="THREAD_ID" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="POST_TITLE" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="THREAD_TITLE" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="FOLDER_NAME" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="FORUM" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="TOTAL" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="SIZE" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="DOWNLOADED" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="URL" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="TOKEN" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column defaultValueComputed="CURRENT_TIMESTAMP" name="ADDED_AT" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column defaultValue="0" name="RANK" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+    </changeSet>
+    <changeSet author="vripper" id="0002">
+        <createTable tableName="IMAGE">
+            <column autoIncrement="true" name="ID" type="INTEGER">
+                <constraints nullable="false" primaryKey="true" primaryKeyName="IMAGE_PK"/>
+            </column>
+            <column name="DOWNLOADED" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="HOST" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="INDEX" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="POST_ID" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="STATUS" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="FILENAME" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="SIZE" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="URL" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="THUMB_URL" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="POST_ID_REF" type="INTEGER">
+                <constraints foreignKeyName="IMAGE_POST_ID_REF_POST_ID_FK" nullable="false"
+                             references="POST(ID)"/>
+            </column>
+        </createTable>
+    </changeSet>
+    <changeSet author="vripper" id="0003">
+        <createTable tableName="THREAD">
+            <column autoIncrement="true" name="ID" type="INTEGER">
+                <constraints nullable="false" primaryKey="true" primaryKeyName="THREAD_PK"/>
+            </column>
+            <column name="TOTAL" type="INTEGER">
+                <constraints nullable="false"/>
+            </column>
+            <column name="URL" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+            <column name="THREAD_ID" type="INTEGER">
+                <constraints unique="true" nullable="false"/>
+            </column>
+            <column name="TITLE" type="TEXT">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+    </changeSet>
+    <changeSet author="vripper" id="0005">
+        <createIndex indexName="IMAGE_POST_ID_IDX" tableName="IMAGE">
+            <column name="POST_ID"/>
+        </createIndex>
+        <createIndex indexName="IMAGE_STATUS_IDX" tableName="IMAGE">
+            <column name="STATUS"/>
+        </createIndex>
+        <createIndex indexName="POST_POST_ID_IDX" tableName="POST">
+            <column name="POST_ID"/>
+        </createIndex>
+        <createIndex indexName="POST_STATUS_IDX" tableName="POST">
+            <column name="STATUS"/>
+        </createIndex>
+        <createIndex indexName="THREAD_THREAD_ID_IDX" tableName="THREAD">
+            <column name="THREAD_ID"/>
+        </createIndex>
+    </changeSet>
+    <changeSet author="vripper" id="0006">
+        <createTable tableName="METADATA">
+            <column name="POST_ID" type="INTEGER">
+                <constraints unique="true" nullable="false"/>
+            </column>
+            <column name="DATA" type="TEXT">
+                <constraints nullable="true"/>
+            </column>
+        </createTable>
+    </changeSet>
 </databaseChangeLog>
@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <configuration>
+
+    <sequenceNumberGenerator class="ch.qos.logback.core.spi.BasicSequenceNumberGenerator"/>
+
    <appender class="ch.qos.logback.core.ConsoleAppender" name="STDOUT">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
@@ -16,15 +19,21 @@
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${VRIPPER_DIR}/vripper.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>10MB</maxFileSize>
-            <maxHistory>7</maxHistory>
-            <totalSizeCap>1GB</totalSizeCap>
+            <maxHistory>5</maxHistory>
        </rollingPolicy>
    </appender>

+    <appender name="RING" class="me.vripper.RingAppender">
+
+    </appender>
+
    <logger name="Exposed" level="OFF"/>
+    <logger name="me.vripper" level="info"/>
+    <logger name="org.springframework.web.socket.config.WebSocketMessageBrokerStats" level="off"/>

    <root level="INFO">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="FILE"/>
+        <appender-ref ref="RING"/>
    </root>
 </configuration>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
dev-claw	f2c9806665	version bump	2025-03-04 18:03:18 +01:00
dev-clawandGitHub	fd586a522c	fixes #216 (#218 )	2025-03-04 18:00:16 +01:00
dev-clawandGitHub	6be744a7a7	Update release.yml	2025-03-02 14:11:22 +01:00
dev-clawandGitHub	6228551836	Update README.md	2024-12-29 12:48:07 +01:00
dev-claw	b872d5a1a5	update links	2024-12-27 19:27:28 +01:00
dev-claw	61ce16d219	version bump	2024-12-27 19:14:46 +01:00
dev-clawandGitHub	c74d711702	fixes #208 (#209 )	2024-12-27 19:12:07 +01:00
death-clawandGitHub	095e69d3c9	Update README.md	2024-12-27 11:45:42 +01:00
death-clawandGitHub	60bee4df2c	Update README.md	2024-12-27 11:39:59 +01:00
death-clawandGitHub	3d68691037	Update README.md	2024-12-26 22:46:03 +01:00
death-claw	4456d3d797	version bump	2024-12-25 16:24:46 +01:00
death-clawandGitHub	2bcdd81eeb	fixes #206 (#207 )	2024-12-25 16:23:13 +01:00
death-claw	9652c7725e	version bump	2024-12-21 17:59:27 +01:00
death-clawandGitHub	01ed204d12	Update README.md	2024-12-21 17:47:27 +01:00
death-clawandGitHub	b8639be241	fixes #204 (#205 )	2024-12-21 17:44:28 +01:00
death-clawandGitHub	b429c58eb5	version bump (#203 )	2024-12-14 18:01:02 +01:00
UncleRoger33andGitHub	91e74c38b8	Update README.md (#189 ) * Updated DL links to the latest version. * Added info for proxy domains giving 403 errors.	2024-04-22 11:01:47 +01:00
death-claw	d960b13a9f	version bump	2024-04-21 10:25:27 +01:00
death-clawandGitHub	b26f78a576	fixes #187 (#188 )	2024-04-21 10:24:55 +01:00
death-claw	733f5c926e	version bump	2024-04-20 22:34:47 +01:00
death-clawandGitHub	0012e3b8ca	fixes #185 (#186 )	2024-04-20 22:24:40 +01:00