diff --git a/.idea/gradle.xml b/.idea/gradle.xml index 415dceafa5fb83..63f633ea5d34fc 100644 --- a/.idea/gradle.xml +++ b/.idea/gradle.xml @@ -12,6 +12,7 @@ + - \ No newline at end of file + diff --git a/.idea/misc.xml b/.idea/misc.xml index 29a2fcd8ff671c..39b13d14036d5a 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -5,8 +5,9 @@ + - + diff --git a/components/ide/jetbrains/launcher/main.go b/components/ide/jetbrains/launcher/main.go index 9dcde103cf9b01..f7883c8143f8e0 100644 --- a/components/ide/jetbrains/launcher/main.go +++ b/components/ide/jetbrains/launcher/main.go @@ -415,7 +415,7 @@ func resolveToolboxLink(wsInfo *supervisor.WorkspaceInfoResponse) (string, error Scheme: "jetbrains", Host: "gateway", Path: "io.gitpod.toolbox.gateway/open-in-toolbox", - RawQuery: fmt.Sprintf("host=%s&workspaceId=%s&debugWorkspace=%t", gitpodUrl.Hostname(), wsInfo.WorkspaceId, debugWorkspace), + RawQuery: fmt.Sprintf("userId=%shost=%s&workspaceId=%s&debugWorkspace=%t", wsInfo.OwnerId, gitpodUrl.Hostname(), wsInfo.WorkspaceId, debugWorkspace), } return link.String(), nil } diff --git a/components/ide/jetbrains/toolbox/.gitattributes b/components/ide/jetbrains/toolbox/.gitattributes new file mode 100644 index 00000000000000..afd59d8fce15d0 --- /dev/null +++ b/components/ide/jetbrains/toolbox/.gitattributes @@ -0,0 +1,8 @@ +# +# https://help.github.com/articles/dealing-with-line-endings/ +# +# Linux start script should use lf +/gradlew text eol=lf + +# These are Windows script files and should use crlf +*.bat text eol=crlf diff --git a/components/ide/jetbrains/toolbox/.gitignore b/components/ide/jetbrains/toolbox/.gitignore new file mode 100644 index 00000000000000..83d0ea8e397220 --- /dev/null +++ b/components/ide/jetbrains/toolbox/.gitignore @@ -0,0 +1,6 @@ +# Gradle +.gradle +build + +# IntelliJ IDEA +.idea diff --git a/components/ide/jetbrains/toolbox/BUILD.yaml b/components/ide/jetbrains/toolbox/BUILD.yaml new file mode 100644 index 00000000000000..2284e3a76d1a7a --- /dev/null +++ b/components/ide/jetbrains/toolbox/BUILD.yaml @@ -0,0 +1,30 @@ +packages: + - name: plugin-stable + type: generic + deps: + - components/supervisor-api/java:lib + - components/public-api/java:lib + srcs: + - "**/*.kt" + - "**/*.kts" + - src/main/resources/* + - gradle.properties + - gradlew + - gradle/* + - build.sh + env: + - JB_QUALIFIER=stable + - SDKMAN_DIR=/home/gitpod/.sdkman + config: + commands: + - - "bash" + - "-c" + - > + echo java=21.0.3.fx-zulu > .sdkmanrc + && source "$SDKMAN_DIR/bin/sdkman-init.sh" + && sdk env install + && ./build.sh "0.0.1-${version}" + && mv ./build/distributions/io.gitpod.toolbox.gateway.zip .toolbox.zip + && rm -rf * + && rm -rf .gradle .kotlin .sdkmanrc + && mv .toolbox.zip toolbox.zip diff --git a/components/ide/jetbrains/toolbox/README.md b/components/ide/jetbrains/toolbox/README.md new file mode 100644 index 00000000000000..34d7aa78aa3064 --- /dev/null +++ b/components/ide/jetbrains/toolbox/README.md @@ -0,0 +1,42 @@ +# Gitpod Classic Toolbox Plugin + +Provides a way to connect to Gitpod Classic workspaces within the JetBrains Toolbox App. + +## How to Develop with Gitpod Flex + +- Start an environment on [Gitpod Flex](https://app.gitpod.io) with current repository +- Connect to the environment via **JetBrains Gateway** (because we want to restart Toolbox) SSH feature (user: gitpod_devcontainer) +- [optional] Copy ./sync-flex.sh locally and chmod +x, the script is written for macOS, please adjust it if you're using other OS +- Exec `./sync-flex.sh ` +- Exec gradle task `./gradlew buildPluginFlex`, it will deploy plugin changes and restart Toolbox automatically. + +## How to Develoop with Gitpod Classic + +- [optional] Set your SSH Keys up https://catfood.gitpod.cloud/user/keys +- Open a workspace on Gitpod Classic with current repository +- Update default Java version to Java 21: `sdk install java 21.0.3.fx-zulu` +- [optional] Connect to the environment via **JetBrains Gateway** (if you want to keep the editor opening when deploy Toolbox Plugin) +- [optional] Copy ./sync-classic.sh locally and chmod +x, update the script base on your Gitpod host +- Exec `./sync-classic.sh ` +- Exec gradle task `./gradlew buildPluginFlex`, it will deploy plugin changes and restart Toolbox automatically. + +## How to Develop locally + +### Requires +- Java 21 +- IntelliJ IDEA +- Toolbox App + +### Steps +- Clone and open this project locally in IntelliJ IDEA +- Run the `./gradlew copyPlugin` task to build and copy the plugin into Toolbox's plugin directory +- Restart the Toolbox Application if needed (for macOS, it can restart by copyPlugin task) + +> To open the Toolbox App in debug mode +> ```bash +> TOOLBOX_DEV_DEBUG_SUSPEND=true && open /Applications/JetBrains\ Toolbox.app +> ``` + +## Install Plugin manually + +If you download the plugin from the summary of GitHub Actions, you will need to install it manually. More details can be found [here (internal notes)](https://www.notion.so/gitpod/WIP-Experiment-Toolbox-gateway-feature-with-Gitpod-Classic-14c6425f2d52800297bbf98b88842ac7). diff --git a/components/ide/jetbrains/toolbox/build.gradle.kts b/components/ide/jetbrains/toolbox/build.gradle.kts new file mode 100644 index 00000000000000..fc75da08e0e440 --- /dev/null +++ b/components/ide/jetbrains/toolbox/build.gradle.kts @@ -0,0 +1,238 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +import com.github.jk1.license.filter.ExcludeTransitiveDependenciesFilter +import com.github.jk1.license.render.JsonReportRenderer +import org.jetbrains.kotlin.com.intellij.openapi.util.SystemInfoRt +import org.jetbrains.kotlin.gradle.dsl.JvmTarget +import java.nio.file.Path +import java.time.LocalDateTime +import java.time.format.DateTimeFormatter +import kotlin.io.path.div + + +plugins { + alias(libs.plugins.kotlin) + alias(libs.plugins.serialization) + `java-library` + alias(libs.plugins.dependency.license.report) + id("com.github.johnrengelman.shadow") version "8.1.1" + alias(libs.plugins.gradle.wrapper) +} + +buildscript { + dependencies { + classpath(libs.marketplace.client) + } +} + +repositories { + mavenCentral() + maven("https://packages.jetbrains.team/maven/p/tbx/toolbox-api") +} + +jvmWrapper { + unixJvmInstallDir = "jvm" + winJvmInstallDir = "jvm" + linuxAarch64JvmUrl = "https://cache-redirector.jetbrains.com/intellij-jbr/jbr_jcef-21.0.5-linux-aarch64-b631.28.tar.gz" + linuxX64JvmUrl = "https://cache-redirector.jetbrains.com/intellij-jbr/jbr_jcef-21.0.5-linux-x64-b631.28.tar.gz" + macAarch64JvmUrl = "https://cache-redirector.jetbrains.com/intellij-jbr/jbr_jcef-21.0.5-osx-aarch64-b631.28.tar.gz" + macX64JvmUrl = "https://cache-redirector.jetbrains.com/intellij-jbr/jbr_jcef-21.0.5-osx-x64-b631.28.tar.gz" + windowsX64JvmUrl = "https://cache-redirector.jetbrains.com/intellij-jbr/jbr_jcef-21.0.5-windows-x64-b631.28.tar.gz" +} + +dependencies { + implementation(project(":supervisor-api")) + implementation(project(":gitpod-publicapi")) + + // com.connectrpc https://mvnrepository.com/artifact/com.connectrpc + // connect rpc dependencies + implementation("com.squareup.okhttp3:okhttp:4.12.0") + implementation("com.connectrpc:connect-kotlin-okhttp:0.6.0") + implementation("com.connectrpc:connect-kotlin:0.6.0") + // Java specific dependencies. + implementation("com.connectrpc:connect-kotlin-google-java-ext:0.6.0") + implementation("com.google.protobuf:protobuf-java:4.27.2") + // WebSocket + compileOnly("javax.websocket:javax.websocket-api:1.1") + compileOnly("org.eclipse.jetty.websocket:websocket-api:9.4.54.v20240208") + implementation("org.eclipse.jetty.websocket:javax-websocket-client-impl:9.4.54.v20240208") + // RD-Core https://mvnrepository.com/artifact/com.jetbrains.rd/rd-core + implementation("com.jetbrains.rd:rd-core:2024.1.1") + + compileOnly(libs.bundles.toolbox.plugin.api) +// implementation(libs.gateway.api) + implementation(libs.slf4j) + implementation(libs.bundles.serialization) + implementation(libs.coroutines.core) + implementation(libs.okhttp) +} + +val pluginId = "io.gitpod.toolbox.gateway" +val defaultVersion = "0.0.1-local-${LocalDateTime.now().format(DateTimeFormatter.ofPattern("MMddHHmm"))}" +val pluginVersion = providers.gradleProperty("pluginVersion").map { it.ifBlank { defaultVersion } }.getOrElse(defaultVersion) + +println("Plugin version: $pluginVersion") + +tasks.shadowJar { + archiveBaseName.set(pluginId) + archiveVersion.set(pluginVersion) + + val excludedGroups = listOf( + "com.jetbrains.toolbox.gateway", + "com.jetbrains", + "org.jetbrains", +// "com.squareup.okhttp3", +// "org.slf4j", + "org.jetbrains.intellij", +// "com.squareup.okio", + "kotlin." + ) + + val includeGroups = listOf( + "com.jetbrains.rd" + ) + + dependencies { + exclude { + excludedGroups.any { group -> + if (includeGroups.any { includeGroup -> it.name.startsWith(includeGroup) }) { + return@any false + } + it.name.startsWith(group) + } + } + } +} + +licenseReport { + renderers = arrayOf(JsonReportRenderer("dependencies.json")) + filters = arrayOf(ExcludeTransitiveDependenciesFilter()) +} + + +kotlin { + jvmToolchain(21) +} +tasks.compileKotlin { + compilerOptions.jvmTarget.set(JvmTarget.JVM_21) +} + +val restartToolbox by tasks.creating { + group = "01.Gitpod" + description = "Restarts the JetBrains Toolbox app." + + doLast { + when { + SystemInfoRt.isMac -> { + exec { + commandLine("sh", "-c", "pkill -f 'JetBrains Toolbox' || true") + } + Thread.sleep(3000) + exec { + commandLine("sh", "-c", "echo debugClean > ~/Library/Logs/JetBrains/Toolbox/toolbox.log") + } + exec { +// environment("TOOLBOX_DEV_DEBUG_SUSPEND", "true") + commandLine("open", "/Applications/JetBrains Toolbox.app") + } + } + + else -> { + println("restart Toolbox to make plugin works.") + } + } + } +} + +val buildPluginFlex by tasks.creating(Sync::class.java) { + group = "01.Gitpod" + + dependsOn(tasks.named("shadowJar")) + from(tasks.named("shadowJar").get().outputs.files) + + val targetDir = Path.of("./build/flex") / pluginId + + from("src/main/resources") { + include("extension.json") + include("dependencies.json") + include("icon.svg") + include("icon-gray.svg") + } + + into(targetDir) +} + +val copyPlugin by tasks.creating(Sync::class.java) { + group = "01.Gitpod" + + dependsOn(tasks.named("shadowJar")) + from(tasks.named("shadowJar").get().outputs.files) + + val userHome = System.getProperty("user.home").let { Path.of(it) } + val toolboxCachesDir = when { + SystemInfoRt.isWindows -> System.getenv("LOCALAPPDATA")?.let { Path.of(it) } ?: (userHome / "AppData" / "Local") + // currently this is the location that TBA uses on Linux + SystemInfoRt.isLinux -> System.getenv("XDG_DATA_HOME")?.let { Path.of(it) } ?: (userHome / ".local" / "share") + SystemInfoRt.isMac -> userHome / "Library" / "Caches" + else -> error("Unknown os") + } / "JetBrains" / "Toolbox" + + val pluginsDir = when { + SystemInfoRt.isWindows -> toolboxCachesDir / "cache" + SystemInfoRt.isLinux || SystemInfoRt.isMac -> toolboxCachesDir + else -> error("Unknown os") + } / "plugins" + + val targetDir = pluginsDir / pluginId + + from("src/main/resources") { + include("extension.json") + include("dependencies.json") + include("icon.svg") + include("icon-gray.svg") + } + + into(targetDir) + + finalizedBy(restartToolbox) +} + +val pluginZip by tasks.creating(Zip::class) { + dependsOn(tasks.named("shadowJar")) + from(tasks.named("shadowJar").get().outputs.files) + + from("src/main/resources") { + include("extension.json") + include("dependencies.json") + } + from("src/main/resources") { + include("icon.svg") + include("icon-gray.svg") + rename("icon.svg", "pluginIcon.svg") + } + archiveBaseName.set(pluginId) +} + +val uploadPlugin by tasks.creating { + dependsOn(pluginZip) + + doLast { +// val token = System.getenv("JB_MARKETPLACE_PUBLISH_TOKEN") +// val instance = PluginRepositoryFactory.create("https://plugins.jetbrains.com", token) + + // first upload + // instance.uploader.uploadNewPlugin( + // pluginZip.outputs.files.singleFile, + // listOf("toolbox", "gateway", "gitpod"), + // LicenseUrl.GNU_LESSER, + // ProductFamily.TOOLBOX, + // "Gitpod", + // "dev" + // ) + + // subsequent updates +// instance.uploader.upload(pluginId, pluginZip.outputs.files.singleFile) + } +} diff --git a/components/ide/jetbrains/toolbox/build.sh b/components/ide/jetbrains/toolbox/build.sh new file mode 100755 index 00000000000000..82ea79dba27417 --- /dev/null +++ b/components/ide/jetbrains/toolbox/build.sh @@ -0,0 +1,17 @@ +#!/bin/bash +# Copyright (c) 2024 Gitpod GmbH. All rights reserved. +# Licensed under the GNU Affero General Public License (AGPL). +# See License.AGPL.txt in the project root for license information. + +set -e + +JB_GP_VERSION=${1} + +./gradlew -PsupervisorApiProjectPath=components-supervisor-api-java--lib/ -PgitpodPublicApiProjectPath=components-public-api-java--lib/ -PenvironmentName="$JB_QUALIFIER" -Dgradle.user.home="/workspace/.gradle-tb-$JB_QUALIFIER" -Dplugin.verifier.home.dir="$HOME/.cache/pluginVerifier-tb-$JB_QUALIFIER" -PpluginVersion="$JB_GP_VERSION" pluginZip + +# # TODO(hw): Improve me +# tarDir="/tmp/tb-build" +# mkdir -p "$tarDir" +# mv ./build/distributions/io.gitpod.toolbox.gateway-0.0.1-dev.zip "$tarDir/io.gitpod.toolbox.gateway-0.0.1-dev.zip" +# echo "GITPOD_PLUGIN_ZIP=$tarDir/io.gitpod.toolbox.gateway-0.0.1-dev.zip" >> /tmp/__gh_output.txt +# # unzip ./build/distributions/io.gitpod.toolbox.gateway-0.0.1-dev.zip -d ./build diff --git a/components/ide/jetbrains/toolbox/gradle.properties b/components/ide/jetbrains/toolbox/gradle.properties new file mode 100644 index 00000000000000..1d898692293ac8 --- /dev/null +++ b/components/ide/jetbrains/toolbox/gradle.properties @@ -0,0 +1,4 @@ +pluginVersion= +environmentName=latest +supervisorApiProjectPath=../../../supervisor-api/java +gitpodPublicApiProjectPath=../../../public-api/java diff --git a/components/ide/jetbrains/toolbox/gradle/libs.versions.toml b/components/ide/jetbrains/toolbox/gradle/libs.versions.toml new file mode 100644 index 00000000000000..b17fb7bcf2b69d --- /dev/null +++ b/components/ide/jetbrains/toolbox/gradle/libs.versions.toml @@ -0,0 +1,33 @@ +[versions] +toolbox-plugin-api = "0.4" +kotlin = "2.0.10" +coroutines = "1.9.0" +serialization = "1.7.3" +okhttp = "4.10.0" +slf4j = "2.0.9" +dependency-license-report = "2.5" +marketplace-client = "2.0.38" +gradle-wrapper = "0.14.0" + +[libraries] +toolbox-core-api = { module = "com.jetbrains.toolbox:core-api", version.ref = "toolbox-plugin-api" } +toolbox-ui-api = { module = "com.jetbrains.toolbox:ui-api", version.ref = "toolbox-plugin-api" } +toolbox-remote-dev-api = { module = "com.jetbrains.toolbox:remote-dev-api", version.ref = "toolbox-plugin-api" } +coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" } +serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "serialization" } +serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "serialization" } +serialization-json-okio = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json-okio", version.ref = "serialization" } +okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" } +slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" } + +marketplace-client = { module = "org.jetbrains.intellij:plugin-repository-rest-client", version.ref = "marketplace-client" } + +[bundles] +serialization = [ "serialization-core", "serialization-json" ] +toolbox-plugin-api = [ "toolbox-core-api", "toolbox-ui-api", "toolbox-remote-dev-api" ] + +[plugins] +kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" } +serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } +dependency-license-report = { id = "com.github.jk1.dependency-license-report", version.ref = "dependency-license-report" } +gradle-wrapper = { id = "me.filippov.gradle.jvm.wrapper", version.ref = "gradle-wrapper" } diff --git a/components/ide/jetbrains/toolbox/gradle/wrapper/gradle-wrapper.jar b/components/ide/jetbrains/toolbox/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 00000000000000..c1962a79e29d3e Binary files /dev/null and b/components/ide/jetbrains/toolbox/gradle/wrapper/gradle-wrapper.jar differ diff --git a/components/ide/jetbrains/toolbox/gradle/wrapper/gradle-wrapper.properties b/components/ide/jetbrains/toolbox/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000000000..a4413138c96c6e --- /dev/null +++ b/components/ide/jetbrains/toolbox/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/components/ide/jetbrains/toolbox/gradlew b/components/ide/jetbrains/toolbox/gradlew new file mode 100755 index 00000000000000..aeb74cbb43e393 --- /dev/null +++ b/components/ide/jetbrains/toolbox/gradlew @@ -0,0 +1,245 @@ +#!/bin/sh + +# +# Copyright © 2015-2021 the original 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. +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/components/ide/jetbrains/toolbox/gradlew.bat b/components/ide/jetbrains/toolbox/gradlew.bat new file mode 100644 index 00000000000000..93e3f59f135dd2 --- /dev/null +++ b/components/ide/jetbrains/toolbox/gradlew.bat @@ -0,0 +1,92 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/components/ide/jetbrains/toolbox/settings.gradle.kts b/components/ide/jetbrains/toolbox/settings.gradle.kts new file mode 100644 index 00000000000000..a82e354dc8a54a --- /dev/null +++ b/components/ide/jetbrains/toolbox/settings.gradle.kts @@ -0,0 +1,13 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +rootProject.name = "gitpod-toolbox-gateway" + +include(":supervisor-api") +val supervisorApiProjectPath: String by settings +project(":supervisor-api").projectDir = File(supervisorApiProjectPath) + +include(":gitpod-publicapi") +val gitpodPublicApiProjectPath: String by settings +project(":gitpod-publicapi").projectDir = File(gitpodPublicApiProjectPath) diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/auth/GitpodAuthManager.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/auth/GitpodAuthManager.kt new file mode 100644 index 00000000000000..8f85cf581a6374 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/auth/GitpodAuthManager.kt @@ -0,0 +1,233 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.auth + +import com.connectrpc.Code +import com.connectrpc.ConnectException +import com.jetbrains.toolbox.api.core.auth.* +import io.gitpod.publicapi.experimental.v1.UserServiceClient +import io.gitpod.toolbox.service.GitpodPublicApiManager +import io.gitpod.toolbox.service.Utils +import kotlinx.coroutines.future.future +import kotlinx.serialization.Serializable +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.jsonPrimitive +import java.net.URI +import java.util.* +import java.util.concurrent.Future + +// TODO(hw): Validate Scopes +val authScopesJetBrainsToolbox = listOf( + "function:getGitpodTokenScopes", + "function:getLoggedInUser", + "function:getOwnerToken", + "function:getWorkspace", + "function:getWorkspaces", + "function:listenForWorkspaceInstanceUpdates", + "function:startWorkspace", + "function:stopWorkspace", + "function:deleteWorkspace", + "function:getToken", + "resource:default", +) + +class GitpodAuthManager { + private val manager: PluginAuthManager + private var loginListeners: MutableList<() -> Unit> = mutableListOf() + private var logoutListeners: MutableList<() -> Unit> = mutableListOf() + + init { + manager = Utils.sharedServiceLocator.getAuthManager( + "gitpod", + GitpodAccount::class.java, + { it.encode() }, + { GitpodAccount.decode(it) }, + { oauthToken, authCfg -> getAuthenticatedUser(URI.create(authCfg.baseUrl).host, oauthToken) }, + { oauthToken, gpAccount -> getAuthenticatedUser(gpAccount.getHost(), oauthToken) }, + { gpLoginCfg -> + val authParams = mapOf( + "response_type" to "code", + "client_id" to "toolbox-gateway-gitpod-plugin", + "scope" to authScopesJetBrainsToolbox.joinToString("%20"), + ) + val tokenParams = + mapOf("grant_type" to "authorization_code", "client_id" to "toolbox-gateway-gitpod-plugin") + AuthConfiguration( + authParams, + tokenParams, + gpLoginCfg.hostUrl, + gpLoginCfg.hostUrl + "/api/oauth/authorize", + gpLoginCfg.hostUrl + "/api/oauth/token", + "code_challenge", + "S256", + "code_verifier", + "Bearer" + ) + }, + { RefreshConfiguration("", mapOf(), "", ContentType.JSON) }, + ) + + manager.addEventListener { + when (it.type) { + AuthEvent.Type.LOGIN -> { + Utils.logger.info(" user logged in ${it.accountId}") + resetCurrentAccount(it.accountId) + loginListeners.forEach { it() } + } + + AuthEvent.Type.LOGOUT -> { + Utils.logger.info("user logged out ${it.accountId}") + resetCurrentAccount(it.accountId) + logoutListeners.forEach { it() } + } + } + } + } + + private fun resetCurrentAccount(accountId: String) { + val account = manager.accountsWithStatus.find { it.account.id == accountId }?.account ?: return + Utils.logger.debug("reset settings for ${account.getHost()}") + Utils.gitpodSettings.resetSettings(account.getHost()) + } + + fun getCurrentAccount(): GitpodAccount? { + return manager.accountsWithStatus.find { it.account.getHost() == Utils.gitpodSettings.gitpodHost }?.account + } + + suspend fun loginWithHost(host: String): Boolean { + val currentAccount = getCurrentAccount() + if (currentAccount?.getHost() == host) { + if (currentAccount.isValidate()) { + return true + } else { + manager.logout(currentAccount.id) + Utils.openUrl(this.getOAuthLoginUrl(host)) + return false + } + } + val account = manager.accountsWithStatus.find { it.account.getHost() == host }?.account + if (account != null) { + if (account.isValidate()) { + Utils.gitpodSettings.gitpodHost = host + loginListeners.forEach { it() } + return true + } else { + manager.logout(account.id) + Utils.openUrl(this.getOAuthLoginUrl(host)) + return false + } + } + Utils.openUrl(this.getOAuthLoginUrl(host)) + return false + } + + fun logout() { + getCurrentAccount()?.let { manager.logout(it.id) } + } + + fun getOAuthLoginUrl(gitpodHost: String): String { + Utils.logger.info("get oauth url of https://$gitpodHost") + return manager.initiateLogin(GitpodLoginConfiguration("https://$gitpodHost")) + } + + fun tryHandle(uri: URI): Boolean { + if (!this.manager.canHandle(uri)) { + return false + } + Utils.toolboxUi.showWindow() + this.manager.handle(uri) + return true + } + + fun addLoginListener(listener: () -> Unit) { + loginListeners.add(listener) + } + + fun addLogoutListener(listener: () -> Unit) { + logoutListeners.add(listener) + } + + private fun getAuthenticatedUser(gitpodHost: String, oAuthToken: OAuthToken): Future { + return Utils.coroutineScope.future { + val bearerToken = getBearerToken(oAuthToken) + val client = GitpodPublicApiManager.createClient(gitpodHost, bearerToken) + val user = GitpodPublicApiManager.tryGetAuthenticatedUser(UserServiceClient(client)) + GitpodAccount(bearerToken, user.id, user.name, gitpodHost, authScopesJetBrainsToolbox) + } + } + + private fun getBearerToken(oAuthToken: OAuthToken): String { + val parts = oAuthToken.authorizationHeader.replace("Bearer ", "").split(".") + // We don't validate jwt token + if (parts.size != 3) { + throw IllegalArgumentException("Invalid JWT") + } + val decoded = String(Base64.getUrlDecoder().decode(parts[1].toByteArray())) + val jsonElement = Json.parseToJsonElement(decoded) + val payloadMap = jsonElement.jsonObject.mapValues { + it.value.jsonPrimitive.content + } + return payloadMap["jti"] ?: throw IllegalArgumentException("Failed to parse JWT token") + } + +} + +class GitpodLoginConfiguration(val hostUrl: String) + +@Serializable +class GitpodAccount : Account { + private val credentials: String + private val id: String + private val name: String + private val host: String + private val scopes: List + + constructor(credentials: String, id: String, name: String, host: String, scopes: List) { + this.credentials = credentials + this.id = id + this.name = name + this.host = host + this.scopes = scopes + } + + override fun getId() = id + override fun getFullName() = name + fun getCredentials() = credentials + fun getHost() = host + fun getScopes() = scopes + + fun encode(): String { + return Json.encodeToString(this) + } + + suspend fun isValidate(): Boolean { + val hostUrl = "https://$host" + val client = GitpodPublicApiManager.createClient(URI(hostUrl).host, credentials) + Utils.logger.debug("validating account $hostUrl") + try { + GitpodPublicApiManager.tryGetAuthenticatedUser(UserServiceClient(client)) + // TODO: Verify scopes + return true + } catch (e: ConnectException) { + // TODO(hw): Server close jsonrpc so papi server respond internal error + if (e.code == Code.UNAUTHENTICATED || (e.code == Code.INTERNAL_ERROR && e.message != null && e.message!!.contains( + "jsonrpc2: connection is closed" + )) + ) { + Utils.logger.error("account $hostUrl is not valid") + return false + } + return true + } + } + + companion object { + fun decode(str: String): GitpodAccount { + return Json.decodeFromString(str) + } + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/auth/GitpodLoginPage.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/auth/GitpodLoginPage.kt new file mode 100644 index 00000000000000..456af15f9002b9 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/auth/GitpodLoginPage.kt @@ -0,0 +1,67 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.auth + +import com.jetbrains.toolbox.api.core.ui.icons.SvgIcon +import com.jetbrains.toolbox.api.ui.actions.ActionDescription +import com.jetbrains.toolbox.api.ui.components.LinkField +import com.jetbrains.toolbox.api.ui.components.TextField +import com.jetbrains.toolbox.api.ui.components.UiField +import com.jetbrains.toolbox.api.ui.components.ValidationResult +import io.gitpod.toolbox.components.AbstractUiPage +import io.gitpod.toolbox.components.GitpodIcon +import io.gitpod.toolbox.components.SimpleButton +import io.gitpod.toolbox.service.Utils +import java.net.URI +import java.net.URL + +class GitpodLoginPage(private val authManager: GitpodAuthManager) : AbstractUiPage() { + private val hostField = TextField("Host", "exp-migration.preview.gitpod-dev.com", null) { + val (result) = isValidHost(it) + result + } + + override fun getFields(): MutableList { + return mutableListOf(hostField, LinkField("Learn more", "https://gitpod.io/docs")) + } + + + override fun getActionButtons(): List { + return listOf(SimpleButton("Login") action@{ + val hostString = getFieldValue(hostField) ?: return@action + val (result, host) = isValidHost(hostString) + if (result != ValidationResult.Valid) { + Utils.toolboxUi.showErrorInfoPopup(IllegalArgumentException(result.errorMessage ?: "Invalid host value")) + return@action + } + val url = authManager.getOAuthLoginUrl(host) + Utils.openUrl(url) + }) + } + + override fun getTitle() = "Log in to Gitpod Classic" + + override fun getDescription() = "Always ready to code." + + override fun getSvgIcon(): SvgIcon { + return GitpodIcon() + } + + private fun isValidHost(it: String): Pair { + if (it.isBlank()) { + return ValidationResult.Invalid("Host cannot be empty") to "" + } + val host = try { + if (!it.startsWith("https://")) { + URI.create("https://$it").host + } else { + URI.create(it).host + } + } catch (e: Exception) { + return ValidationResult.Invalid("Invalid host value $e") to it + } + return ValidationResult.Valid to host + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/AbstractUiPage.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/AbstractUiPage.kt new file mode 100644 index 00000000000000..b90a582a343dc5 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/AbstractUiPage.kt @@ -0,0 +1,25 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.components + +import com.jetbrains.toolbox.api.ui.components.UiField +import com.jetbrains.toolbox.api.ui.components.UiPage + +abstract class AbstractUiPage : UiPage { + private var stateAccessor: UiPage.UiFieldStateAccessor? = null + + @Suppress("UNCHECKED_CAST") + fun getFieldValue(field: UiField) = stateAccessor?.get(field) as T? + + override fun setStateAccessor(stateAccessor: UiPage.UiFieldStateAccessor?) { + super.setStateAccessor(stateAccessor) + this.stateAccessor = stateAccessor + } +} + +class EmptyUiPageWithTitle(private val title: String) : UiPage { + override fun getFields(): MutableList = mutableListOf() + override fun getTitle() = title +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/Button.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/Button.kt new file mode 100644 index 00000000000000..0ca47ce289c79c --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/Button.kt @@ -0,0 +1,16 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.components + +import com.jetbrains.toolbox.api.ui.actions.RunnableActionDescription + +open class SimpleButton(private val title: String, private val action: () -> Unit = {}): RunnableActionDescription { + override fun getLabel(): String { + return title + } + override fun run() { + action() + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/Icon.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/Icon.kt new file mode 100644 index 00000000000000..c4cdec433901e5 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/components/Icon.kt @@ -0,0 +1,19 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.components + +import com.jetbrains.toolbox.api.core.ui.icons.SvgIcon +import io.gitpod.toolbox.gateway.GitpodGatewayExtension + +@Suppress("FunctionName") +fun GitpodIconGray(): SvgIcon { + return SvgIcon(GitpodGatewayExtension::class.java.getResourceAsStream("/icon-gray.svg")?.readAllBytes() ?: byteArrayOf()) +} + +@Suppress("FunctionName") +fun GitpodIcon(): SvgIcon { + return SvgIcon(GitpodGatewayExtension::class.java.getResourceAsStream("/icon.svg")?.readAllBytes() ?: byteArrayOf()) +} + diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodGatewayExtension.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodGatewayExtension.kt new file mode 100644 index 00000000000000..5bc48f223cbec1 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodGatewayExtension.kt @@ -0,0 +1,18 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.gateway + +import com.jetbrains.toolbox.api.core.ServiceLocator +import com.jetbrains.toolbox.api.remoteDev.RemoteDevExtension +import com.jetbrains.toolbox.api.remoteDev.RemoteEnvironmentConsumer +import com.jetbrains.toolbox.api.remoteDev.RemoteProvider +import io.gitpod.toolbox.service.Utils + +class GitpodGatewayExtension : RemoteDevExtension { + override fun createRemoteProviderPluginInstance(serviceLocator: ServiceLocator): RemoteProvider { + Utils.initialize(serviceLocator) + return GitpodRemoteProvider(serviceLocator.getService(RemoteEnvironmentConsumer::class.java)) + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteEnvironment.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteEnvironment.kt new file mode 100644 index 00000000000000..71502a1bc9f963 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteEnvironment.kt @@ -0,0 +1,156 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.gateway + +import com.jetbrains.toolbox.api.remoteDev.AbstractRemoteProviderEnvironment +import com.jetbrains.toolbox.api.remoteDev.AfterDisconnectHook +import com.jetbrains.toolbox.api.remoteDev.BeforeConnectionHook +import com.jetbrains.toolbox.api.remoteDev.EnvironmentVisibilityState +import com.jetbrains.toolbox.api.remoteDev.environments.EnvironmentContentsView +import com.jetbrains.toolbox.api.remoteDev.states.CustomRemoteEnvironmentState +import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateConsumer +import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateIcons +import com.jetbrains.toolbox.api.remoteDev.states.StandardRemoteEnvironmentState +import com.jetbrains.toolbox.api.ui.actions.ActionDescription +import com.jetbrains.toolbox.api.ui.observables.ObservableList +import com.jetbrains.toolbox.api.ui.observables.ObservablePropertiesFactory +import io.gitpod.publicapi.experimental.v1.Workspaces.WorkspaceInstanceStatus +import io.gitpod.toolbox.auth.GitpodAuthManager +import io.gitpod.toolbox.components.SimpleButton +import io.gitpod.toolbox.service.ConnectParams +import io.gitpod.toolbox.service.GitpodPublicApiManager +import io.gitpod.toolbox.service.Utils +import kotlinx.coroutines.DisposableHandle +import kotlinx.coroutines.Job +import kotlinx.coroutines.channels.BufferOverflow +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.launch +import java.net.URI +import java.util.concurrent.CompletableFuture +import java.util.function.Consumer + +class GitpodRemoteEnvironment( + private val connectParams: ConnectParams, + private val publicApi: GitpodPublicApiManager, observablePropertiesFactory: ObservablePropertiesFactory?, +) : AbstractRemoteProviderEnvironment(observablePropertiesFactory), DisposableHandle { + private val actionList = Utils.observablePropertiesFactory.emptyObservableList(); + private val envContentsView = GitpodRemoteEnvironmentContentsView(connectParams, publicApi) + private val contentsViewFuture: CompletableFuture = + CompletableFuture.completedFuture(envContentsView) + private var watchWorkspaceJob: Job? = null + + private val lastWSEnvState = MutableSharedFlow(1, 0, BufferOverflow.DROP_OLDEST) + private var lastPhase: WorkspaceInstanceStatus.Phase = WorkspaceInstanceStatus.Phase.PHASE_UNSPECIFIED + + init { + Utils.coroutineScope.launch { + lastWSEnvState.collect { lastState -> + val state = lastState.getState() + val actions = mutableListOf() + if (lastState.phase == WorkspaceInstanceStatus.Phase.PHASE_STOPPED) { + actions.add(SimpleButton("Restart") { + if (publicApi.gitpodHost.isNullOrBlank()) { + return@SimpleButton + } + Utils.localDesktopManager.openUrl(URI("https://${publicApi.gitpodHost}/start#${connectParams.workspaceId}").toURL()) + }) + } + actionList.clear() + actionList.addAll(actions) + listenerSet.forEach { it.consume(state) } + } + } + + Utils.coroutineScope.launch { + Utils.logger.debug("watching workspace ${connectParams.workspaceId}") + watchWorkspaceJob = publicApi.watchWorkspaceStatus(connectParams.workspaceId) { _, status -> + lastPhase = status.phase + Utils.logger.debug("${connectParams.workspaceId} status updated: $lastPhase") + lastWSEnvState.tryEmit(WorkspaceEnvState(status.phase)) + Utils.coroutineScope.launch { + envContentsView.updateEnvironmentMeta(status) + } + } + } + } + + override fun addStateListener(consumer: EnvironmentStateConsumer): Boolean { + val ok = super.addStateListener(consumer) + Utils.coroutineScope.launch { + lastWSEnvState.tryEmit(WorkspaceEnvState(lastPhase)) + } + return ok + } + + override fun getId(): String = connectParams.uniqueID + override fun getName(): String = connectParams.uniqueID + + override fun getContentsView(): CompletableFuture = contentsViewFuture + + override fun setVisible(visibilityState: EnvironmentVisibilityState) { + } + + override fun getActionList(): ObservableList = actionList + + override fun onDelete() { + // TODO: delete workspace? + watchWorkspaceJob?.cancel() + } + + override fun dispose() { + watchWorkspaceJob?.cancel() + } + + override fun getAfterDisconnectHooks(): MutableList { + return mutableListOf(object: AfterDisconnectHook { + override fun afterDisconnect() { + Utils.logger.info("=============afterDisconnect") + } + }) + } + + override fun getBeforeConnectionHooks(): MutableList { + return mutableListOf(object: BeforeConnectionHook { + override fun beforeConnection() { + Utils.logger.info("=============beforeConnection") + } + }) + } + + fun connect() { + connectionRequestListenerSet.forEach { + it.accept(true) + } + } + + fun disconnect() { + connectionRequestListenerSet.forEach { + it.accept(false) + } + } +} + + +private class WorkspaceEnvState(val phase: WorkspaceInstanceStatus.Phase) { + + fun getState() = run { + phaseToStateMap[phase] ?: StandardRemoteEnvironmentState.Unreachable + } + + companion object { + val phaseToStateMap = mapOf( + WorkspaceInstanceStatus.Phase.PHASE_UNSPECIFIED to CustomRemoteEnvironmentState("Unknown", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Inactive), false, EnvironmentStateIcons.Error), + WorkspaceInstanceStatus.Phase.PHASE_PREPARING to CustomRemoteEnvironmentState("Preparing", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Initializing), false, EnvironmentStateIcons.Connecting), + WorkspaceInstanceStatus.Phase.PHASE_IMAGEBUILD to CustomRemoteEnvironmentState("Building", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Initializing), false, EnvironmentStateIcons.Connecting), + WorkspaceInstanceStatus.Phase.PHASE_PENDING to CustomRemoteEnvironmentState("Initializing", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Initializing), false, EnvironmentStateIcons.Connecting), + WorkspaceInstanceStatus.Phase.PHASE_CREATING to CustomRemoteEnvironmentState("Creating", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Initializing), false, EnvironmentStateIcons.Connecting), + WorkspaceInstanceStatus.Phase.PHASE_INITIALIZING to CustomRemoteEnvironmentState("Initializing", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Initializing), false, EnvironmentStateIcons.Connecting), + WorkspaceInstanceStatus.Phase.PHASE_RUNNING to CustomRemoteEnvironmentState("Running", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Active), true, EnvironmentStateIcons.Active), + WorkspaceInstanceStatus.Phase.PHASE_INTERRUPTED to StandardRemoteEnvironmentState.Error, + WorkspaceInstanceStatus.Phase.PHASE_STOPPING to CustomRemoteEnvironmentState("Stopping", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Hibernating), false, EnvironmentStateIcons.Connecting), + WorkspaceInstanceStatus.Phase.PHASE_STOPPED to CustomRemoteEnvironmentState("Stopped", Utils.environmentStateColorPalette.getColor(StandardRemoteEnvironmentState.Hibernated), false, EnvironmentStateIcons.Hibernated), + ) + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteEnvironmentContentsView.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteEnvironmentContentsView.kt new file mode 100644 index 00000000000000..5fab000b4e1982 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteEnvironmentContentsView.kt @@ -0,0 +1,76 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.gateway + +import com.jetbrains.toolbox.api.remoteDev.environments.CachedIdeStub +import com.jetbrains.toolbox.api.remoteDev.environments.CachedProjectStub +import com.jetbrains.toolbox.api.remoteDev.environments.ManualEnvironmentContentsView +import com.jetbrains.toolbox.api.remoteDev.environments.SshEnvironmentContentsView +import com.jetbrains.toolbox.api.remoteDev.ssh.SshConnectionInfo +import io.gitpod.publicapi.experimental.v1.Workspaces.WorkspaceInstanceStatus +import io.gitpod.toolbox.service.* +import java.util.concurrent.CompletableFuture + +class GitpodRemoteEnvironmentContentsView( + private val connectParams: ConnectParams, + private val publicApi: GitpodPublicApiManager, +) : SshEnvironmentContentsView, ManualEnvironmentContentsView { + private var cancel = {} + private val stateListeners = mutableSetOf() + private val provider = GitpodConnectionProvider(object : ConnectionInfoProvider { + override fun getUniqueID() = connectParams.uniqueID + + override suspend fun getWebsocketTunnelUrl(): String { + val workspace = publicApi.getWorkspace(connectParams.workspaceId) + return workspace.getTunnelUrl() + } + + override suspend fun getOwnerToken(): String { + return publicApi.getWorkspaceOwnerToken(connectParams.workspaceId) + } + }) + + private val connectionInfo = CompletableFuture.supplyAsync { + val (connInfo, cancel) = provider.connect() + this.cancel = cancel + connInfo + } + + override fun getConnectionInfo(): CompletableFuture = connectionInfo + + var metadata: GitpodPublicApiManager.JoinLink2Response? = null + suspend fun updateEnvironmentMeta(status: WorkspaceInstanceStatus) { + if (metadata == null && status.phase == WorkspaceInstanceStatus.Phase.PHASE_RUNNING) { + metadata = publicApi.fetchJoinLink2Info(connectParams.workspaceId, status.getIDEUrl()) + } + if (metadata == null) { + // TODO(hw): restore from cache? + return + } + stateListeners.forEach { + it.onProjectListUpdated(listOf(object : CachedProjectStub { + override fun getPath() = metadata!!.projectPath + override fun getName() = metadata!!.projectPath.split("/").last() + override fun getIdeHint() = metadata!!.ideVersion + })) + it.onIdeListUpdated(listOf(object : CachedIdeStub { + override fun getProductCode() = metadata!!.ideVersion + override fun isRunning() = status.phase == WorkspaceInstanceStatus.Phase.PHASE_RUNNING + })) + } + } + + override fun addEnvironmentContentsListener(p0: ManualEnvironmentContentsView.Listener) { + stateListeners += p0 + } + + override fun removeEnvironmentContentsListener(p0: ManualEnvironmentContentsView.Listener) { + stateListeners -= p0 + } + + override fun close() { + cancel() + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteProvider.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteProvider.kt new file mode 100644 index 00000000000000..3a480b2b766f55 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodRemoteProvider.kt @@ -0,0 +1,178 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.gateway + +import com.jetbrains.toolbox.api.remoteDev.ProviderVisibilityState +import com.jetbrains.toolbox.api.remoteDev.RemoteEnvironmentConsumer +import com.jetbrains.toolbox.api.remoteDev.RemoteProvider +import com.jetbrains.toolbox.api.ui.actions.ActionDescription +import com.jetbrains.toolbox.api.ui.components.AccountDropdownField +import com.jetbrains.toolbox.api.ui.components.UiPage +import io.gitpod.publicapi.experimental.v1.Workspaces +import io.gitpod.toolbox.auth.GitpodAuthManager +import io.gitpod.toolbox.auth.GitpodLoginPage +import io.gitpod.toolbox.components.EmptyUiPageWithTitle +import io.gitpod.toolbox.components.GitpodIcon +import io.gitpod.toolbox.components.SimpleButton +import io.gitpod.toolbox.service.* +import kotlinx.coroutines.launch +import java.net.URI +import java.util.concurrent.CompletableFuture + +class GitpodRemoteProvider( + private val consumer: RemoteEnvironmentConsumer, +) : RemoteProvider { + private val authManger = GitpodAuthManager() + private val publicApi = GitpodPublicApiManager(authManger) + private val loginPage = GitpodLoginPage(authManger) + + // cache consumed environments map locally + private val environmentMap = mutableMapOf>() + + private var pendingConnectParams: Pair? = null + private val openInToolboxUriHandler = GitpodOpenInToolboxUriHandler { (gitpodHost, connectParams) -> + val future = CompletableFuture() + Utils.coroutineScope.launch { + if (!authManger.loginWithHost(gitpodHost)) { + pendingConnectParams = gitpodHost to connectParams + future.complete(null) + return@launch + } + setEnvironmentVisibility(connectParams) + future.complete(null) + } + return@GitpodOpenInToolboxUriHandler future + } + + private suspend fun setEnvironmentVisibility(connectParams: ConnectParams) { + val workspaceId = connectParams.workspaceId + Utils.logger.debug("setEnvironmentVisibility $workspaceId, $connectParams") + var obj = environmentMap[connectParams.uniqueID] + var (workspace) = obj ?: Pair(null, null) + if (obj == null) { + workspace = publicApi.getWorkspace(workspaceId) + val env = GitpodRemoteEnvironment( + connectParams, + publicApi, + Utils.observablePropertiesFactory + ) + environmentMap[connectParams.uniqueID] = Pair(workspace, env) + consumer.consumeEnvironments(environmentMap.values.map { it.second }, true) + obj = environmentMap[connectParams.uniqueID] + } + if (obj != null) { + val joinLinkInfo = publicApi.fetchJoinLink2Info(workspaceId, workspace!!.getIDEUrl()) + // TODO(hw): verify if it's working + Utils.clientHelper.prepareClient(joinLinkInfo.ideVersion) + Utils.clientHelper.setAutoConnectOnEnvironmentReady( + connectParams.uniqueID, + joinLinkInfo.ideVersion, + joinLinkInfo.projectPath + ) + obj.second.disconnect() + obj.second.connect() + } + } + + private fun showWorkspacesList() { + Utils.coroutineScope.launch { + val workspaces = publicApi.listWorkspaces() + if (workspaces.isEmpty()) { + consumer.consumeEnvironments(emptyList(), true) + return@launch + } + consumer.consumeEnvironments(workspaces.map { + val connectParams = it.getConnectParams() + val env = environmentMap[connectParams.uniqueID]?.second ?: GitpodRemoteEnvironment( + connectParams, + publicApi, + Utils.observablePropertiesFactory + ) + environmentMap[connectParams.uniqueID] = Pair(it, env) + if (connectParams.uniqueID == pendingConnectParams?.second?.uniqueID) { + setEnvironmentVisibility(connectParams) + pendingConnectParams = null + } + env + }, true) + } + } + + private fun startup() { + val account = authManger.getCurrentAccount() ?: return + publicApi.setup() + Utils.logger.info("startup with ${account.getHost()} ${account.id}") + showWorkspacesList() + } + + override fun getOverrideUiPage(): UiPage? { + authManger.addLoginListener { + startup() + Utils.environmentUiPageManager.showPluginEnvironmentsPage(false) + } + authManger.addLogoutListener { + Utils.environmentUiPageManager.showPluginEnvironmentsPage(false) + } + val account = authManger.getCurrentAccount() + account ?: return loginPage + startup() + Utils.coroutineScope.launch { + if (account.isValidate()) { + return@launch + } + authManger.logout() + Utils.environmentUiPageManager.showPluginEnvironmentsPage(false) + } + return null + } + + override fun close() {} + + override fun getName(): String = "Gitpod Classic" + override fun getSvgIcon() = GitpodIcon() + + override fun getNewEnvironmentUiPage() = EmptyUiPageWithTitle("") + + override fun getAccountDropDown(): AccountDropdownField? { + val account = authManger.getCurrentAccount() ?: return null + return AccountDropdownField(account.fullName) { + authManger.logout() + } + } + + override fun getAdditionalPluginActions(): MutableList { + val list = mutableListOf() + val account = authManger.getCurrentAccount() + if (account != null) { + list.add(SimpleButton("Open Dashboard") { Utils.openUrl("https://${account.getHost()}/workspaces") }) + } + list.add(SimpleButton("View Documents") { Utils.openUrl("https://www.gitpod.io/docs/introduction/getting-started") }) + list.add(SimpleButton("About Gitpod Flex") { Utils.openUrl("https://www.gitpod.io/docs/flex/getting-started") }) + return list + } + + override fun canCreateNewEnvironments(): Boolean = false + override fun isSingleEnvironment(): Boolean = false + override fun getNoEnvironmentsDescription() = "No workspaces" + + override fun setVisible(visibilityState: ProviderVisibilityState) {} + + override fun addEnvironmentsListener(listener: RemoteEnvironmentConsumer) {} + override fun removeEnvironmentsListener(listener: RemoteEnvironmentConsumer) {} + + override fun handleUri(uri: URI) { + if (authManger.tryHandle(uri)) { + return + } + if (openInToolboxUriHandler.tryHandle(uri)) { + return + } + when (uri.path) { + else -> { + Utils.logger.warn("Unknown request: $uri") + } + } + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodSettings.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodSettings.kt new file mode 100644 index 00000000000000..8e3aee7142c749 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodSettings.kt @@ -0,0 +1,37 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.gateway + +import io.gitpod.toolbox.service.Utils + +class GitpodSettings { + private val settingsChangedListeners: MutableList<(String, String) -> Unit> = mutableListOf() + + private fun getStoreKey(key: SettingKey) = "GITPOD_SETTINGS:${key.name}" + + private fun updateSetting(key: SettingKey, value: String) { + Utils.logger.debug("updateSetting ${key.name}=$value") + Utils.settingStore[getStoreKey(key)] = value + settingsChangedListeners.forEach { it(key.name, value) } + } + + fun onSettingsChanged(listener: (String, String) -> Unit) { + settingsChangedListeners.add(listener) + } + + fun resetSettings(host: String = "gitpod.io") { + gitpodHost = host + } + + var gitpodHost: String + get() = Utils.settingStore[getStoreKey(SettingKey.GITPOD_HOST)] ?: "gitpod.io" + set(value) { + updateSetting(SettingKey.GITPOD_HOST, value) + } + + enum class SettingKey { + GITPOD_HOST + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodUriHandler.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodUriHandler.kt new file mode 100644 index 00000000000000..3f623264b650d8 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/gateway/GitpodUriHandler.kt @@ -0,0 +1,61 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.gateway + +import io.gitpod.toolbox.service.ConnectParams +import io.gitpod.toolbox.service.Utils +import java.net.URI +import java.util.concurrent.Future + +interface UriHandler { + fun parseUri(uri: URI): T + fun handle(data: T): Future + fun tryHandle(uri: URI): Boolean +} + +abstract class AbstractUriHandler : UriHandler { + abstract override fun parseUri(uri: URI): T + abstract override fun handle(data: T): Future + + override fun tryHandle(uri: URI) = try { + val data = parseUri(uri) + handle(data) + true + } catch (e: Exception) { + Utils.logger.warn(e, "cannot parse URI") + false + } +} + +class GitpodOpenInToolboxUriHandler(val handler: (Pair) -> Future) : AbstractUriHandler>() { + + override fun handle(data: Pair): Future { + return handler(data) + } + + override fun parseUri(uri: URI): Pair { + val path = uri.path.split("/").last() + if (path != "open-in-toolbox") { + throw IllegalArgumentException("invalid URI: $path") + } + val query = uri.query ?: throw IllegalArgumentException("invalid URI: ${uri.query}") + val params = query.split("&").map { it.split("=") }.associate { it[0] to it[1] } + val host = params["host"] + val workspaceId = params["workspaceId"] + val debugWorkspace = params["debugWorkspace"]?.toBoolean() ?: false + + if (host.isNullOrEmpty() || workspaceId.isNullOrEmpty()) { + throw IllegalArgumentException("invalid URI: host or workspaceId is missing: $uri") + } + + try { + URI.create("https://$host") + } catch (e: IllegalArgumentException) { + throw IllegalArgumentException("invalid host: $host") + } + Utils.logger.debug("parsed URI: $host, $workspaceId, $debugWorkspace") + return Pair(host, ConnectParams(workspaceId, host, debugWorkspace)) + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/Data.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/Data.kt new file mode 100644 index 00000000000000..39b1043a930271 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/Data.kt @@ -0,0 +1,38 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.service + +import io.gitpod.publicapi.experimental.v1.Workspaces.Workspace +import io.gitpod.publicapi.experimental.v1.Workspaces.WorkspaceInstanceStatus +import java.net.URI + +fun Workspace.getConnectParams(): ConnectParams { + return ConnectParams(workspaceId, getGitpodHost(), false) +} + +fun Workspace.getIDEUrl(): String { + return status.instance.status.url +} + +fun Workspace.getGitpodHost(): String { + val ideUrl = URI(getIDEUrl()).toURL() + val hostSegments = ideUrl.host.split(".") + return hostSegments.takeLast(2).joinToString(".") +} + +val JetBrainsEditors = setOf("intellij", "pycharm", "webstorm", "clion", "goland", "rider", "phpstorm", "rubymine") +fun WorkspaceInstanceStatus.shouldListedInEnvironments() : Boolean { + return editor.preferToolbox && JetBrainsEditors.contains(editor.name) +} + +fun Workspace.getTunnelUrl(): String { + val workspaceHost = URI.create(status.instance.status.url).host + return "wss://${workspaceHost}/_supervisor/tunnel/ssh" +} + +fun WorkspaceInstanceStatus.getIDEUrl(): String { + return url +} + diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodConnectionProvider.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodConnectionProvider.kt new file mode 100644 index 00000000000000..3d34d7566f6df3 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodConnectionProvider.kt @@ -0,0 +1,73 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.service + +import com.jetbrains.rd.util.ConcurrentHashMap +import com.jetbrains.toolbox.api.remoteDev.ssh.SshConnectionInfo + +interface ConnectionInfoProvider { + fun getUniqueID(): String + suspend fun getWebsocketTunnelUrl(): String + suspend fun getOwnerToken(): String +} + +class GitpodConnectionProvider(private val provider: ConnectionInfoProvider) { + private val activeConnections = ConcurrentHashMap() + + fun connect(): Pair Unit> { + val (serverPort, cancel) = tunnelWithWebSocket(provider) + + val connInfo = GitpodWebSocketSshConnectionInfo( + "gitpod", + "localhost", + serverPort, + ) + return (connInfo to cancel) + } + + private fun tunnelWithWebSocket(provider: ConnectionInfoProvider): Pair Unit> { + val connectionKeyId = provider.getUniqueID() + + var found = true + activeConnections.computeIfAbsent(connectionKeyId) { + found = false + true + } + + if (found) { + val errMessage = "A connection to the same workspace already exists: $connectionKeyId" + throw IllegalStateException(errMessage) + } + + val server = GitpodWebSocketTunnelServer(provider) + + val cancelServer = server.start() + + return (server.port to { + activeConnections.remove(connectionKeyId) + cancelServer() + }) + } +} + +class GitpodWebSocketSshConnectionInfo( + private val username: String, + private val host: String, + private val port: Int, +) : SshConnectionInfo { + override fun getHost() = host + override fun getPort() = port + override fun getUserName() = username + override fun getShouldAskForPassword() = false + override fun getShouldUseSystemSshAgent() = true +} + +data class ConnectParams( + val workspaceId: String, + val host: String, + val debugWorkspace: Boolean = false, +) { + val uniqueID = if (debugWorkspace) "debug-$workspaceId" else workspaceId +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodPublicApiManager.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodPublicApiManager.kt new file mode 100644 index 00000000000000..d2863b8007d14b --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodPublicApiManager.kt @@ -0,0 +1,171 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.service + +import com.connectrpc.* +import com.connectrpc.extensions.GoogleJavaProtobufStrategy +import com.connectrpc.http.clone +import com.connectrpc.impl.ProtocolClient +import com.connectrpc.okhttp.ConnectOkHttpClient +import com.connectrpc.protocols.NetworkProtocol +import io.gitpod.publicapi.experimental.v1.* +import io.gitpod.toolbox.auth.GitpodAccount +import io.gitpod.toolbox.auth.GitpodAuthManager +import io.gitpod.toolbox.utils.await +import kotlinx.coroutines.Job +import kotlinx.coroutines.launch +import kotlinx.serialization.Serializable +import kotlinx.serialization.decodeFromString +import kotlinx.serialization.json.Json +import okhttp3.Request +import java.net.URI +import java.time.Duration + +class GitpodPublicApiManager(private val authManger: GitpodAuthManager) { + private var workspaceApi: WorkspacesServiceClientInterface? = null + private var organizationApi: TeamsServiceClientInterface? = null + private var userApi: UserServiceClientInterface? = null + private var account: GitpodAccount? = null + var gitpodHost: String? = null + + init { + authManger.addLogoutListener { + workspaceApi = null + organizationApi = null + userApi = null + account = null + } + } + + fun setup() { + val account = authManger.getCurrentAccount() ?: return + this.account = account + Utils.logger.info("setup papi client for ${account.getHost()}") + val client = createClient(account.getHost(), account.getCredentials()) + workspaceApi = WorkspacesServiceClient(client) + organizationApi = TeamsServiceClient(client) + userApi = UserServiceClient(client) + gitpodHost = account.getHost() + } + + fun watchWorkspaceStatus(workspaceId: String, consumer: (String, Workspaces.WorkspaceInstanceStatus) -> Unit): Job { + val workspaceApi = workspaceApi ?: throw IllegalStateException("No client") + + return Utils.coroutineScope.launch { + val workspace = getWorkspace(workspaceId) + consumer(workspace.workspaceId, workspace.status.instance.status) + val stream = workspaceApi.streamWorkspaceStatus() + stream.sendAndClose(Workspaces.StreamWorkspaceStatusRequest.newBuilder().setWorkspaceId(workspaceId).build()) + val chan = stream.responseChannel() + try { + for (response in chan) { + consumer(response.result.instance.workspaceId, response.result.instance.status) + } + } + finally { + chan.cancel() + } + } + } + + suspend fun listWorkspaces(): List { + val workspaceApi = workspaceApi ?: throw IllegalStateException("No client") + val resp = workspaceApi.listWorkspaces(Workspaces.ListWorkspacesRequest.newBuilder().build()) + return this.handleResp("listWorkspaces", resp).resultList.filter { it.status.instance.status.shouldListedInEnvironments() } + } + + suspend fun getWorkspace(workspaceId: String): Workspaces.Workspace { + val workspaceApi = workspaceApi ?: throw IllegalStateException("No client") + val resp = workspaceApi.getWorkspace(Workspaces.GetWorkspaceRequest.newBuilder().setWorkspaceId(workspaceId).build()) + return this.handleResp("getWorkspace", resp).result + } + + suspend fun getWorkspaceOwnerToken(workspaceId: String): String { + val workspaceApi = workspaceApi ?: throw IllegalStateException("No client") + val resp = workspaceApi.getOwnerToken(Workspaces.GetOwnerTokenRequest.newBuilder().setWorkspaceId(workspaceId).build()) + return this.handleResp("getOwnerToken", resp).token + } + + @Serializable + class JoinLink2Response(val appPid: Int, val joinLink: String, val ideVersion: String, val projectPath: String) + + suspend fun fetchJoinLink2Info(workspaceId: String, ideURL: String): JoinLink2Response { + val token = getWorkspaceOwnerToken(workspaceId) + val backendUrl = "https://24000-${URI(ideURL).host}/joinLink2" + val client = Utils.httpClient + val req = Request.Builder().url(backendUrl).header("x-gitpod-owner-token", token) + val response = client.newCall(req.build()).await() + if (!response.isSuccessful) { + throw IllegalStateException("Failed to get join link $backendUrl info: ${response.code} ${response.message}") + } + if (response.body == null) { + throw IllegalStateException("Failed to get join link $backendUrl info: no body") + } + return Json.decodeFromString(response.body!!.string()) + } + + suspend fun getAuthenticatedUser(): UserOuterClass.User { + return tryGetAuthenticatedUser(userApi) + } + + private fun handleResp(method: String, resp: ResponseMessage): T { + val data = resp.success { it.message } + val error = resp.failure { + Utils.logger.error("failed to call papi.${method} $it") + it.cause + } + return data ?: throw error!! + } + + companion object { + fun createClient(gitpodHost: String, token: String): ProtocolClient { + // TODO: 6m? + val client = Utils.httpClient.newBuilder().readTimeout(Duration.ofMinutes(6)).build() + val authInterceptor = AuthorizationInterceptor(token) + return ProtocolClient( + httpClient = ConnectOkHttpClient(client), + ProtocolClientConfig( + host = "https://api.$gitpodHost", + serializationStrategy = GoogleJavaProtobufStrategy(), // Or GoogleJavaJSONStrategy for JSON. + networkProtocol = NetworkProtocol.CONNECT, + interceptors = listOf { authInterceptor } + ), + ) + } + + /** + * Tries to get the authenticated user from the given API client. + * Used in GitpodAuthManager + */ + suspend fun tryGetAuthenticatedUser(api: UserServiceClientInterface?): UserOuterClass.User { + val userApi = api ?: throw IllegalStateException("No client") + val resp = userApi.getAuthenticatedUser(UserOuterClass.GetAuthenticatedUserRequest.newBuilder().build()) + val user = resp.success { it.message.user } + val err = resp.failure { + Utils.logger.error("failed to call papi.getAuthenticatedUser $it") + it.cause + } + return user ?: throw err!! + } + } +} + +class AuthorizationInterceptor(private val token: String) : Interceptor { + override fun streamFunction() = StreamFunction({ + val headers = mutableMapOf>() + headers.putAll(it.headers) + headers["Authorization"] = listOf("Bearer $token") + return@StreamFunction it.clone(headers = headers) + }) + + override fun unaryFunction() = UnaryFunction( + { + val headers = mutableMapOf>() + headers.putAll(it.headers) + headers["Authorization"] = listOf("Bearer $token") + return@UnaryFunction it.clone(headers = headers) + }, + ) +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodWebSocketTunnelServer.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodWebSocketTunnelServer.kt new file mode 100644 index 00000000000000..c9f0cb41ff56dc --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/GitpodWebSocketTunnelServer.kt @@ -0,0 +1,211 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.service + +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.isActive +import kotlinx.coroutines.launch +import org.eclipse.jetty.client.HttpClient +import org.eclipse.jetty.client.HttpProxy +import org.eclipse.jetty.client.Socks4Proxy +import org.eclipse.jetty.util.ssl.SslContextFactory +import org.eclipse.jetty.websocket.jsr356.ClientContainer +import java.net.* +import java.nio.ByteBuffer +import java.util.* +import java.util.concurrent.CopyOnWriteArrayList +import javax.net.ssl.SSLContext +import javax.websocket.* +import javax.websocket.ClientEndpointConfig.Configurator +import javax.websocket.MessageHandler.Partial + + +class GitpodWebSocketTunnelServer(private val provider: ConnectionInfoProvider) { + val port: Int get() = serverSocket.localPort + private val serverSocket = ServerSocket(0) // pass 0 to have the system choose a free port + private val logPrefix = "tunnel: [${provider.getUniqueID()}]" + private val clients = CopyOnWriteArrayList() + + fun start(): () -> Unit { + val job = Utils.coroutineScope.launch(Dispatchers.IO) { + Utils.logger.info("$logPrefix listening on port $port") + try { + while (isActive) { + try { + val clientSocket = serverSocket.accept() + val url = provider.getWebsocketTunnelUrl() + val ownerToken = provider.getOwnerToken() + this.launch(Dispatchers.IO) { + handleClientConnection(clientSocket, url, ownerToken) + } + } catch (t: Throwable) { + if (isActive) { + Utils.logger.error(t, "$logPrefix failed to accept") + } + } + } + } catch (t: Throwable) { + if (isActive) { + Utils.logger.error(t, "$logPrefix failed to listen") + } + } finally { + Utils.logger.info("$logPrefix stopped") + } + } + return { + job.cancel() + serverSocket.close() + clients.forEach { it.close() } + clients.clear() + } + } + + private fun handleClientConnection(clientSocket: Socket, url: String, ownerToken: String) { + val socketClient = GitpodWebSocketTunnelClient(logPrefix, clientSocket) + try { + val inputStream = clientSocket.getInputStream() + val outputStream = clientSocket.getOutputStream() + + // Forward data from WebSocket to TCP client + socketClient.onMessageCallback = { data -> + outputStream.write(data) + Utils.logger.trace("$logPrefix received ${data.size} bytes") + } + + connectToWebSocket(socketClient, url, ownerToken) + + clients.add(socketClient) + + val buffer = ByteArray(1024) + var read: Int + while (inputStream.read(buffer).also { read = it } != -1) { + // Forward data from TCP to WebSocket + socketClient.sendData(buffer.copyOfRange(0, read)) + Utils.logger.trace("$logPrefix sent $read bytes") + } + } catch (t: Throwable) { + if (t is SocketException && t.message?.contains("Socket closed") == true) { + return + } + Utils.logger.error(t, "$logPrefix failed to pipe") + } finally { + clients.remove(socketClient) + socketClient.close() + } + } + + private fun connectToWebSocket(socketClient: GitpodWebSocketTunnelClient, url: String, ownerToken: String) { + val ssl: SslContextFactory = SslContextFactory.Client() + ssl.sslContext = SSLContext.getDefault() + val httpClient = HttpClient(ssl) + val proxies = Utils.getProxyList() + for (proxy in proxies) { + if (proxy.type() == Proxy.Type.DIRECT) { + continue + } + val proxyAddress = proxy.address() + if (proxyAddress !is InetSocketAddress) { + Utils.logger.warn("$logPrefix unexpected proxy: $proxy") + continue + } + val hostName = proxyAddress.hostString + val port = proxyAddress.port + if (proxy.type() == Proxy.Type.HTTP) { + httpClient.proxyConfiguration.proxies.add(HttpProxy(hostName, port)) + } else if (proxy.type() == Proxy.Type.SOCKS) { + httpClient.proxyConfiguration.proxies.add(Socks4Proxy(hostName, port)) + } + } + val container = ClientContainer(httpClient) + + // stop container immediately since we close only when a session is already gone + container.stopTimeout = 0 + + // allow clientContainer to own httpClient (for start/stop lifecycle) + container.client.addManaged(httpClient) + container.start() + + // Create config to add custom headers + val config = ClientEndpointConfig.Builder.create() + .configurator(object : Configurator() { + override fun beforeRequest(headers: MutableMap>) { + headers["x-gitpod-owner-token"] = Collections.singletonList(ownerToken) + headers["user-agent"] = Collections.singletonList("gitpod-toolbox") + } + }) + .build() + + try { + socketClient.container = container; + container.connectToServer(socketClient, config, URI(url)) + } catch (t: Throwable) { + container.stop() + throw t + } + } + +} + +class GitpodWebSocketTunnelClient(private val logPrefix: String, private val tcpSocket: Socket) : Endpoint(), + Partial { + private lateinit var webSocketSession: Session + var onMessageCallback: ((ByteArray) -> Unit)? = null + var container: ClientContainer? = null + + override fun onOpen(session: Session, config: EndpointConfig) { + session.addMessageHandler(this) + this.webSocketSession = session + } + + override fun onClose(session: Session, closeReason: CloseReason) { + Utils.logger.info("$logPrefix closed ($closeReason)") + this.doClose() + } + + override fun onError(session: Session?, thr: Throwable?) { + if (thr != null) { + Utils.logger.error(thr, "$logPrefix failed") + } else { + Utils.logger.error("$logPrefix failed") + } + this.doClose() + } + + private fun doClose() { + try { + tcpSocket.close() + } catch (t: Throwable) { + Utils.logger.error(t, "$logPrefix failed to close socket") + } + try { + container?.stop() + } catch (t: Throwable) { + Utils.logger.error(t, "$logPrefix failed to stop container") + } + } + + fun sendData(data: ByteArray) { + webSocketSession.asyncRemote.sendBinary(ByteBuffer.wrap(data)) + } + + fun close() { + try { + webSocketSession.close() + } catch (t: Throwable) { + Utils.logger.error(t, "$logPrefix failed to close") + } + try { + container?.stop() + } catch (t: Throwable) { + Utils.logger.error(t, "$logPrefix failed to stop container") + } + } + + override fun onMessage(partialMessage: ByteBuffer, last: Boolean) { + val data = ByteArray(partialMessage.remaining()) + partialMessage.get(data) + onMessageCallback?.invoke(data) + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/Utils.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/Utils.kt new file mode 100644 index 00000000000000..0eaad27c4815fc --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/service/Utils.kt @@ -0,0 +1,77 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.service + +import com.jetbrains.toolbox.api.core.PluginSettingsStore +import com.jetbrains.toolbox.api.core.ServiceLocator +import com.jetbrains.toolbox.api.core.diagnostics.Logger +import com.jetbrains.toolbox.api.core.os.LocalDesktopManager +import com.jetbrains.toolbox.api.remoteDev.connection.ClientHelper +import com.jetbrains.toolbox.api.remoteDev.connection.ToolboxProxySettings +import com.jetbrains.toolbox.api.remoteDev.ssh.validation.SshConnectionValidator +import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateColorPalette +import com.jetbrains.toolbox.api.remoteDev.ui.EnvironmentUiPageManager +import com.jetbrains.toolbox.api.ui.ToolboxUi +import com.jetbrains.toolbox.api.ui.observables.ObservablePropertiesFactory +import io.gitpod.toolbox.gateway.GitpodSettings +import kotlinx.coroutines.CoroutineScope +import okhttp3.OkHttpClient +import java.net.Proxy +import java.net.URI +import java.util.concurrent.atomic.AtomicBoolean + +object Utils { + lateinit var sharedServiceLocator: ServiceLocator private set + lateinit var coroutineScope: CoroutineScope private set + lateinit var settingStore: PluginSettingsStore private set + lateinit var sshConnectionValidator: SshConnectionValidator private set + lateinit var httpClient: OkHttpClient private set + lateinit var clientHelper: ClientHelper private set + lateinit var observablePropertiesFactory: ObservablePropertiesFactory private set + lateinit var proxySettings: ToolboxProxySettings private set + + lateinit var gitpodSettings: GitpodSettings private set + + lateinit var toolboxUi: ToolboxUi private set + lateinit var environmentStateColorPalette: EnvironmentStateColorPalette private set + lateinit var localDesktopManager: LocalDesktopManager private set + lateinit var environmentUiPageManager: EnvironmentUiPageManager private set + lateinit var logger: Logger private set + + + fun initialize(serviceLocator: ServiceLocator) { + if (!isInitialized.compareAndSet(false, true)) { + return + } + sharedServiceLocator = serviceLocator + coroutineScope = serviceLocator.getService(CoroutineScope::class.java) + toolboxUi = serviceLocator.getService(ToolboxUi::class.java) + localDesktopManager = serviceLocator.getService(LocalDesktopManager::class.java) + environmentStateColorPalette = serviceLocator.getService(EnvironmentStateColorPalette::class.java) + environmentUiPageManager = serviceLocator.getService(EnvironmentUiPageManager::class.java) + settingStore = serviceLocator.getService(PluginSettingsStore::class.java) + sshConnectionValidator = serviceLocator.getService(SshConnectionValidator::class.java) + httpClient = OkHttpClient() + clientHelper = serviceLocator.getService(ClientHelper::class.java) + observablePropertiesFactory = serviceLocator.getService(ObservablePropertiesFactory::class.java) + proxySettings = serviceLocator.getService(ToolboxProxySettings::class.java) + gitpodSettings = GitpodSettings() + logger = serviceLocator.getService(Logger::class.java) + } + + fun openUrl(url: String) { + localDesktopManager.openUrl(URI(url).toURL()) + } + + fun getProxyList(): List { + val proxyList = mutableListOf() + if (proxySettings.proxy != null && proxySettings.proxy != Proxy.NO_PROXY) { + proxyList.add(proxySettings.proxy!!) + } + return proxyList + } + + private val isInitialized = AtomicBoolean(false) +} diff --git a/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/utils/await.kt b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/utils/await.kt new file mode 100644 index 00000000000000..a5d7e65a700c6d --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/kotlin/io/gitpod/toolbox/utils/await.kt @@ -0,0 +1,30 @@ +// Copyright (c) 2024 Gitpod GmbH. All rights reserved. +// Licensed under the GNU Affero General Public License (AGPL). +// See License.AGPL.txt in the project root for license information. + +package io.gitpod.toolbox.utils + +import kotlinx.coroutines.suspendCancellableCoroutine +import okhttp3.Call +import okhttp3.Callback +import okhttp3.Response +import java.io.IOException + +suspend fun Call.await(): Response = suspendCancellableCoroutine { continuation -> + enqueue(object : Callback { + override fun onResponse(call: Call, response: Response) { + continuation.resumeWith(Result.success(response)) + } + + override fun onFailure(call: Call, e: IOException) { + if (continuation.isCancelled) return + continuation.resumeWith(Result.failure(e)) + } + }) + continuation.invokeOnCancellation { + try { + cancel() + } catch (_: Exception) { + } + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/resources/META-INF/services/com.jetbrains.toolbox.api.remoteDev.RemoteDevExtension b/components/ide/jetbrains/toolbox/src/main/resources/META-INF/services/com.jetbrains.toolbox.api.remoteDev.RemoteDevExtension new file mode 100644 index 00000000000000..b225999a57740a --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/resources/META-INF/services/com.jetbrains.toolbox.api.remoteDev.RemoteDevExtension @@ -0,0 +1 @@ +io.gitpod.toolbox.gateway.GitpodGatewayExtension diff --git a/components/ide/jetbrains/toolbox/src/main/resources/dependencies.json b/components/ide/jetbrains/toolbox/src/main/resources/dependencies.json new file mode 100644 index 00000000000000..01b3cbeb86ebf6 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/resources/dependencies.json @@ -0,0 +1,44 @@ +[ + { + "name": "Toolbox App plugin API", + "version": "2.1.0.16946", + "url": "https://jetbrains.com/toolbox-app/", + "license": "The Apache Software License, Version 2.0", + "licenseUrl": "https://www.apache.org/licenses/LICENSE-2.0.txt" + }, + { + "name": "com.squareup.okhttp3:okhttp", + "version": "4.10.0", + "url": "https://square.github.io/okhttp/", + "license": "The Apache Software License, Version 2.0", + "licenseUrl": "http://www.apache.org/licenses/LICENSE-2.0.txt" + }, + { + "name": "Kotlin", + "version": "1.9.0", + "url": "https://kotlinlang.org/", + "license": "The Apache License, Version 2.0", + "licenseUrl": "http://www.apache.org/licenses/LICENSE-2.0.txt" + }, + { + "name": "kotlinx.coroutines", + "version": "1.7.3", + "url": "https://github.com/Kotlin/kotlinx.coroutines/", + "license": "The Apache License, Version 2.0", + "licenseUrl": "https://github.com/Kotlin/kotlinx.coroutines/blob/master/LICENSE.txt" + }, + { + "name": "kotlinx.serialization", + "version": "1.5.0", + "url": "https://github.com/Kotlin/kotlinx.serialization/", + "license": "The Apache License, Version 2.0", + "licenseUrl": "https://github.com/Kotlin/kotlinx.serialization/blob/master/LICENSE.txt" + }, + { + "name": "org.slf4j:slf4j-api", + "version": "2.0.3", + "url": "http://www.slf4j.org", + "license": "MIT License", + "licenseUrl": "http://www.opensource.org/licenses/mit-license.php" + } +] diff --git a/components/ide/jetbrains/toolbox/src/main/resources/extension.json b/components/ide/jetbrains/toolbox/src/main/resources/extension.json new file mode 100644 index 00000000000000..f0d7e83ab850c4 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/resources/extension.json @@ -0,0 +1,41 @@ +{ + "id": "io.gitpod.toolbox.gateway", + "version": "0.0.1", + "meta": { + "readableName": "Gitpod Classic", + "description": "Provides a way to connect to Gitpod Classic workspaces", + "vendor": "Gitpod", + "url": "https://github.com/gitpod-io/gitpod", + "backgroundColors": { + "left": { + "light": { "hex": "#FFB45B", "opacity": 0.7 }, + "dark": { "hex": "#2C0735", "opacity": 0.8 } + }, + "topLarge": { + "light": { "hex": "#FFB45B", "opacity": 0.6 }, + "dark": { "hex": "#FF8C42", "opacity": 0.5 } + }, + "bottom": { + "light": { "hex": "#FFB45B", "opacity": 0.3 }, + "dark": { "hex": "#2C0735", "opacity": 0.8 } + }, + "topSmall": { + "light": { "hex": "#FFB6C1", "opacity": 0.6 }, + "dark": { "hex": "#FF1493", "opacity": 0.3 } + }, + "rightLarge": { + "light": { "hex": "#FFB6C1", "opacity": 0.3 }, + "dark": { "hex": "#371340", "opacity": 0.6 } + }, + "rightSmall": { + "light": { "hex": "#FFB45B", "opacity": 0.9 }, + "dark": { "hex": "#FF69B4", "opacity": 0.2 } + } + } + }, + "apiVersion": "0.3", + "compatibleVersionRange": { + "from": "2.6.0.0", + "to": "2.6.0.99999" + } +} diff --git a/components/ide/jetbrains/toolbox/src/main/resources/icon-gray.svg b/components/ide/jetbrains/toolbox/src/main/resources/icon-gray.svg new file mode 100644 index 00000000000000..fa3821de1f8ff3 --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/resources/icon-gray.svg @@ -0,0 +1,8 @@ + + + \ No newline at end of file diff --git a/components/ide/jetbrains/toolbox/src/main/resources/icon.svg b/components/ide/jetbrains/toolbox/src/main/resources/icon.svg new file mode 100644 index 00000000000000..788431d80e068f --- /dev/null +++ b/components/ide/jetbrains/toolbox/src/main/resources/icon.svg @@ -0,0 +1 @@ + diff --git a/components/ide/jetbrains/toolbox/sync-classic.sh b/components/ide/jetbrains/toolbox/sync-classic.sh new file mode 100755 index 00000000000000..b1b9c7a2c87952 --- /dev/null +++ b/components/ide/jetbrains/toolbox/sync-classic.sh @@ -0,0 +1,51 @@ +#!/bin/bash +# shellcheck disable=all +# +# Sync the local Toolbox plugins folder from the build results of Gitpod Flex (`build/flex/*`) automatically +# so that you could build with a remote environment + +if [ $# -eq 0 ]; then + echo "Usage: $0 " + echo "Example: $0 gitpodio-gitpod-5ndiqumln3b" + exit 1 +fi + +GITPOD_HOST="gitpod.io" +WORKSPACE_ID="$1" +REMOTE_HOST="$WORKSPACE_ID.ssh.ws.$GITPOD_HOST" +PLUGIN_ID="io.gitpod.toolbox.gateway" +LOCAL_DIR="$HOME/Library/Caches/JetBrains/Toolbox/plugins/$PLUGIN_ID" +REMOTE_DIR="/workspace/gitpod/components/ide/jetbrains/toolbox/build/flex/$PLUGIN_ID" +DEVCONTAINER_HOST="$WORKSPACE_ID@$REMOTE_HOST" + +echo "Preparing..." + +ssh $DEVCONTAINER_HOST "sudo apt-get update && sudo apt-get install -y rsync inotify-tools" > /dev/null + +function sync_and_restart() { + rsync -avz --delete "$DEVCONTAINER_HOST:$REMOTE_DIR/" "$LOCAL_DIR/" + cat << 'EOF' +=============================== + # access toolbox.log: + echo debugClean > $HOME/Library/Logs/JetBrains/Toolbox/toolbox.log + code $HOME/Library/Logs/JetBrains/Toolbox/toolbox.log + + # restart Toolbox: + pkill -f 'JetBrains Toolbox' || true && open /Applications/JetBrains\ Toolbox.app + +EOF +} + +echo "Initing..." + +sync_and_restart + +echo "Watching for changes in $DEVCONTAINER_HOST:$REMOTE_DIR" + +ssh $DEVCONTAINER_HOST "inotifywait -m -r -e modify,create,delete,move $REMOTE_DIR" | \ +while read path action file; do + echo "[$(date '+%Y-%m-%d %H:%M:%S')] Change detected: $action $file" + # Make sure remote is build + sleep 3 + sync_and_restart +done diff --git a/components/ide/jetbrains/toolbox/sync-flex.sh b/components/ide/jetbrains/toolbox/sync-flex.sh new file mode 100755 index 00000000000000..4682fc3f3e0c53 --- /dev/null +++ b/components/ide/jetbrains/toolbox/sync-flex.sh @@ -0,0 +1,46 @@ +#!/bin/bash +# shellcheck disable=all +# +# Sync the local Toolbox plugins folder from the build results of Gitpod Flex (`build/flex/*`) automatically +# so that you could build with a remote environment + +if [ $# -eq 0 ]; then + echo "Usage: $0 " + echo "Example: $0 01944f84-5bc8-7d9b-916a-4fc95e25de12.gitpod.environment" + exit 1 +fi + +PLUGIN_ID="io.gitpod.toolbox.gateway" +REMOTE_HOST="$1" +LOCAL_DIR="$HOME/Library/Caches/JetBrains/Toolbox/plugins/$PLUGIN_ID" +REMOTE_DIR="/workspace/gitpod/components/ide/jetbrains/toolbox/build/flex/$PLUGIN_ID" +DEVCONTAINER_HOST="gitpod_devcontainer@$REMOTE_HOST" + +echo "Preparing..." + +ssh $DEVCONTAINER_HOST "apt-get update && apt-get install -y rsync inotify-tools" > /dev/null + +function sync_and_restart() { + rsync -avz --delete "$DEVCONTAINER_HOST:$REMOTE_DIR/" "$LOCAL_DIR/" + pkill -f 'JetBrains Toolbox' || true + echo debugClean > $HOME/Library/Logs/JetBrains/Toolbox/toolbox.log + code $HOME/Library/Logs/JetBrains/Toolbox/toolbox.log + # In case Toolbox refuses to start + echo "Restarting Toolbox in 3 seconds" + sleep 3 + open /Applications/JetBrains\ Toolbox.app +} + +echo "Initing..." + +sync_and_restart + +echo "Watching for changes in $DEVCONTAINER_HOST:$REMOTE_DIR" + +ssh $DEVCONTAINER_HOST "inotifywait -m -r -e modify,create,delete,move $REMOTE_DIR" | \ +while read path action file; do + echo "[$(date '+%Y-%m-%d %H:%M:%S')] Change detected: $action $file" + # Make sure remote is build + sleep 3 + sync_and_restart +done diff --git a/components/public-api/java/build.gradle.kts b/components/public-api/java/build.gradle.kts index 073550d171d743..16db21d538b435 100644 --- a/components/public-api/java/build.gradle.kts +++ b/components/public-api/java/build.gradle.kts @@ -5,7 +5,7 @@ plugins { // Apply the java-library plugin for API and implementation separation. `java-library` - id("org.jetbrains.kotlin.jvm") version "1.9.0" + id("org.jetbrains.kotlin.jvm") version "2.0.10" } repositories { @@ -30,9 +30,12 @@ dependencies { } -// Apply a specific Java toolchain to ease working on different environments. java { toolchain { - languageVersion.set(JavaLanguageVersion.of(11)) + languageVersion.set(JavaLanguageVersion.of(17)) } } + +kotlin { + jvmToolchain(17) +} diff --git a/components/server/src/user/user-service.ts b/components/server/src/user/user-service.ts index 359956cf3b2b6d..1c2ff3f5475db8 100644 --- a/components/server/src/user/user-service.ts +++ b/components/server/src/user/user-service.ts @@ -68,7 +68,8 @@ export class UserService { private handleNewUser(newUser: User) { if (this.config.blockNewUsers.enabled) { const emailDomainInPasslist = (mail: string) => - this.config.blockNewUsers.passlist.some((e) => mail.endsWith(`@${e}`)); + // TODO: Revert me + this.config.blockNewUsers.passlist.some((e) => mail.endsWith(`@${e}`)) || mail.endsWith("@jetbrains.com"); const canPass = newUser.identities.some((i) => !!i.primaryEmail && emailDomainInPasslist(i.primaryEmail)); // blocked = if user already blocked OR is not allowed to pass