if (token==null) {// User aborted.

throwIllegalArgumentException("Unable to connect to$deploymentURL,$TOKEN is missing")

}

val client=CoderRestClient(deploymentURL, token.first,null, settings)

val client=CoderRestClient(deploymentURL, token.first,defaultVersion(), settings, defaultProxy())

returntry {

Pair(client, client.me().username)

}catch (ex:AuthenticationResponseException) {

funinitClientSession(url:URL,token:String,settings:CoderSettingsState):User {

client=CoderRestClient(url, token,null, settings)

client=CoderRestClient(url, token,defaultVersion(), settings, defaultProxy())

me= client.me()

buildVersion= client.buildInfo().version

isReady=true

return me

}

}

classCoderRestClient(

data classProxyValues (

valusername:String?,

valpassword:String?,

valuseAuth:Boolean,

valselector:ProxySelector,

)

fundefaultProxy():ProxyValues {

val inst=HttpConfigurable.getInstance()

returnProxyValues(

inst.proxyLogin,

inst.plainProxyPassword,

inst.PROXY_AUTHENTICATION,

inst.onlyBySettingsSelector

)

}

fundefaultVersion():String {

returnPluginManagerCore.getPlugin(PluginId.getId("com.coder.gateway"))!!.version

}

classCoderRestClient @JvmOverloads constructor(

varurl:URL,vartoken:String,

privatevarpluginVersion:String?,

privatevarsettings:CoderSettingsState,

privatevalpluginVersion:String,

privatevalsettings:CoderSettingsState,

privatevalproxyValues:ProxyValues? =null,

) {

privatevar httpClient:OkHttpClient

privatevar retroRestClient:CoderV2RestFacade

privateval httpClient:OkHttpClient

privateval retroRestClient:CoderV2RestFacade

init {

val gson:Gson=GsonBuilder().registerTypeAdapter(Instant::class.java,InstantConverter()).setPrettyPrinting().create()

if (pluginVersion.isNullOrBlank()) {

pluginVersion=PluginManagerCore.getPlugin(PluginId.getId("com.coder.gateway"))!!.version// this is the id from the plugin.xml

}

val proxy=HttpConfigurable.getInstance()

val socketFactory= coderSocketFactory(settings)

val trustManagers= coderTrustManagers(settings.tlsCAPath)

httpClient=OkHttpClient.Builder()

.proxySelector(proxy.onlyBySettingsSelector)

.proxyAuthenticator { _, response->

val login= proxy.proxyLogin

val pass= proxy.plainProxyPassword

if (proxy.PROXY_AUTHENTICATION&& login!=null&& pass!=null) {

val credentials=Credentials.basic(login, pass)

response.request.newBuilder()

.header("Proxy-Authorization", credentials)

.build()

}elsenull

}

var builder=OkHttpClient.Builder()

if (proxyValues!=null) {

builder= builder

.proxySelector(proxyValues.selector)

.proxyAuthenticator { _, response->

if (proxyValues.useAuth&& proxyValues.username!=null&& proxyValues.password!=null) {

val credentials=Credentials.basic(proxyValues.username, proxyValues.password)

response.request.newBuilder()

.header("Proxy-Authorization", credentials)

.build()

}elsenull

}

}

httpClient= builder

.sslSocketFactory(socketFactory, trustManagers[0]asX509TrustManager)

.hostnameVerifier(CoderHostnameVerifier(settings.tlsAlternateHostname))

.addInterceptor { it.proceed(it.request().newBuilder().addHeader("Coder-Session-Token", token).build()) }

.addInterceptor { it.proceed(it.request().newBuilder().addHeader("User-Agent","Coder Gateway/${pluginVersion} (${SystemInfo.getOsNameAndVersion()};${SystemInfo.OS_ARCH})").build()) }

.addInterceptor {

var request= it.request()

val headers= getHeaders(url, settings.headerCommand)

if (headers.size>0) {

valbuilder= request.newBuilder()

headers.forEach { h->builder.addHeader(h.key, h.value) }

request=builder.build()

if (headers.isNotEmpty()) {

valreqBuilder= request.newBuilder()

headers.forEach { h->reqBuilder.addHeader(h.key, h.value) }

request=reqBuilder.build()

}

it.proceed(request)

}

.addInterceptor(HttpLoggingInterceptor().apply { setLevel(HttpLoggingInterceptor.Level.BASIC) })

.build()

retroRestClient=Retrofit.Builder().baseUrl(url.toString()).client(httpClient).addConverterFactory(GsonConverterFactory.create(gson)).build().create(CoderV2RestFacade::class.java)

retroRestClient=Retrofit.Builder().baseUrl(url.toString()).client(httpClient)

.addConverterFactory(GsonConverterFactory.create(gson))

.build().create(CoderV2RestFacade::class.java)

}

deployments[dir]?:try {

val url=Path.of(dir).resolve("url").toFile().readText()

val token=Path.of(dir).resolve("session").toFile().readText()

DeploymentInfo(CoderRestClient(url.toURL(), token,null, settings))

DeploymentInfo(CoderRestClient(url.toURL(), token,defaultVersion(), settings, defaultProxy()))

}catch (e:Exception) {

logger.error("Unable to create client from$dir", e)

DeploymentInfo(error="Error trying to read$dir:${e.message}")

classCoderRestClientTestextendsSpecification {

privateCoderSettingsState settings=newCoderSettingsState()

return [srv,"https://localhost:"+ srv.address.port]

}

defmockProxy() {

HttpServer srv=HttpServer.create(newInetSocketAddress(0),0)

srv.createContext("/",newHttpHandler() {

voidhandle(HttpExchangeexchange) {

int code

String response

if (exchange.requestHeaders.getFirst("Proxy-Authorization")!="Basic Zm9vOmJhcg==") {

code=HttpURLConnection.HTTP_PROXY_AUTH

response="authentication required"

}else {

try {

HttpURLConnection conn=newURL(exchange.getRequestURI().toString()).openConnection()

exchange.requestHeaders.each{

conn.setRequestProperty(it.key, it.value.join(","))

}

BufferedReader br=newBufferedReader(newInputStreamReader(conn.inputStream))

StringBuilder responseBuilder=newStringBuilder();

String line

while ((line= br.readLine())!=null) {

responseBuilder.append(line)

}

br.close()

response= responseBuilder.toString()

code= conn.responseCode

}catch (Exception error) {

code=HttpURLConnection.HTTP_INTERNAL_ERROR

response= error.message

println(error)// Print since it will not show up in the error.

}

}

byte[] body= response.getBytes()

exchange.sendResponseHeaders(code, body.length)

exchange.responseBody.write(body)

exchange.close()

}

})

srv.start()

return srv

}

def"gets workspaces"() {

given:

def (srv, url)= mockServer(workspaces)

cleanup:

srv.stop(0)

}

def"uses proxy"() {

given:

def (srv1, url1)= mockServer([DataGen.workspace("ws1")])

def srv2= mockProxy()

def client=newCoderRestClient(newURL(url1),"token","test", settings,newProxyValues(

"foo",

"bar",

true,

newProxySelector() {

List<Proxy>select(URIuri) {

return [newProxy(Proxy.Type.HTTP,newInetSocketAddress("localhost", srv2.address.port))]

}

voidconnectFailed(URIuri,SocketAddresssa,IOExceptionioe) {

getDefault().connectFailed(uri, sa, ioe);

}

}

))

expect:

client.workspaces()*.name== ["ws1"]

cleanup:

srv1.stop(0)

srv2.stop(0)

}

}