From 2f2f42910a5aff3097d9e1b123210c4f31ecaba7 Mon Sep 17 00:00:00 2001 From: sumit_kumar Date: Mon, 3 Feb 2025 17:12:05 -0800 Subject: [PATCH 1/3] Update disptach-core to the latest available 2.0.0 version. The older version are flagged in security scans. https://github.com/eed3si9n/scalaxb/issues/673 --- .../httpclients_dispatch2000.scala.template | 27 +++++++++++++++++++ ...pclients_dispatch2000_async.scala.template | 26 ++++++++++++++++++ .../scalaxb/compiler/wsdl11/Driver.scala | 3 +++ project/dependencies.scala | 4 +-- 4 files changed, 58 insertions(+), 2 deletions(-) create mode 100644 cli/src/main/resources/httpclients_dispatch2000.scala.template create mode 100644 cli/src/main/resources/httpclients_dispatch2000_async.scala.template diff --git a/cli/src/main/resources/httpclients_dispatch2000.scala.template b/cli/src/main/resources/httpclients_dispatch2000.scala.template new file mode 100644 index 00000000..e8ad8dc4 --- /dev/null +++ b/cli/src/main/resources/httpclients_dispatch2000.scala.template @@ -0,0 +1,27 @@ +package scalaxb + +import java.nio.charset.Charset +import java.time.Duration +import scala.concurrent._, duration._ +import scala.jdk.DurationConverters._ + +trait DispatchHttpClients extends HttpClients { + lazy val httpClient = new DispatchHttpClient {} + def requestTimeout: scala.concurrent.duration.FiniteDuration = 60.seconds + def connectionTimeout: scala.concurrent.duration.FiniteDuration = 5.seconds + + trait DispatchHttpClient extends HttpClient { + import dispatch._, Defaults._ + + // Keep it lazy. See https://github.com/eed3si9n/scalaxb/pull/279 + lazy val http = Http.withConfiguration(_. + setRequestTimeout(requestTimeout.toJava). + setConnectTimeout(connectionTimeout.toJava)) + + def request(in: String, address: java.net.URI, headers: Map[String, String]): String = { + val req = url(address.toString).setBodyEncoding(Charset.forName("UTF-8")) <:< headers << in + val s = http(req > as.String) + s() + } + } +} diff --git a/cli/src/main/resources/httpclients_dispatch2000_async.scala.template b/cli/src/main/resources/httpclients_dispatch2000_async.scala.template new file mode 100644 index 00000000..d3f4333e --- /dev/null +++ b/cli/src/main/resources/httpclients_dispatch2000_async.scala.template @@ -0,0 +1,26 @@ +package scalaxb + +import java.nio.charset.Charset +import java.time.Duration +import scala.concurrent._, duration._ +import scala.jdk.DurationConverters._ + +trait DispatchHttpClientsAsync extends HttpClientsAsync { + lazy val httpClient = new DispatchHttpClient {} + def requestTimeout: scala.concurrent.duration.FiniteDuration = 60.seconds + def connectionTimeout: scala.concurrent.duration.FiniteDuration = 5.seconds + + trait DispatchHttpClient extends HttpClient { + import dispatch._ + + // Keep it lazy. See https://github.com/eed3si9n/scalaxb/pull/279 + lazy val http = Http.withConfiguration(_. + setRequestTimeout(requestTimeout.toJava). + setConnectTimeout(connectionTimeout.toJava)) + + def request(in: String, address: java.net.URI, headers: Map[String, String])(implicit ec: ExecutionContext): Future[String] = { + val req = url(address.toString).setBodyEncoding(Charset.forName("UTF-8")) <:< headers << in + http(req > as.String) + } + } +} diff --git a/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala b/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala index ddc875bc..3aeb92f5 100644 --- a/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala +++ b/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala @@ -254,6 +254,9 @@ class Driver extends Module { driver => case (VersionPattern(1, 0 | 1, _), style) => // Same as 0.13.x generateDispatchFromResource(style, "/httpclients_dispatch0130", config) + case (VersionPattern(2, 0 | 2, _), style) => + // New for 2.0.x + generateDispatchFromResource(style, "/httpclients_dispatch2000", config) } else Nil) ++ (if (config.generateGigahorseClient) (config.gigahorseVersion, config.httpClientStyle) match { case (VersionPattern(x, y, _), HttpClientStyle.Sync) if (x.toInt == 0) && (y.toInt <= 5) => diff --git a/project/dependencies.scala b/project/dependencies.scala index 847be1da..5058d166 100644 --- a/project/dependencies.scala +++ b/project/dependencies.scala @@ -15,9 +15,9 @@ object Dependencies { } } val log4j = "log4j" % "log4j" % "1.2.17" - val defaultDispatchVersion = "1.0.1" + val defaultDispatchVersion = "2.0.0" def dispatch(sv: String) = CrossVersion partialVersion sv match { - case Some((2, x)) if x >= 13 => "org.dispatchhttp" %% "dispatch-core" % "1.1.0" + case Some((2, x)) if x >= 13 => "org.dispatchhttp" %% "dispatch-core" % defaultDispatchVersion case Some(_) => "org.dispatchhttp" %% "dispatch-core" % "1.0.1" case x => sys error s"Unexpected Scala version [$sv], with partial version $x" } From 8714d1aaf86a41c124af8faa949cfb5f262520e9 Mon Sep 17 00:00:00 2001 From: sumit_kumar Date: Tue, 4 Feb 2025 17:05:31 -0800 Subject: [PATCH 2/3] Keeping the default version to 1.0.1 as the integration test are passing against this version. From the project the version of the dispatch-core can be configured using the configuration, compile / scalaxb / scalaxbDispatchVersion. Since the supporting templates are been added to the scalaxb, the dispatch-core 2.0.0 version should work fine. https://github.com/eed3si9n/scalaxb/issues/673 --- project/dependencies.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/project/dependencies.scala b/project/dependencies.scala index 5058d166..847be1da 100644 --- a/project/dependencies.scala +++ b/project/dependencies.scala @@ -15,9 +15,9 @@ object Dependencies { } } val log4j = "log4j" % "log4j" % "1.2.17" - val defaultDispatchVersion = "2.0.0" + val defaultDispatchVersion = "1.0.1" def dispatch(sv: String) = CrossVersion partialVersion sv match { - case Some((2, x)) if x >= 13 => "org.dispatchhttp" %% "dispatch-core" % defaultDispatchVersion + case Some((2, x)) if x >= 13 => "org.dispatchhttp" %% "dispatch-core" % "1.1.0" case Some(_) => "org.dispatchhttp" %% "dispatch-core" % "1.0.1" case x => sys error s"Unexpected Scala version [$sv], with partial version $x" } From 9b10b6d7b57072f0eb7b41c67c547428034be4d8 Mon Sep 17 00:00:00 2001 From: Shikha Date: Sat, 8 Feb 2025 23:22:44 -0800 Subject: [PATCH 3/3] https://github.com/eed3si9n/scalaxb/issues/603 Corrected Driver.scala version pattern match for dispatch-core 2.0.0 version. Udpate Log4j to the latest 2.24.x and fixed Log.scala to support the updated log4j jars. Update scala 2.13 version to the latest 2.13.16 Updated default version of Dispatch-core to 1.2.0 and updated the corresponding pattern to support the .y in Driver.scala --- cli/src/main/scala/scalaxb/compiler/Log.scala | 59 ++++++++++--------- .../scalaxb/compiler/wsdl11/Driver.scala | 4 +- project/dependencies.scala | 12 ++-- 3 files changed, 40 insertions(+), 35 deletions(-) diff --git a/cli/src/main/scala/scalaxb/compiler/Log.scala b/cli/src/main/scala/scalaxb/compiler/Log.scala index 8b269b92..ffba8dbd 100644 --- a/cli/src/main/scala/scalaxb/compiler/Log.scala +++ b/cli/src/main/scala/scalaxb/compiler/Log.scala @@ -21,14 +21,16 @@ */ package scalaxb.compiler -import org.apache.log4j.{Logger, Level, ConsoleAppender, EnhancedPatternLayout} -import org.apache.log4j.spi.LoggingEvent +import org.apache.logging.log4j.{Logger, LogManager, Level} +import org.apache.logging.log4j.core.appender.ConsoleAppender +import org.apache.logging.log4j.core.layout.{PatternLayout, AbstractStringLayout} +import org.apache.logging.log4j.core.LogEvent case class Log(logger: Logger) { def info(message: String, args: Any*): Unit = { - if (args.toSeq.isEmpty) logger.info(message) + if (args.isEmpty) logger.info(message) else try { - logger.info(message.format(args.toSeq: _*)) + logger.info(message.format(args: _*)) } catch { case _: Throwable => logger.info(message) @@ -36,9 +38,9 @@ case class Log(logger: Logger) { } def debug(message: String, args: Any*): Unit = { - if (args.toSeq.isEmpty) logger.debug(message) + if (args.isEmpty) logger.debug(message) else try { - logger.debug(message.format(args.toSeq: _*)) + logger.debug(message.format(args: _*)) } catch { case _: Throwable => logger.debug(message) @@ -46,9 +48,9 @@ case class Log(logger: Logger) { } def warn(message: String, args: Any*): Unit = { - if (args.toSeq.isEmpty) logger.warn(message) + if (args.isEmpty) logger.warn(message) else try { - logger.warn(message.format(args.toSeq: _*)) + logger.warn(message.format(args: _*)) } catch { case _: Throwable => logger.warn(message) @@ -56,9 +58,9 @@ case class Log(logger: Logger) { } def error(message: String, args: Any*): Unit = { - if (args.toSeq.isEmpty) logger.error(message) + if (args.isEmpty) logger.error(message) else try { - logger.error(message.format(args.toSeq: _*)) + logger.error(message.format(args: _*)) } catch { case _: Throwable => logger.error(message) @@ -66,9 +68,9 @@ case class Log(logger: Logger) { } def fatal(message: String, args: Any*): Unit = { - if (args.toSeq.isEmpty) logger.fatal(message) + if (args.isEmpty) logger.fatal(message) else try { - logger.fatal(message.format(args.toSeq: _*)) + logger.fatal(message.format(args: _*)) } catch { case _: Throwable => logger.fatal(message) @@ -77,40 +79,41 @@ case class Log(logger: Logger) { } object Log { - def forName(name: String) = Log(Logger.getLogger(name)) + def forName(name: String) = Log(LogManager.getLogger(name)) def configureLogger(verbose: Boolean): Unit = { - val root = Logger.getRootLogger() + val root = LogManager.getRootLogger.asInstanceOf[org.apache.logging.log4j.core.Logger] val level = if (verbose) Level.TRACE else Level.WARN root.setLevel(level) - val console = new ConsoleAppender(new Formatter) - val threshold = if (verbose) Level.TRACE else Level.INFO - console.setThreshold(threshold) + val console = ConsoleAppender + .createDefaultAppenderForLayout(new Formatter()) + + console.start() root.addAppender(console) } /** * Formats log messages. Prepends a '!' to each line of an exception. */ - class Formatter extends EnhancedPatternLayout("%-5p [%d] %c: %m\n") { - - override def ignoresThrowable = false + class Formatter extends AbstractStringLayout(PatternLayout.createDefaultLayout().getCharset) { - override def format(event: LoggingEvent) : String = { - val message = super.format(event) - val frames = event.getThrowableStrRep() - if (frames == null) { + override def toSerializable(event: LogEvent): String = { + val message = event.getMessage.getFormattedMessage + val throwable = event.getThrown + if (throwable == null) { message } else { val msg = new StringBuilder(message) - for (line <- frames) { - msg.append("! ").append(line).append("\n") + for (line <- throwable.getStackTrace) { + msg.append("! ").append(line.toString).append("\n") } msg.toString } } + override def toByteArray(event: LogEvent): Array[Byte] = { + toSerializable(event).getBytes(getCharset) + } } - -} +} \ No newline at end of file diff --git a/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala b/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala index 3aeb92f5..990f7820 100644 --- a/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala +++ b/cli/src/main/scala/scalaxb/compiler/wsdl11/Driver.scala @@ -251,10 +251,10 @@ class Driver extends Module { driver => case (VersionPattern(0, 14, _), style) => // Same as 0.13.x generateDispatchFromResource(style, "/httpclients_dispatch0130", config) - case (VersionPattern(1, 0 | 1, _), style) => + case (VersionPattern(1, 0 | 1 | 2, _), style) => // Same as 0.13.x generateDispatchFromResource(style, "/httpclients_dispatch0130", config) - case (VersionPattern(2, 0 | 2, _), style) => + case (VersionPattern(2, 0, _), style) => // New for 2.0.x generateDispatchFromResource(style, "/httpclients_dispatch2000", config) } else Nil) ++ diff --git a/project/dependencies.scala b/project/dependencies.scala index 847be1da..a1337e79 100644 --- a/project/dependencies.scala +++ b/project/dependencies.scala @@ -2,7 +2,7 @@ import sbt._ object Dependencies { val scala3 = "3.3.1" - val scala213 = "2.13.12" + val scala213 = "2.13.16" val scala212 = "2.12.18" val jaxb = "javax.xml.bind" % "jaxb-api" % "2.3.1" @@ -14,10 +14,11 @@ object Dependencies { "com.github.scopt" %% "scopt" % "4.1.0" } } - val log4j = "log4j" % "log4j" % "1.2.17" - val defaultDispatchVersion = "1.0.1" + val log4j = "org.apache.logging.log4j" % "log4j-core" % "2.24.3" + val log4jApi = "org.apache.logging.log4j" %% "log4j-api-scala" % "13.1.0" + val defaultDispatchVersion = "1.2.0" def dispatch(sv: String) = CrossVersion partialVersion sv match { - case Some((2, x)) if x >= 13 => "org.dispatchhttp" %% "dispatch-core" % "1.1.0" + case Some((2, x)) if x >= 13 => "org.dispatchhttp" %% "dispatch-core" % "1.2.0" case Some(_) => "org.dispatchhttp" %% "dispatch-core" % "1.0.1" case x => sys error s"Unexpected Scala version [$sv], with partial version $x" } @@ -65,7 +66,8 @@ object Dependencies { launcherInterface % "provided", jaxb % "provided", scopt(sv), - log4j + log4j, + log4jApi ) ++ (sv match { case x if sv.startsWith("2.12.") => Seq(scalaXml2, scalaParserCombinators1) case x => Seq(scalaXml2, scalaParserCombinators2)