Debug del codice Scala con simple-build-tool (sbt) e IntelliJ

Qual è il modo più semplice per eseguire il debug del codice Scala gestito da sbt utilizzando il debugger integrato di IntelliJ? La documentazione da "RunningSbt" dal sito di codice google di sbt elenca i comandi per eseguire la classe principale per un progetto o per i test, ma sembra che non ci siano comandi per il debug.

Domanda di follow-up: qual è il modo più semplice per collegare il debugger di IntelliJ a Jetty quando si utilizza il comando jetty-run di sbt?

Per il debug ordinario in IntelliJ, è possibile utilizzare una configurazione di esecuzione / debug dell'applicazione nel solito modo, indipendentemente dal fatto che si utilizzi sbt per compilare il codice.

Per connetterti alla tua applicazione in esecuzione in Jetty, dovrai creare una configurazione di debug remoto. Quando lo fai, IntelliJ ti fornirà una serie di argomenti della riga di comando per eseguire la JVM remota, qualcosa di simile

-Xdebug -Xrunjdwp: trasporto = dt_socket, server = y, suspend = n, indirizzo = 5005

Avvia sbt con questi argomenti e poi esegui jetty-run. Infine, avvia la configurazione del debug remoto in IntelliJ. Questo thread potrebbe essere utile.

C'è un -jvm-debugflag molto conveniente nei pacchetti SBT ufficiali per Mac, Linux e Windows . È possibile utilizzare il flag per specificare la porta di debug:

sbt -jvm-debug 5005

Sotto le coperte , questo avvia la JVM per SBT con il tipico incantesimo di debug dettagliato:

-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005

Ora puoi eseguire il tuo codice normalmente, ad esempio con il runcomando sbt .

Configurazione di IntelliJ per la connessione al codice in esecuzione ...

Ora connetti IntelliJ al processo in esecuzione utilizzando una configurazione di debug remoto . Si noti che i superiori 3 campi in questa forma, mentre spaventoso, sono solo per copiare il testo fuori di, piuttosto che in (che stanno dando il verbose debug incantesimo sopra specificato, che -jvm-debugprende già cura di per voi) - l'unica configurazione puoi cambiare è nella Settingssezione a metà:

Ho avuto qualche problema anche con questo, quindi a rischio di essere eccessivamente dettagliato, ecco cosa ho fatto:

IMPOSTARE

1. Creare una configurazione di esecuzione per sbt jetty-run

   • Vai a Esegui> Modifica configurazioni
   • Fare clic sull'icona [+] e scegliere Scala Compilation Server
   • Immettere il nome che si desidera e fare clic sulla casella di controllo "Esegui azione SBT" e selezionare il jetty-run dell'azione SBT dal [...]

2. Crea una configurazione di debug per il debug remoto

   • Vai a Esegui> Modifica configurazioni
   • Fare clic sull'icona [+] e scegliere Remote
   • Inserisci il nome che desideri e copia la riga -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005(assicurati di fare clic su OK per creare effettivamente la configurazione)

3. Configura il plugin sbt per eseguire le opzioni vm sopra

   • Vai a File> Impostazioni> SBT
   • Incolla la riga -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005nella casella dei parametri della VM, dopo quelle già presenti

DEBUGGING

1. Impostare i punti di interruzione come desiderato
2. Avvia il server web jetty scegliendo la configurazione jetty-run sbt creata sopra e scegliendo Esegui> Esegui o facendo clic sulla freccia verde
3. Avvia il debugger remoto scegliendo la configurazione di debug remoto creata sopra e scegliendo Esegui> Debug o facendo clic sull'icona del bug

Questo funziona per me ogni volta e l'unica cosa che devi impostare è il debug remoto in IntelliJ; Avvio SBT con i parametri JVM dal terminale in IntelliJ:

sbt -J-Xdebug -J-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005

Dopodiché posso avviare il debug remoto su localhost: 5005

Aggiungo un'altra risposta qui, perché ho trovato questa domanda durante la ricerca di un problema correlato: Debug delle classi di test utilizzando i punti di interruzione.

