Cleaned up logging

.gitignore

@@ -61,6 +61,7 @@ fabric.properties
 # From https://github.com/github/gitignore/blob/master/Gradle.gitignore
 .gradle
 /build/
+/frontend/generated/
 
 # Ignore Gradle GUI config
 gradle-app.setting

LICENSE

@@ -63,13 +63,13 @@
 
      - SLF4J - Simple facade or abstraction for various logging frameworks
        [MIT License]
-       http://www.slf4j.org
+       https://www.slf4j.org
        Copyright 2023
          QOS.ch
 
      - JUL to SLF4J - Java Util Logging implemented over SLF4J
        [MIT License]
-       http://www.slf4j.org
+       https://www.slf4j.org
        Copyright 2023
          QOS.ch
 
@@ -79,6 +79,13 @@
        Copyright 2023
          Vaadin Ltd.
 
+     - Jakarta Servlet  - Jakarta Servlet™ is a standard technology for interacting with the web on the Jakarta EE platform. 
+       [GNU General Public License, version 2, with the Classpath Exception]
+       https://projects.eclipse.org/projects/ee4j.servlet 
+       Copyright 2023
+         Yamini K B
+         ee4j-pmc@eclipse.org
+
      - Updates - Software Update Management
        [The Apache Software License, Version 2.0]
        https://git.dorkbox.com/dorkbox/Updates
@@ -93,3 +100,39 @@
              JetBrains s.r.o. and Kotlin Programming Language contributors
            Kotlin Compiler, Test Data+Libraries, and Tools repository contain third-party code, to which different licenses may apply
            See: https://github.com/JetBrains/kotlin/blob/master/license/README.md
+
+     - FiniteStateMachine - Finite State Machine using the AhoCorasick implementation using a Double Array Trie, java 8+
+       [The Apache Software License, Version 2.0]
+       https://git.dorkbox.com/dorkbox/FSM
+       Copyright 2023
+         Dorkbox LLC
+
+       Extra license information
+         - AhoCorasickDoubleArrayTrie - An extremely fast implementation of Aho Corasick algorithm based on Double Array Trie structure.
+           [The Apache Software License, Version 2.0]
+           https://github.com/hankcs/AhoCorasickDoubleArrayTrie
+           Copyright 2018
+             hankcs <me@hankcs.com>
+
+         - Kotlin - 
+           [The Apache Software License, Version 2.0]
+           https://github.com/JetBrains/kotlin
+           Copyright 2020
+             JetBrains s.r.o. and Kotlin Programming Language contributors
+           Kotlin Compiler, Test Data+Libraries, and Tools repository contain third-party code, to which different licenses may apply
+           See: https://github.com/JetBrains/kotlin/blob/master/license/README.md
+
+         - Updates - Software Update Management
+           [The Apache Software License, Version 2.0]
+           https://git.dorkbox.com/dorkbox/Updates
+           Copyright 2021
+             Dorkbox LLC
+
+           Extra license information
+             - Kotlin - 
+               [The Apache Software License, Version 2.0]
+               https://github.com/JetBrains/kotlin
+               Copyright 2020
+                 JetBrains s.r.o. and Kotlin Programming Language contributors
+               Kotlin Compiler, Test Data+Libraries, and Tools repository contain third-party code, to which different licenses may apply
+               See: https://github.com/JetBrains/kotlin/blob/master/license/README.md

LICENSE.GPLv2_CP

@@ -0,0 +1,347 @@
+The GNU General Public License (GPL)
+
+Version 2, June 1991
+
+Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this license
+document, but changing it is not allowed.
+
+Preamble
+
+The licenses for most software are designed to take away your freedom to share
+and change it.  By contrast, the GNU General Public License is intended to
+guarantee your freedom to share and change free software--to make sure the
+software is free for all its users.  This General Public License applies to
+most of the Free Software Foundation's software and to any other program whose
+authors commit to using it.  (Some other Free Software Foundation software is
+covered by the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+When we speak of free software, we are referring to freedom, not price.  Our
+General Public Licenses are designed to make sure that you have the freedom to
+distribute copies of free software (and charge for this service if you wish),
+that you receive source code or can get it if you want it, that you can change
+the software or use pieces of it in new free programs; and that you know you
+can do these things.
+
+To protect your rights, we need to make restrictions that forbid anyone to deny
+you these rights or to ask you to surrender the rights.  These restrictions
+translate to certain responsibilities for you if you distribute copies of the
+software, or if you modify it.
+
+For example, if you distribute copies of such a program, whether gratis or for
+a fee, you must give the recipients all the rights that you have.  You must
+make sure that they, too, receive or can get the source code.  And you must
+show them these terms so they know their rights.
+
+We protect your rights with two steps: (1) copyright the software, and (2)
+offer you this license which gives you legal permission to copy, distribute
+and/or modify the software.
+
+Also, for each author's protection and ours, we want to make certain that
+everyone understands that there is no warranty for this free software.  If the
+software is modified by someone else and passed on, we want its recipients to
+know that what they have is not the original, so that any problems introduced
+by others will not reflect on the original authors' reputations.
+
+Finally, any free program is threatened constantly by software patents.  We
+wish to avoid the danger that redistributors of a free program will
+individually obtain patent licenses, in effect making the program proprietary.
+To prevent this, we have made it clear that any patent must be licensed for
+everyone's free use or not licensed at all.
+
+The precise terms and conditions for copying, distribution and modification
+follow.
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. This License applies to any program or other work which contains a notice
+placed by the copyright holder saying it may be distributed under the terms of
+this General Public License.  The "Program", below, refers to any such program
+or work, and a "work based on the Program" means either the Program or any
+derivative work under copyright law: that is to say, a work containing the
+Program or a portion of it, either verbatim or with modifications and/or
+translated into another language.  (Hereinafter, translation is included
+without limitation in the term "modification".) Each licensee is addressed as
+"you".
+
+Activities other than copying, distribution and modification are not covered by
+this License; they are outside its scope.  The act of running the Program is
+not restricted, and the output from the Program is covered only if its contents
+constitute a work based on the Program (independent of having been made by
+running the Program).  Whether that is true depends on what the Program does.
+
+1. You may copy and distribute verbatim copies of the Program's source code as
+you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and
+disclaimer of warranty; keep intact all the notices that refer to this License
+and to the absence of any warranty; and give any other recipients of the
+Program a copy of this License along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and you may
+at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Program or any portion of it, thus
+forming a work based on the Program, and copy and distribute such modifications
+or work under the terms of Section 1 above, provided that you also meet all of
+these conditions:
+
+    a) You must cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in whole or
+    in part contains or is derived from the Program or any part thereof, to be
+    licensed as a whole at no charge to all third parties under the terms of
+    this License.
+
+    c) If the modified program normally reads commands interactively when run,
+    you must cause it, when started running for such interactive use in the
+    most ordinary way, to print or display an announcement including an
+    appropriate copyright notice and a notice that there is no warranty (or
+    else, saying that you provide a warranty) and that users may redistribute
+    the program under these conditions, and telling the user how to view a copy
+    of this License.  (Exception: if the Program itself is interactive but does
+    not normally print such an announcement, your work based on the Program is
+    not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If identifiable
+sections of that work are not derived from the Program, and can be reasonably
+considered independent and separate works in themselves, then this License, and
+its terms, do not apply to those sections when you distribute them as separate
+works.  But when you distribute the same sections as part of a whole which is a
+work based on the Program, the distribution of the whole must be on the terms
+of this License, whose permissions for other licensees extend to the entire
+whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest your
+rights to work written entirely by you; rather, the intent is to exercise the
+right to control the distribution of derivative or collective works based on
+the Program.
+
+In addition, mere aggregation of another work not based on the Program with the
+Program (or with a work based on the Program) on a volume of a storage or
+distribution medium does not bring the other work under the scope of this
+License.
+
+3. You may copy and distribute the Program (or a work based on it, under
+Section 2) in object code or executable form under the terms of Sections 1 and
+2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable source
+    code, which must be distributed under the terms of Sections 1 and 2 above
+    on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three years, to
+    give any third party, for a charge no more than your cost of physically
+    performing source distribution, a complete machine-readable copy of the
+    corresponding source code, to be distributed under the terms of Sections 1
+    and 2 above on a medium customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer to
+    distribute corresponding source code.  (This alternative is allowed only
+    for noncommercial distribution and only if you received the program in
+    object code or executable form with such an offer, in accord with
+    Subsection b above.)
+
+The source code for a work means the preferred form of the work for making
+modifications to it.  For an executable work, complete source code means all
+the source code for all modules it contains, plus any associated interface
+definition files, plus the scripts used to control compilation and installation
+of the executable.  However, as a special exception, the source code
+distributed need not include anything that is normally distributed (in either
+source or binary form) with the major components (compiler, kernel, and so on)
+of the operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the source
+code from the same place counts as distribution of the source code, even though
+third parties are not compelled to copy the source along with the object code.
+
+4. You may not copy, modify, sublicense, or distribute the Program except as
+expressly provided under this License.  Any attempt otherwise to copy, modify,
+sublicense or distribute the Program is void, and will automatically terminate
+your rights under this License.  However, parties who have received copies, or
+rights, from you under this License will not have their licenses terminated so
+long as such parties remain in full compliance.
+
+5. You are not required to accept this License, since you have not signed it.
+However, nothing else grants you permission to modify or distribute the Program
+or its derivative works.  These actions are prohibited by law if you do not
+accept this License.  Therefore, by modifying or distributing the Program (or
+any work based on the Program), you indicate your acceptance of this License to
+do so, and all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+6. Each time you redistribute the Program (or any work based on the Program),
+the recipient automatically receives a license from the original licensor to
+copy, distribute or modify the Program subject to these terms and conditions.
+You may not impose any further restrictions on the recipients' exercise of the
+rights granted herein.  You are not responsible for enforcing compliance by
+third parties to this License.
+
+7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues), conditions
+are imposed on you (whether by court order, agreement or otherwise) that
+contradict the conditions of this License, they do not excuse you from the
+conditions of this License.  If you cannot distribute so as to satisfy
+simultaneously your obligations under this License and any other pertinent
+obligations, then as a consequence you may not distribute the Program at all.
+For example, if a patent license would not permit royalty-free redistribution
+of the Program by all those who receive copies directly or indirectly through
+you, then the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply and
+the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any patents or
+other property right claims or to contest validity of any such claims; this
+section has the sole purpose of protecting the integrity of the free software
+distribution system, which is implemented by public license practices.  Many
+people have made generous contributions to the wide range of software
+distributed through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing to
+distribute software through any other system and a licensee cannot impose that
+choice.
+
+This section is intended to make thoroughly clear what is believed to be a
+consequence of the rest of this License.
+
+8. If the distribution and/or use of the Program is restricted in certain
+countries either by patents or by copyrighted interfaces, the original
+copyright holder who places the Program under this License may add an explicit
+geographical distribution limitation excluding those countries, so that
+distribution is permitted only in or among countries not thus excluded.  In
+such case, this License incorporates the limitation as if written in the body
+of this License.
+
+9. The Free Software Foundation may publish revised and/or new versions of the
+General Public License from time to time.  Such new versions will be similar in
+spirit to the present version, but may differ in detail to address new problems
+or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any later
+version", you have the option of following the terms and conditions either of
+that version or of any later version published by the Free Software Foundation.
+If the Program does not specify a version number of this License, you may
+choose any version ever published by the Free Software Foundation.
+
+10. If you wish to incorporate parts of the Program into other free programs
+whose distribution conditions are different, write to the author to ask for
+permission.  For software which is copyrighted by the Free Software Foundation,
+write to the Free Software Foundation; we sometimes make exceptions for this.
+Our decision will be guided by the two goals of preserving the free status of
+all derivatives of our free software and of promoting the sharing and reuse of
+software generally.
+
+NO WARRANTY
+
+11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
+THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE
+STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE
+PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE,
+YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
+ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE
+PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
+INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
+BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER
+OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest possible
+use to the public, the best way to achieve this is to make it free software
+which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program.  It is safest to attach
+them to the start of each source file to most effectively convey the exclusion
+of warranty; and each file should have at least the "copyright" line and a
+pointer to where the full notice is found.
+
+    One line to give the program's name and a brief idea of what it does.
+
+    Copyright (C) <year> <name of author>
+
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+
+    This program is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+    more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc., 59
+    Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this when it
+starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author Gnomovision comes
+    with ABSOLUTELY NO WARRANTY; for details type 'show w'.  This is free
+    software, and you are welcome to redistribute it under certain conditions;
+    type 'show c' for details.
+
+The hypothetical commands 'show w' and 'show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may be
+called something other than 'show w' and 'show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.  Here
+is a sample; alter the names:
+
+    Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+    'Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+    signature of Ty Coon, 1 April 1989
+
+    Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General Public
+License instead of this License.
+
+
+"CLASSPATH" EXCEPTION TO THE GPL
+
+Certain source files distributed by Oracle America and/or its affiliates are
+subject to the following clarification and special exception to the GPL, but
+only where Oracle has expressly included in the particular source file's header
+the words "Oracle designates this particular file as subject to the "Classpath"
+exception as provided by Oracle in the LICENSE file that accompanied this code."
+
+    Linking this library statically or dynamically with other modules is making
+    a combined work based on this library.  Thus, the terms and conditions of
+    the GNU General Public License cover the whole combination.
+
+    As a special exception, the copyright holders of this library give you
+    permission to link this library with independent modules to produce an
+    executable, regardless of the license terms of these independent modules,
+    and to copy and distribute the resulting executable under terms of your
+    choice, provided that you also meet, for each linked independent module,
+    the terms and conditions of the license of that module.  An independent
+    module is a module which is not derived from or based on this library.  If
+    you modify this library, you may extend this exception to your version of
+    the library, but you are not obligated to do so.  If you do not wish to do
+    so, delete this exception statement from your version.