Sto usando ScalaTest e di solito eseguo una suite usando il comando "solo test" di sbt. Ora, quando voglio utilizzare il debugger interattivo, posso fare quanto segue:

Creare una nuova configurazione di esecuzione / debug di tipo 'ScalaTest', inserire il nome principale "Classe di test:" e scegliere "Prima del lancio: eseguire l'azione SBT 'test-compile'". Ecco fatto, ora puoi posizionare i punti di interruzione nelle sorgenti di test ed eseguire questa configurazione.

Nessuna di queste risposte o collegamenti forniti ha funzionato per me, quindi una volta capito, ho pensato di condividere ...

compresa la comprensione di base che non avevo quando ho iniziato ...

Questo si basa principalmente sulle istruzioni qui solo con una spiegazione aggiuntiva che mi ha portato attraverso di essa.

Il mio ambiente: Scala 2.10.2, SBT 0.13 e IntelliJ 13.1

Sfondo:

• Per qualsiasi motivo, l'utilizzo di SBT per compilare Scala in IntelliJ non è integrato nel modo in cui sono i progetti Maven (che consentono il debug molto facilmente).
• Da quanto ho capito, quando compili con SBT, stai compilando in un processo separato, quindi devi eseguire il debug da remoto.

Cos'è il debug?

• Il debug è una modalità in cui è possibile eseguire la JVM o l'app che consente di controllare il flusso di esecuzione del codice.
• Lo strumento di debug che utilizzi può quindi inviare comandi al motore di debug che gli dice "esegui la riga di codice successiva e poi metti di nuovo in pausa" o "continua l'esecuzione" o "ottieni il valore della variabile archiviata qui in memoria".

Cos'è il debug remoto?

• Il debug remoto esegue il debug su una connessione di rete (socket).
• Questa connessione di rete consente di inviare i comandi al motore di debug da una macchina remota.
• Ciò è utile quando si desidera eseguire il debug del codice in esecuzione su un server remoto, MA
• È anche utile per situazioni come il codice Scala eseguito sotto SBT e avviato tramite un server web, come Jetty o Tomcat, separato dall'ambiente IntelliJ.

Facendo riferimento al collegamento sopra, sono utili le seguenti spiegazioni / modifiche:

1. Configurare IntelliJ per avviare SBT con le impostazioni JVM "abilita debug", inclusa la porta da utilizzare durante la configurazione del socket di rete. (invariato) aggiungi i parametri VM denominati alle impostazioni di IntelliJ.
2. Assicurati che il tuo numero di porta qui corrisponda alle tue impostazioni JVM dal passaggio 1.
3. Quando avvii SBT, devi farlo dal plug-in della console SBT (che è ciò che hai configurato nel passaggio 1). Se esegui SBT al di fuori di IntelliJ (dalla riga di comando), dovrai avviare SBT con gli stessi parametri della VM dal passaggio 1 (non l'ho fatto; quindi nessuna istruzione). Dopo questo passaggio, SBT è ora in esecuzione (ma il codice non è ancora) e la JVM è configurata per il debug remoto.
4. Verrà avviato lo strumento di debug di IntelliJ, che si connette alla JVM avviata nel passaggio 3.
5. Infine, avvia la compilazione nella console SBT. Puoi farlo con qualsiasi comando di compilazione, incluso un comando di compilazione continua. Se si ricompila continuamente, la ricompilazione avverrà, ma non mentre l'esecuzione del codice è sospesa dal debugger.

Ho anche lottato con il debug su Windows con un'app Spray-can / Akka / Scala creata tramite SBT, utilizzando Intellij. Mettendo insieme vari suggerimenti, l'approccio più semplice per me è stato:

1. Assicurati di avere sbt.Revolver nel tuo file project / plugsin.sbt, ad es

   addSbtPlugin ("io.spray"% "sbt-revolver"% "0.7.1")

2. Imposta javaoptions nel tuo file build.sbt:

   javaOptions: = Seq ("- Xdebug", "-Xrunjdwp: transport = dt_socket, server = y, suspend = y, address = 5005")

In particolare, usa l'opzione suspend = y. L'app manterrà l'app fino a quando non connetti un debugger remoto da Intellij

3. Impostare una configurazione del debugger in Intellij tramite il menu Esegui / Modifica configurazioni. Premere il pulsante +, selezionare l'opzione "Remote". Assicurati che le voci corrispondano alle opzioni java sopra, in particolare l'indirizzo della porta di 5005. Assegna alla configurazione un nome come "Spray".

4. Dalla tua console SBT usa il comando re-start. Dovresti vedere l'indirizzo della porta 5005 nell'output di feedback.

5. In Intellij imposta i tuoi punti di interruzione.

6. Da Intellij, seleziona Esegui \ Debug "Spray". Questo dovrebbe connettersi al server web della bomboletta spray. Dovresti essere in grado di vedere molti thread nella finestra di debug.

7. Fai attenzione che alcune delle direttive Get in Spray sembrano essere eseguite all'avvio ma non ripetutamente quando si chiama il sito web.

Utilizzando Scala 2.10 e SBT 0.12, ho funzionato in questo modo: http://tuliodomingos.blogspot.com.es/2014/01/scala-remote-debugging-in-sbts-jetty.html

Per quello che vale la gente di Windows, modifica %SBT_HOME%\bin\sbt.bate individua le seguenti righe di codice:

:run

"%_JAVACMD%" %_JAVA_OPTS% %SBT_OPTS% -cp "%SBT_HOME%sbt-launch.jar" xsbt.boot.Boot %*
if ERRORLEVEL 1 goto error
goto end

quindi sostituiscili con questo codice:

FOR %%a IN (%*) DO (
  if "%%a" == "-jvm-debug" (
    set JVM_DEBUG=true
    set /a JVM_DEBUG_PORT=5005 2>nul >nul
  ) else if "!JVM_DEBUG!" == "true" (
    set /a JVM_DEBUG_PORT=%%a 2>nul >nul
    if not "%%a" == "!JVM_DEBUG_PORT!" (
      set SBT_ARGS=!SBT_ARGS! %%a
    )
  ) else (
    set SBT_ARGS=!SBT_ARGS! %%a
  )
)

if defined JVM_DEBUG_PORT (
  set _JAVA_OPTS=!_JAVA_OPTS! -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=!JVM_DEBUG_PORT!
)

call :run %SBT_ARGS%

if ERRORLEVEL 1 goto error
goto end

:run
"%_JAVACMD%" %_JAVA_OPTS% %SBT_OPTS% -cp "%SBT_HOME%sbt-launch.jar" xsbt.boot.Boot %*
goto :eof

Il meglio che posso fare per ottenere lo stesso comportamento -jvm-debug quando viene visualizzato nel programma di avvio degli script Bash

NB. Non penso %SBT_HOME%che esista effettivamente al di fuori di questo script, a meno che tu non l'abbia creato esplicitamente nel tuo ambiente, ma comunque ottieni il punto: D

File-> Impostazioni-> Altre impostazioni-> Parametri VM SBT -Xmx512M -XX: MaxPermSize = 256M -Xdebug -Xrunjdwp: transport = dt_socket, server = y, suspend = n, address = 5005

Esegui-> Modifica configurazioni Premere + e quindi selezionare remoto Premere Applica

Ora nella console SBT (avviato da intelliJ) quando esegui il comando 'run' vedrai "Listening for transport dt_socket all'indirizzo: 5005"

Ora premi Esegui-> Debug. Vedrai i menu di debug di seguito attivati. Ha due schede Debugger e Console.

Usa F7 per dalla riga successiva alla successiva

Ho scelto di sospendere come n. Essendo y quando ho eseguito il comando di esecuzione, era bloccato

export SBT_OPTS=-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5009

prova questo

Ho anche avuto lo stesso problema, mi piace condividere come ho risolto. A proposito, sto usando Ubuntu 14.04 e IntelliJ 15.

1. In Impostazioni -> SBT -> Incollato sotto la riga nella casella di testo Parametri VM:

   -XX: MaxPermSize = 384M -Xdebug -Xrunjdwp: transport = dt_socket, server = y, suspend = n, address = 5005

2. Ha aperto Termilal in IntelliJ ed eseguito:

   sbt -jvm-debug 5005

   Nota: dovresti vedere questa riga nel terminale: "Listening for transport dt_socket all'indirizzo: 5005"

3. Modifica configurazioni -> Fai clic su + -> Seleziona "Remoto"

   I. Give some name example: DebugMyModule
   
   II. All needed configurations will be set automatically, But you just verify. In Command line arguments should look like this "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005".
   
   III. In 'Search Sources in Module's Classpath' text box specify your module in which module your test cases are there.
   
   IV. put 127.0.0.1 host instead of 'localhost'. 'localhost' not working for me.

4. Seleziona DebugMyModule nella Edit Configurationscasella di riepilogo e fai clic su Debug .

   Nota: dovresti vedere la visualizzazione di debug aperta e nella console di debug dovresti essere in grado di vedere "Connesso alla VM di destinazione, indirizzo:, '127.0.0.1:5005'trasporto: 'socket'"

5. Inserisci punti di interruzione in alcuni casi di test nella tua classe di test.

6. Vieni al terminale dove corri " sbt -jvm-debug 5005" e corri come sotto

   project <your-module-name>
   it:testOnly package.TestSpec

   Ad esempio: com.myproject.module.AddServiceTest [Spec]

7. Puoi vedere il debug avviato nel punto di interruzione del test case.

Il plug-in AttachMe IntelliJ è potenzialmente più veloce nel collegare il debugger senza dover armeggiare con i numeri di porta:

AttachMe collegherà automaticamente il debugger di IntelliJ anche se avvii l'app dal terminale (o in qualsiasi altro modo). Non è necessario attivare Attach to processmanualmente l'azione.

Il post sul blog e il file readme contengono istruzioni per la configurazione, tuttavia ho dovuto modificarle un po 'per farlo funzionare sulla mia macchina

1. Scarica lo installer.shscript dal repository ufficiale

   curl -o installer.shhttps://raw.githubusercontent.com/JetBrains/attachme/master/installer.sh

2. Dagli i permessi eseguibili chmod u+x installer.sh
3. Eseguilo con ./installer.sh
4. Questo dovrebbe installare l'agente in /.config/attachme/agent.jare creare il ~/.attachmefile

5. Modifica ~/.attachmeper contenere

   AM_JDWP_ARGS="transport=dt_socket,server=y,suspend=y,address=127.0.0.1:0"
   echo Using JDWP arguments ${AM_JDWP_ARGS}
   export JAVA_TOOL_OPTIONS="- javaagent:/Users/mario_galic/.config/attachme/agent.jar -agentlib:jdwp=${AM_JDWP_ARGS}"
   echo "AttachMe configured successfully"

6. Installa il plug-in Attachme corrispondente e riavvia: IntelliJ | Preferences | Plugins

7. Crea Attachmeconfigurazione corsa:Run | Edit configurations... | Add new configuration | Attachme debugger registry | OK

Dopo questi imbrogli unici, possiamo allegare automaticamente un debugger tramite

1. Avvia la Attachmeconfigurazione della corsa
2. source ~/.attachme
3. Avvia l'applicazione dal terminale, forse, sbt "runMain example.Hello"
4. Il debugger dovrebbe collegarsi e arrestarsi automaticamente a qualsiasi punto di interruzione

Come per la risposta di Roberto Tyley sopra, ma in Windows dobbiamo anche impostare le seguenti variabili d'ambiente dopo l'installazione di sbt:

SBT_HOME
C: \ Programmi (x86) \ sbt \
[o ovunque sia installato sbt]

SBT_OPTS
-Xdebug -runjdwp: transport = dt_socket, server = y, suspend = n, address = 5005

[secondo l'esempio IntelliJ di RT]

Aggiungi al percorso:% SBT_HOME% \ bin;% SBT_OPTS%

Quindi eseguire quanto segue nella riga di comando all'interno della cartella del progetto "sbt run -jvm -debug 5005".

Se funziona correttamente, la riga di comando inizialmente produrrà una riga "Ascolto per trasporto dt_socket all'indirizzo: 5005".

Imposta punto di interruzione in IntelliJ.

Aprire il sito Web nel browser per attivare il punto di interruzione del debugger, ad esempio " http: // localhost: 9000 / ".