README.md

@@ -23,7 +23,7 @@ Maven Info
     <dependency>
       <groupId>com.dorkbox</groupId>
       <artifactId>VaadinUndertow</artifactId>
-      <version>14.9</version>
+      <version>14.10</version>
     </dependency>
 </dependencies>
 ```
@@ -33,7 +33,7 @@ Gradle Info
 ```
 dependencies {
     ...
-    implementation "com.dorkbox:VaadinUndertow:14.9"
+    implementation "com.dorkbox:VaadinUndertow:14.10"
 }
 ````
 

build.gradle.kts

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2023 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,20 +20,13 @@
 ////// RELEASE : (to sonatype/maven central), <'publish and release' - 'publishToSonatypeAndRelease'>
 ///////////////////////////////
 
-import java.time.Instant
-
-repositories {
-    mavenCentral()
-}
-gradle.startParameter.showStacktrace = ShowStacktrace.ALWAYS   // always show the stacktrace!
-
 plugins {
-    id("com.dorkbox.GradleUtils") version "3.8"
-    id("com.dorkbox.Licensing") version "2.19"
-    id("com.dorkbox.VersionUpdate") version "2.5"
-    id("com.dorkbox.GradlePublish") version "1.17"
+    id("com.dorkbox.GradleUtils") version "3.18"
+    id("com.dorkbox.Licensing") version "2.28"
+    id("com.dorkbox.VersionUpdate") version "2.8"
+    id("com.dorkbox.GradlePublish") version "1.20"
 
-    kotlin("jvm") version "1.7.22"
+    kotlin("jvm") version "1.9.0"
 }
 
 object Extras {
@@ -42,16 +35,15 @@ object Extras {
     const val name = "VaadinUndertow"
     const val id = "VaadinUndertow"
 
-    const val version = "14.9"
+    const val version = "14.10"
 
     const val vendor = "Dorkbox LLC"
     const val vendorUrl = "https://dorkbox.com"
     const val url = "https://git.dorkbox.com/dorkbox/VaadinUndertow"
 
-    val buildDate = Instant.now().toString()
 
     // These MUST be in lock-step with what the GradleVaadin (other project) + gradle.build.kts + VaadinApplication.kt define, otherwise horrific errors can occur.
-    const val vaadinVer = "14.9.4"
+    const val vaadinVer = "14.10.1"
     const val undertowVer = "2.2.22.Final"
 }
 
@@ -100,7 +92,7 @@ licensing {
 
 dependencies {
     api("org.jetbrains.kotlin:kotlin-reflect")
-    api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
+    api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1")
 
     compileOnly("com.vaadin:vaadin:${Extras.vaadinVer}")
 
@@ -110,20 +102,21 @@ dependencies {
     api("io.undertow:undertow-websockets-jsr:${Extras.undertowVer}")
 
     // Uber-fast, ultra-lightweight Java classpath and module path scanner
-    api("io.github.classgraph:classgraph:4.8.154")
+    api("io.github.classgraph:classgraph:4.8.160")
 
     api("com.dorkbox:Updates:1.1")
+    api("com.dorkbox:FSM:1.0")
 
 //    implementation("com.conversantmedia:disruptor:1.2.19")
 
     // awesome logging framework for kotlin.
     // https://www.reddit.com/r/Kotlin/comments/8gbiul/slf4j_loggers_in_3_ways/
     // https://github.com/MicroUtils/kotlin-logging
-    api("io.github.microutils:kotlin-logging:3.0.4")
+    api("io.github.microutils:kotlin-logging:3.0.5")
 
     // 1.8.0-beta4 supports jpms
-    api("org.slf4j:slf4j-api:2.0.5")
-    api("org.slf4j:jul-to-slf4j:2.0.5")
+    api("org.slf4j:slf4j-api:2.0.7")
+    api("org.slf4j:jul-to-slf4j:2.0.7")
 
 
 //    api("ch.qos.logback:logback-core:1.4.5")
@@ -144,7 +137,7 @@ tasks.jar.get().apply {
         attributes["Specification-Vendor"] = Extras.vendor
 
         attributes["Implementation-Title"] = "${Extras.group}.${Extras.id}"
-        attributes["Implementation-Version"] = Extras.buildDate
+        attributes["Implementation-Version"] = GradleUtils.now()
         attributes["Implementation-Vendor"] = Extras.vendor
     }
 }

frontend/index.html

@@ -0,0 +1,36 @@
+<!--
+  ~ Copyright 2023 dorkbox, llc
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<!DOCTYPE html>
+
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <style>
+    body, #outlet {
+      height: 100vh;
+      width: 100%;
+      margin: 0;
+    }
+  </style>
+  <!-- index.ts is included here automatically (either by the dev server or during the build) -->
+</head>
+<body>
+  <!-- This outlet div is where the views are rendered -->
+  <div id="outlet"></div>
+</body>
+</html>

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle.kts

@@ -13,3 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+rootProject.name = "VaadinUndertow"

src/dorkbox/vaadin/VaadinApplication.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2023 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +17,12 @@ package dorkbox.vaadin
 
 import com.vaadin.flow.server.VaadinContext
 import com.vaadin.flow.server.frontend.FrontendUtils
+import dorkbox.fsm.DoubleArrayStringTrie
 import dorkbox.vaadin.undertow.*
 import dorkbox.vaadin.util.CallingClass
 import dorkbox.vaadin.util.TrieClassLoader
 import dorkbox.vaadin.util.UndertowBuilder
 import dorkbox.vaadin.util.VaadinConfig
-import dorkbox.vaadin.util.ahoCorasick.DoubleArrayTrie
 import io.github.classgraph.ClassGraph
 import io.github.classgraph.ScanResult
 import io.undertow.Undertow
@@ -64,12 +64,18 @@ class VaadinApplication : ExceptionHandler {
         /**
          * Gets the version number.
          */
-        const val version = "14.9"
+        const val version = "14.10"
 
         // this must match the version information in the build.gradle.kts file (this is automatically passed into the plugin)
-        const val vaadinVersion = "14.9.4"
+        const val vaadinVersion = "14.10.1"
         const val undertowVersion = "2.2.21.Final"
 
+        // Vaadin 14.9 changed how license checking works, and doesn't include this.
+        const val oshiVersion = "6.4.0"
+
+        // license checker requires JNA
+        const val jnaVersion = "5.12.1"  //5.13 isn't properly published? It cannot be found.
+
         init {
             // Add this project to the updates system, which verifies this class + UUID + version information
             dorkbox.updates.Updates.add(VaadinApplication::class.java, "fc74a52b08c8410fabfea67ac5dca566", version)
@@ -103,9 +109,9 @@ class VaadinApplication : ExceptionHandler {
     private lateinit var servletHttpHandler: HttpHandler
     private lateinit var servletManager: DeploymentManager
 
-    private lateinit var jarStringTrie: DoubleArrayTrie<String>
-    private lateinit var jarUrlTrie: DoubleArrayTrie<URL>
-    private lateinit var diskTrie: DoubleArrayTrie<URL>
+    private lateinit var jarStringTrie: DoubleArrayStringTrie<String>
+    private lateinit var jarUrlTrie: DoubleArrayStringTrie<URL>
+    private lateinit var diskTrie: DoubleArrayStringTrie<URL>
 
     private lateinit var servletBuilder: DeploymentInfo
     private lateinit var serverBuilder: UndertowBuilder
@@ -360,16 +366,14 @@ class VaadinApplication : ExceptionHandler {
         }
 
         // EVERYTHING IS ACCESSED VIA TRIE, NOT VIA HASHMAP! (it's faster this way)
-        jarStringTrie = DoubleArrayTrie(jarStringResourceRequestMap)
-        jarUrlTrie = DoubleArrayTrie(jarUrlResourceRequestMap)
-        diskTrie = DoubleArrayTrie(diskResourceRequestMap)
+        jarStringTrie = DoubleArrayStringTrie(jarStringResourceRequestMap)
+        jarUrlTrie = DoubleArrayStringTrie(jarUrlResourceRequestMap)
+        diskTrie = DoubleArrayStringTrie(diskResourceRequestMap)
 
 
         // so we can use the undertow cache to serve resources, instead of the vaadin servlet (which doesn't cache, and is really slow)
         // NOTE: this will load the stats.json file!
 
-        val debug = vaadinConfig.debug
-
         // for our classloader, we have to make sure that we are BY DIRECTORY, not by file, for the resource array!
         val toTypedArray = jarLocations.map { it.resourceDir }.toSet().toTypedArray()
         this.trieClassLoader = TrieClassLoader(diskTrie, jarStringTrie, toTypedArray, this.javaClass.classLoader, logger)

src/dorkbox/vaadin/undertow/DirectResourceHandler.kt

@@ -18,6 +18,7 @@
 
 package dorkbox.vaadin.undertow
 
+import dorkbox.vaadin.util.logger
 import io.undertow.UndertowLogger
 import io.undertow.io.IoCallback
 import io.undertow.predicate.Predicate
@@ -31,12 +32,12 @@ import io.undertow.server.handlers.cache.ResponseCache
 import io.undertow.server.handlers.encoding.ContentEncodedResourceManager
 import io.undertow.server.handlers.resource.*
 import io.undertow.util.*
+import org.slf4j.Logger
 import java.io.File
 import java.io.IOException
 import java.nio.file.Paths
 import java.util.*
-import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.TimeUnit
+import java.util.concurrent.*
 
 @Suppress("unused")
 /**
@@ -49,6 +50,7 @@ import java.util.concurrent.TimeUnit
  */
 class DirectResourceHandler(@Volatile private var resourceManager: ResourceManager?,
                             @Volatile private var resourceSupplier: ResourceSupplier = DefaultResourceSupplier(resourceManager),
+                            val logger: Logger,
                             private val next: HttpHandler = ResponseCodeHandler.HANDLE_404) : HttpHandler {
 
     private val welcomeFiles = CopyOnWriteArrayList(arrayOf("index.html", "index.htm", "default.html", "default.htm"))
@@ -451,12 +453,13 @@ class DirectResourceHandler(@Volatile private var resourceManager: ResourceManag
 
     }
 
-    private class Wrapper internal constructor(private val location: String,
-                                               private val allowDirectoryListing: Boolean) : HandlerWrapper {
+    private class Wrapper(private val location: String,
+                          private val allowDirectoryListing: Boolean) : HandlerWrapper {
 
         override fun wrap(handler: HttpHandler): HttpHandler {
-            val rm = PathResourceManager(Paths.get(location), 1024)
-            val resourceHandler = DirectResourceHandler(rm)
+            val resourceManager = PathResourceManager(Paths.get(location), 1024)
+            // use a default logger
+            val resourceHandler = DirectResourceHandler(resourceManager, DefaultResourceSupplier(resourceManager), logger())
             resourceHandler.setDirectoryListingEnabled(allowDirectoryListing)
             return resourceHandler
         }

src/dorkbox/vaadin/undertow/JarResourceManager.kt

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2024 dorkbox, llc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 /*
  * Copyright 2012-2019 the original author or authors.
  *
@@ -15,13 +31,13 @@
  */
 package dorkbox.vaadin.undertow
 
-import dorkbox.vaadin.util.ahoCorasick.DoubleArrayTrie
+import dorkbox.fsm.DoubleArrayStringTrie
 import io.undertow.UndertowMessages
 import io.undertow.server.handlers.resource.Resource
 import io.undertow.server.handlers.resource.ResourceChangeListener
 import io.undertow.server.handlers.resource.ResourceManager
 import io.undertow.server.handlers.resource.URLResource
-import mu.KLogger
+import org.slf4j.Logger
 import java.io.IOException
 import java.net.URL
 
@@ -32,20 +48,25 @@ import java.net.URL
  * @author Andy Wilkinson
  * @author Dorkbox LLC
  */
-internal class JarResourceManager(val name: String, val trie: DoubleArrayTrie<URL>, val logger: KLogger) : ResourceManager {
+internal class JarResourceManager(val name: String,
+                                  private val trie: DoubleArrayStringTrie<URL>,
+                                  private val logger: Logger) : ResourceManager {
 
     @Throws(IOException::class)
     override fun getResource(path: String): Resource? {
-        logger.trace { "REQUEST jar: $path" }
-
-        val url = trie[path] ?: return null
-        logger.trace { "TRIE: $url" }
-
-        val resource = URLResource(url, path)
-        if (path.isNotBlank() && path != "/" && resource.contentLength < 0) {
+        val url = trie[path]
+        if (url === null) {
+            logger.trace("REQUEST not found for PATH: {}", path)
             return null
         }
 
+        val resource = URLResource(url, path)
+        if (path.isNotBlank() && path != "/" && resource.contentLength < 0) {
+            logger.trace("REQUEST file not found for PATH: {}, {}", path, url)
+            return null
+        }
+
+        logger.debug("REQUEST found: {}, {}", path, url)
         return resource
     }
 

src/dorkbox/vaadin/undertow/ResourceCollectionManager.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Dorkbox LLC
+ * Copyright 2024 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,14 +16,14 @@
 
 package dorkbox.vaadin.undertow
 
+import dorkbox.vaadin.util.logger
 import io.undertow.UndertowMessages
 import io.undertow.server.handlers.resource.Resource
 import io.undertow.server.handlers.resource.ResourceChangeListener
 import io.undertow.server.handlers.resource.ResourceManager
-import mu.KotlinLogging
 
 class ResourceCollectionManager(private val resources: List<ResourceManager>) : ResourceManager {
-    private val logger = KotlinLogging.logger {}
+    private val logger = logger()
 
     private val changeListenerSupported : Boolean by lazy {
         var supported = true
@@ -77,7 +77,7 @@ class ResourceCollectionManager(private val resources: List<ResourceManager>) :
             try {
                 it.close()
             } catch (e: Exception) {
-                logger.error(e) { "Error closing resourceManager" }
+                logger.error("Error closing resourceManager", e)
             }
         }
     }

src/dorkbox/vaadin/undertow/StrictFileResourceManager.kt

@@ -1,71 +0,0 @@
-/*
- * Copyright 2012-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package dorkbox.vaadin.undertow
-
-import dorkbox.vaadin.util.ahoCorasick.DoubleArrayTrie
-import io.undertow.UndertowMessages
-import io.undertow.server.handlers.resource.FileResource
-import io.undertow.server.handlers.resource.Resource
-import io.undertow.server.handlers.resource.ResourceChangeListener
-import io.undertow.server.handlers.resource.ResourceManager
-import mu.KLogger
-import java.io.File
-import java.io.IOException
-import java.net.URL
-
-/**
- * [ResourceManager] for pre-scanned file resources.
- *
- * @author Dorkbox LLC
- */
-internal class StrictFileResourceManager(val name: String, val trie: DoubleArrayTrie<URL>, val logger: KLogger) : io.undertow.server.handlers.resource.FileResourceManager(File(".")) {
-
-    @Throws(IOException::class)
-    override fun getResource(path: String): Resource? {
-        logger.trace { "REQUEST static: $path" }
-
-        val url = trie[path] ?: return null
-
-        logger.trace { "TRIE: $url" }
-
-        val resource = FileResource(File(url.file), this, path)
-        if (path.isNotBlank() && path != "/" && resource.contentLength < 0) {
-            return null
-        }
-
-        return resource
-    }
-
-    override fun isResourceChangeListenerSupported(): Boolean {
-        return false
-    }
-
-    override fun registerResourceChangeListener(listener: ResourceChangeListener) {
-        throw UndertowMessages.MESSAGES.resourceChangeListenerNotSupported()
-    }
-
-    override fun removeResourceChangeListener(listener: ResourceChangeListener) {
-        throw UndertowMessages.MESSAGES.resourceChangeListenerNotSupported()
-    }
-
-    @Throws(IOException::class)
-    override fun close() {
-    }
-
-    override fun toString(): String {
-        return "FileResourceManager($name)"
-    }
-}

src/dorkbox/vaadin/undertow/TrieFileResourceManager.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2024 dorkbox, llc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dorkbox.vaadin.undertow
+
+import dorkbox.fsm.DoubleArrayStringTrie
+import io.undertow.UndertowMessages
+import io.undertow.server.handlers.resource.*
+import org.slf4j.Logger
+import java.io.File
+import java.io.IOException
+import java.net.URL
+
+/**
+ * [ResourceManager] for pre-scanned file resources.
+ *
+ * @author Dorkbox LLC
+ */
+internal class TrieFileResourceManager(val name: String,
+                                       private val trie: DoubleArrayStringTrie<URL>,
+                                       private val logger: Logger,
+
+
+                                       base: File = File("").absoluteFile,
+
+                                       /**
+                                        * Size to use direct FS to network transfer (if supported by OS/JDK) instead of read/write
+                                        */
+                                       transferMinSize: Long = 1024,
+
+                                       /**
+                                        * Check to validate caseSensitive issues for specific case-insensitive FS.
+                                        * @see io.undertow.server.handlers.resource.PathResourceManager#isFileSameCase(java.nio.file.Path, String)
+                                        */
+                                       caseSensitive: Boolean = false,
+
+                                       /**
+                                        * Check to allow follow symbolic links
+                                        */
+                                       followLinks: Boolean = false,
+
+                                       /**
+                                        * Used if followLinks == true. Set of paths valid to follow symbolic links. If this is empty and followLinks
+                                        * it true then all links will be followed
+                                        */
+                                       vararg safePaths: String)
+
+    : FileResourceManager(base, transferMinSize, caseSensitive, followLinks, *safePaths) {
+
+    @Throws(IOException::class)
+    override fun getResource(path: String): Resource? {
+        val url = trie[path]
+        if (url === null) {
+            logger.trace("REQUEST not found for PATH: {}", path)
+            return null
+        }
+
+        val file = File(url.file)
+        val resource = FileResource(file, this, path)
+        if (path.isNotBlank() && path != "/" && resource.contentLength < 0) {
+            logger.trace("REQUEST file not found for PATH: {}, {}", path, file)
+            return null
+        }
+
+        logger.debug("REQUEST found: {}, {}", path, file)
+        return resource
+    }
+
+    override fun isResourceChangeListenerSupported(): Boolean {
+        return false
+    }
+
+    override fun registerResourceChangeListener(listener: ResourceChangeListener) {
+        throw UndertowMessages.MESSAGES.resourceChangeListenerNotSupported()
+    }
+
+    override fun removeResourceChangeListener(listener: ResourceChangeListener) {
+        throw UndertowMessages.MESSAGES.resourceChangeListenerNotSupported()
+    }
+
+    @Throws(IOException::class)
+    override fun close() {
+    }
+
+    override fun toString(): String {
+        return "FileResourceManager($name)"
+    }
+}

src/dorkbox/vaadin/undertow/WebResource.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2024 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,4 +17,22 @@ package dorkbox.vaadin.undertow
 
 import java.net.URL
 
-data class WebResource(val requestPath: String, val resourcePath: URL)
+// stored in a set, and URL.toString() can cause a DNS lookup!
+data class WebResource(val requestPath: String, val resourcePath: URL) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is WebResource) return false
+
+        if (requestPath != other.requestPath) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        return requestPath.hashCode()
+    }
+
+    override fun toString(): String {
+        return "WebResource(requestPath='$requestPath')"
+    }
+}

src/dorkbox/vaadin/undertow/WebResourceString.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2024 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,4 +17,25 @@ package dorkbox.vaadin.undertow
 
 import java.net.URL
 
-data class WebResourceString(val requestPath: String, val resourcePath: URL, val relativeResourcePath: String, val resourceDir: URL)
+// stored in a set, and URL.toString() can cause a DNS lookup!
+data class WebResourceString(val requestPath: String, val resourcePath: URL, val relativeResourcePath: String, val resourceDir: URL) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is WebResourceString) return false
+
+        if (requestPath != other.requestPath) return false
+        if (relativeResourcePath != other.relativeResourcePath) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = requestPath.hashCode()
+        result = 31 * result + relativeResourcePath.hashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "WebResourceString(requestPath='$requestPath', relativeResourcePath='$relativeResourcePath')"
+    }
+}

src/dorkbox/vaadin/util/CallingClass.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2024 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 package dorkbox.vaadin.util
 
 /**
- *
+ * This class is overridden by the multi-source compile for java 9+
  */
 object CallingClass {
     fun get(): Class<*> {

src/dorkbox/vaadin/util/CommonUtils.kt

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2023 dorkbox, llc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 /*
  * Copyright 2017 Pronghorn Technology LLC
  *
@@ -16,16 +32,20 @@
 
 package dorkbox.vaadin.util
 
-import mu.KLogger
-import mu.KotlinLogging
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import java.io.PrintWriter
 import java.io.StringWriter
 
-inline fun <reified T> T.logger(): KLogger {
+inline fun <reified T> T.logger(): Logger {
     if (T::class.isCompanion) {
-        return KotlinLogging.logger(T::class.java.enclosingClass.name)
+        return LoggerFactory.getLogger(T::class.java.enclosingClass.name)
     }
-    return KotlinLogging.logger(T::class.java.name)
+    return LoggerFactory.getLogger(T::class.java.name)
+}
+
+inline fun <reified T> T.logger(name: String): Logger {
+    return LoggerFactory.getLogger(name)
 }
 
 

src/dorkbox/vaadin/util/Math.kt

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2023 dorkbox, llc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 /*
  * Copyright 2017 Pronghorn Technology LLC
  *
@@ -16,7 +32,7 @@
 
 package dorkbox.vaadin.util
 
-import mu.KotlinLogging
+import org.slf4j.LoggerFactory
 
 private const val MAX_POW2 = 1 shl 30
 
@@ -27,10 +43,13 @@ inline fun <reified T : Any> validatePowerOfTwoCapacity(caller: T,
             value
         }
         else -> {
-            val logger = KotlinLogging.logger(caller.javaClass.name)
-            logger.warn {
-                "${caller.javaClass.simpleName} capacity should be a power of two, but ($value) requested. Using the next available: ${roundToNextPowerOfTwo(value)}."
+            val logger =  if (T::class.isCompanion) {
+                LoggerFactory.getLogger(caller::class.java.enclosingClass.name)
+            } else {
+                LoggerFactory.getLogger(caller.javaClass.name)
             }
+
+            logger.warn("${caller.javaClass.simpleName} capacity should be a power of two, but ($value) requested. Using the next available: ${roundToNextPowerOfTwo(value)}.")
             roundToNextPowerOfTwo(value)
         }
     }

src/dorkbox/vaadin/util/TrieClassLoader.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2024 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,33 +15,39 @@
  */
 package dorkbox.vaadin.util
 
-import dorkbox.vaadin.util.ahoCorasick.DoubleArrayTrie
-import mu.KLogger
+import dorkbox.fsm.DoubleArrayStringTrie
+import org.slf4j.Logger
 import java.net.URL
 import java.net.URLClassLoader
 
 /**
- *
+ * Used to get classloader data, but using a trie to store the lookups
  */
 class TrieClassLoader(
-    private val urlTrie: DoubleArrayTrie<URL>,
-    private val stringTrie: DoubleArrayTrie<String>,
-    urls: Array<URL>, parent: ClassLoader,
-    private val logger: KLogger): URLClassLoader(urls, parent) {
+    private val diskTrie: DoubleArrayStringTrie<URL>,
+    private val jarTrie: DoubleArrayStringTrie<String>,
+
+    jarResourceDirs: Array<URL>, parentClassloader: ClassLoader,
+
+    private val logger: Logger,
+    private val loggerDisk: Logger,
+    private val loggerJar: Logger,
+
+    ): URLClassLoader(jarResourceDirs, parentClassloader) {
 
     override fun getResource(name: String): URL? {
-        logger.trace { "URL Classloader: $name" }
+        logger.trace(name)
 
         // check disk first
-        val diskResourcePath: URL? = urlTrie[name]
+        val diskResourcePath: URL? = diskTrie[name]
         if (diskResourcePath != null) {
-            logger.trace { "TRIE: $diskResourcePath" }
+            loggerDisk.trace(diskResourcePath.file)
             return diskResourcePath
         }
 
-        val jarResourcePath: String? = stringTrie[name]
+        val jarResourcePath: String? = jarTrie[name]
         if (jarResourcePath != null) {
-            logger.trace { "TRIE: $jarResourcePath" }
+            loggerJar.trace(jarResourcePath)
             return super.getResource(jarResourcePath)
         }
 

src/dorkbox/vaadin/util/UndertowBuilder.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2023 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,16 +18,38 @@ package dorkbox.vaadin.util
 import io.undertow.Undertow
 import io.undertow.Undertow.ListenerBuilder
 import io.undertow.connector.ByteBufferPool
+import io.undertow.security.api.AuthenticationMechanism
+import io.undertow.security.api.AuthenticationMode
+import io.undertow.security.handlers.AuthenticationCallHandler
+import io.undertow.security.handlers.AuthenticationConstraintHandler
+import io.undertow.security.handlers.AuthenticationMechanismsHandler
+import io.undertow.security.handlers.SecurityInitialHandler
+import io.undertow.security.idm.IdentityManager
+import io.undertow.security.impl.BasicAuthenticationMechanism
 import io.undertow.server.HttpHandler
 import org.xnio.Option
 import org.xnio.XnioWorker
-import java.util.concurrent.Executor
+import java.util.concurrent.*
 import javax.net.ssl.KeyManager
 import javax.net.ssl.SSLContext
 import javax.net.ssl.TrustManager
 
 @Suppress("unused")
 class UndertowBuilder() {
+    companion object {
+        fun addSecurity(toWrap: HttpHandler, identityManager: IdentityManager): HttpHandler {
+            var handler = toWrap
+            handler = AuthenticationCallHandler(handler)
+            handler = AuthenticationConstraintHandler(handler)
+
+            val mechanisms = listOf<AuthenticationMechanism>(BasicAuthenticationMechanism("My Realm"))
+            handler = AuthenticationMechanismsHandler(handler, mechanisms)
+            handler = SecurityInitialHandler(AuthenticationMode.PRO_ACTIVE, identityManager, handler)
+
+            return handler
+        }
+    }
+
     private val builder = Undertow.builder()
 
     // the LAST http (or https) listener will recorded as the listener used.
@@ -153,7 +175,6 @@ class UndertowBuilder() {
      * to the various worker-related configuration (ioThreads, workerThreads, workerOptions)
      * when [Undertow.start] is called.
      * Additionally, this newly created worker will be shutdown when [Undertow.stop] is called.
-     * <br></br>
      *
      *
      * When non-null, the provided [XnioWorker] will be reused instead of creating a new [XnioWorker]

src/dorkbox/vaadin/util/VaadinConfig.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 dorkbox, llc
+ * Copyright 2023 dorkbox, llc
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -74,11 +74,8 @@ class VaadinConfig(runningAsJar: Boolean, tempDir: File) {
                 // this file from the jar to the temp location.
                 File(tempDir, defaultTokenFile).absolutePath
             } else {
-                if (tokenInJar.path.startsWith("/")) {
-                    tokenInJar.path.substring(1)
-                } else {
-                    tokenInJar.path
-                }
+                // loading as a FILE, so we must make sure
+                tokenInJar.path
             }
 
             tokenJson = JsonUtil.parse(tokenInJar.readText(Charsets.UTF_8)) as JsonObject?
@@ -97,8 +94,8 @@ class VaadinConfig(runningAsJar: Boolean, tempDir: File) {
 
         if (tokenFileName.isEmpty() || tokenJson == null || !tokenJson.hasKey(InitParameters.SERVLET_PARAMETER_PRODUCTION_MODE)) {
             // this is a problem! we must configure the system first via gradle!
-            throw java.lang.RuntimeException("Unable to continue! Error reading token!" +
-                    "You must FIRST compile the vaadin resources for DEV or PRODUCTION mode!")
+            throw java.lang.RuntimeException("Unable to continue! Error reading token! " +
+                    "You must FIRST compile the vaadin resources for Development or Production mode!")
         }
 
 
@@ -150,7 +147,7 @@ class VaadinConfig(runningAsJar: Boolean, tempDir: File) {
         // the stats.json http request will be coming from the local box (so everything is local. Only when on a specific IP should that specific IP be used)
         servlet
             .addInitParam(InitParameters.EXTERNAL_STATS_FILE, "true")
-            .addInitParam(InitParameters.EXTERNAL_STATS_URL, "$url")
+            .addInitParam(InitParameters.EXTERNAL_STATS_URL, url)
     }
 
     /**

src/dorkbox/vaadin/util/ahoCorasick/State.kt

@@ -1,202 +0,0 @@
-/*
- * AhoCorasickDoubleArrayTrie Project
- *      https://github.com/hankcs/AhoCorasickDoubleArrayTrie
- *
- * Copyright 2008-2018 hankcs <me@hankcs.com>
- * You may modify and redistribute as long as this attribution remains.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dorkbox.vaadin.util.ahoCorasick
-
-import java.util.*
-
-/**
- *
- *
- * A state has the following functions
- *
- *
- *
- *
- *  * success; successfully transferred to another state
- *  * failure; if you cannot jump along the string, jump to a shallow node
- *  * emits; hit a pattern string
- *
- *
- *
- *
- *
- * The root node is slightly different. The root node has no failure function. Its "failure" refers to moving to the next state according to the string path. Other nodes have a failure state.
- *
- *
- * @author Robert Bor
- */
-class State
-/**
- * Construct a node with a depth of depth
- */
-@JvmOverloads constructor(
-    /**
-     * The length of the pattern string is also the depth of this state
-     */
-        /**
-         * Get node depth
-         */
-        val depth: Int = 0) {
-
-    /**
-     * The fail function, if there is no match, jumps to this state.
-     */
-    private var failure: State? = null
-
-    /**
-     * Record mode string as long as this state is reachable
-     */
-    private var emits: MutableSet<Int>? = null
-    /**
-     * The goto table, also known as the transfer function. Move to the next state based on the next character of the string
-     */
-    private val success = TreeMap<Char, State>()
-
-    /**
-     * Corresponding subscript in double array
-     */
-    var index: Int = 0
-
-    /**
-     * Get the largest value
-     */
-    val largestValueId: Int?
-        get() = if (emits == null || emits!!.size == 0) {
-            null
-        }
-        else emits!!.iterator().next()
-
-    /**
-     * Whether it is the termination status
-     */
-    val isAcceptable: Boolean
-        get() = this.depth > 0 && this.emits != null
-
-    val states: Collection<State>
-        get() = this.success.values
-
-    val transitions: Collection<Char>
-        get() = this.success.keys
-
-    /**
-     * Add a matching pattern string (this state corresponds to this pattern string)
-     */
-    fun addEmit(keyword: Int) {
-        if (this.emits == null) {
-            this.emits = TreeSet(Collections.reverseOrder())
-        }
-        this.emits!!.add(keyword)
-    }
-
-    /**
-     * Add some matching pattern strings
-     */
-    fun addEmit(emits: Collection<Int>) {
-        for (emit in emits) {
-            addEmit(emit)
-        }
-    }
-
-    /**
-     * Get the pattern string represented by this node (we)
-     */
-    fun emit(): Collection<Int> {
-        return this.emits ?: emptyList()
-    }
-
-    /**
-     * Get the failure status
-     */
-    fun failure(): State? {
-        return this.failure
-    }
-
-    /**
-     * Set the failure status
-     */
-    fun setFailure(failState: State,
-                   fail: IntArray) {
-        this.failure = failState
-        fail[index] = failState.index
-    }
-
-    /**
-     * Move to the next state
-     *
-     * @param character wants to transfer by this character
-     * @param ignoreRootState Whether to ignore the root node, it should be true if the root node calls itself, otherwise it is false
-     *
-     * @return transfer result
-     */
-    private fun nextState(character: Char,
-                          ignoreRootState: Boolean): State? {
-        var nextState: State? = this.success[character]
-        if (!ignoreRootState && nextState == null && this.depth == 0) {
-            nextState = this
-        }
-        return nextState
-    }
-
-    /**
-     * According to the character transfer, the root node transfer failure will return itself (never return null)
-     */
-    fun nextState(character: Char): State? {
-        return nextState(character, false)
-    }
-
-    /**
-     * According to character transfer, any node transfer failure will return null
-     */
-    fun nextStateIgnoreRootState(character: Char): State? {
-        return nextState(character, true)
-    }
-
-    fun addState(character: Char): State {
-        var nextState = nextStateIgnoreRootState(character)
-        if (nextState == null) {
-            nextState = State(this.depth + 1)
-            this.success[character] = nextState
-        }
-        return nextState
-    }
-
-    override fun toString(): String {
-        val sb = StringBuilder("State{")
-        sb.append("depth=").append(depth)
-        sb.append(", ID=").append(index)
-        sb.append(", emits=").append(emits)
-        sb.append(", success=").append(success.keys)
-        sb.append(", failureID=").append(if (failure == null) "-1" else failure!!.index)
-        sb.append(", failure=").append(failure)
-        sb.append('}')
-        return sb.toString()
-    }
-
-    /**
-     * Get goto table
-     */
-    fun getSuccess(): Map<Char, State> {
-        return success
-    }
-}
-/**
- * Construct a node with a depth of 0
- */

src9/module-info.java

@@ -2,74 +2,73 @@ module dorkbox.vaadin {
     exports dorkbox.vaadin;
     exports dorkbox.vaadin.util;
 
-    requires dorkbox.updates;
-    requires org.slf4j;
+    requires transitive dorkbox.updates;
+    requires transitive org.slf4j;
 
 //    requires static ch.qos.logback.classic;
 
 //    requires vaadin;
 
     //Vaadin UI components used
-    requires flow.data;
-    requires flow.server;
-    requires vaadin.accordion.flow;
-    requires vaadin.accordion;
-    requires vaadin.app.layout.flow;
-    requires vaadin.app.layout;
-    requires vaadin.button.flow;
-    requires vaadin.button;
-    requires vaadin.charts.flow;
-    requires vaadin.charts;
-    requires vaadin.checkbox.flow;
-    requires vaadin.checkbox;
-    requires vaadin.combo.box.flow;
-    requires vaadin.combo.box;
-    requires vaadin.confirm.dialog.flow;
-    requires vaadin.confirm.dialog;
-    requires vaadin.context.menu.flow;
-    requires vaadin.context.menu;
-    requires vaadin.control.state.mixin;
-    requires vaadin.cookie.consent.flow;
-    requires vaadin.cookie.consent;
-    requires vaadin.core;
-    requires vaadin.custom.field.flow;
-    requires vaadin.custom.field;
-    requires vaadin.date.picker.flow;
-    requires vaadin.date.picker;
-    requires vaadin.details.flow;
-    requires vaadin.details;
-    requires vaadin.development.mode.detector;
-    requires vaadin.dialog.flow;
-    requires vaadin.dialog;
-    requires vaadin.element.mixin;
-    requires vaadin.grid.flow;
-    requires vaadin.list.box.flow;
-    requires vaadin.list.box;
-    requires vaadin.list.mixin;
-    requires vaadin.login.flow;
-    requires vaadin.login;
-    requires vaadin.lumo.theme;
-    requires vaadin.ordered.layout.flow;
-    requires vaadin.ordered.layout;
-    requires vaadin.progress.bar.flow;
-    requires vaadin.progress.bar;
-    requires vaadin.radio.button.flow;
-    requires vaadin.radio.button;
-    requires vaadin.text.field.flow;
-    requires vaadin.text.field;
-    requires vaadin.upload.flow;
-    requires vaadin.upload;
-    requires vaadin.usage.statistics;
+    requires transitive flow.data;
+    requires transitive flow.server;
+    requires transitive vaadin.accordion.flow;
+    requires transitive vaadin.accordion;
+    requires transitive vaadin.app.layout.flow;
+    requires transitive vaadin.app.layout;
+    requires transitive vaadin.button.flow;
+    requires transitive vaadin.button;
+    requires transitive vaadin.charts.flow;
+    requires transitive vaadin.charts;
+    requires transitive vaadin.checkbox.flow;
+    requires transitive vaadin.checkbox;
+    requires transitive vaadin.combo.box.flow;
+    requires transitive vaadin.combo.box;
+    requires transitive vaadin.confirm.dialog.flow;
+    requires transitive vaadin.confirm.dialog;
+    requires transitive vaadin.context.menu.flow;
+    requires transitive vaadin.context.menu;
+    requires transitive vaadin.control.state.mixin;
+    requires transitive vaadin.cookie.consent.flow;
+    requires transitive vaadin.cookie.consent;
+    requires transitive vaadin.core;
+    requires transitive vaadin.custom.field.flow;
+    requires transitive vaadin.custom.field;
+    requires transitive vaadin.date.picker.flow;
+    requires transitive vaadin.date.picker;
+    requires transitive vaadin.details.flow;
+    requires transitive vaadin.details;
+    requires transitive vaadin.development.mode.detector;
+    requires transitive vaadin.dialog.flow;
+    requires transitive vaadin.dialog;
+    requires transitive vaadin.element.mixin;
+    requires transitive vaadin.grid.flow;
+    requires transitive vaadin.list.box.flow;
+    requires transitive vaadin.list.box;
+    requires transitive vaadin.list.mixin;
+    requires transitive vaadin.login.flow;
+    requires transitive vaadin.login;
+    requires transitive vaadin.lumo.theme;
+    requires transitive vaadin.ordered.layout.flow;
+    requires transitive vaadin.ordered.layout;
+    requires transitive vaadin.progress.bar.flow;
+    requires transitive vaadin.progress.bar;
+    requires transitive vaadin.radio.button.flow;
+    requires transitive vaadin.radio.button;
+    requires transitive vaadin.text.field.flow;
+    requires transitive vaadin.text.field;
+    requires transitive vaadin.upload.flow;
+    requires transitive vaadin.upload;
+    requires transitive vaadin.usage.statistics;
 
-    requires xnio.api;
+    requires transitive xnio.api;
 
 //    requires com.conversantmedia.disruptor;
-    requires io.github.classgraph;
+    requires transitive io.github.classgraph;
 
-    requires undertow.core;
-    requires undertow.servlet;
-    requires undertow.websockets.jsr;
+    requires transitive undertow.core;
+    requires transitive undertow.servlet;
+    requires transitive undertow.websockets.jsr;
 
-    requires kotlin.stdlib;
-    requires java.base;
+    requires transitive kotlin.stdlib;
 }