Depurando código Scala com simple-build-tool (sbt) e IntelliJ

Qual é a maneira mais fácil de depurar o código Scala gerenciado pelo sbt usando o depurador interno do IntelliJ? A documentação de "RunningSbt" do site de códigos do google da sbt lista comandos para executar a classe principal de um projeto ou de testes, mas parece não haver comandos para depuração.

Pergunta de acompanhamento: qual é a maneira mais fácil de conectar o depurador do IntelliJ ao Jetty ao usar o comando jetty-run do sbt?

Para depuração comum no IntelliJ, você pode usar uma configuração de execução / depuração de aplicativo da maneira usual, independentemente de estar usando sbt para compilar seu código.

Para se conectar ao seu aplicativo em execução no Jetty, você precisará criar uma configuração de depuração remota. Quando você faz isso, o IntelliJ fornece um conjunto de argumentos de linha de comando para executar a JVM remota - algo como

-Xdebug -Xrunjdwp: transporte = dt_socket, servidor = y, suspensão = n, endereço = 5005

Inicie o sbt com esses argumentos e execute jetty-run. Por fim, inicie sua configuração de depuração remota no IntelliJ. Este tópico pode ser útil.

Há uma -jvm-debugbandeira muito conveniente nos pacotes oficiais do SBT para Mac, Linux e Windows . Você pode usar o sinalizador para especificar a porta de depuração:

sbt -jvm-debug 5005

Nos bastidores , isso inicia a JVM para SBT com o encantamento detalhado típico de depuração:

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

Agora você pode executar seu código normalmente, por exemplo, com o runcomando sbt .

Configurando o IntelliJ para conectar-se ao código em execução ...

Agora você conecta o IntelliJ ao processo em execução usando uma configuração de Depuração Remota . Note-se que os superiores 3 campos deste formulário, enquanto assustador, são apenas para você copiar o texto fora de, em vez de em (eles estão dando o verbose de depuração encantamento especificado acima, que -jvm-debugjá cuida para você) - a única configuração você pode mudar está na Settingsseção até a metade:

Também tive alguns problemas com isso, então, correndo o risco de ser excessivamente detalhado, eis o que fiz:

CONFIGURAÇÃO

1. Crie uma configuração de execução para sbt jetty-run

   • Vá para Executar> Editar configurações
   • Clique no ícone [+] e escolha Scala Compilation Server
   • Digite o nome que desejar e clique na caixa de seleção "Executar ação do SBT" e marque o jet-action do SBT-Action no [...]

2. Crie uma configuração de depuração para depuração remota

   • Vá para Executar> Editar configurações
   • Clique no ícone [+] e escolha Remoto
   • Digite o nome desejado e copie a linha -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005(clique em OK para criar a configuração)

3. Configure o plugin sbt para executar as opções vm acima

   • Vá para Arquivo> Configurações> SBT
   • Cole a linha -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005na caixa de parâmetros da VM, depois das que já estão lá

DEBUGGING

1. Defina pontos de interrupção conforme desejado
2. Inicie o servidor da web jetty escolhendo a configuração sbt jetty-run que você criou acima e escolhendo Executar> Executar ou clicando na seta verde
3. Inicie o depurador remoto escolhendo a configuração de depuração remota criada acima e escolhendo Executar> Depurar ou clicando no ícone do bug

Este funciona para mim todas as vezes, e a única coisa que você precisa configurar é a depuração remota no IntelliJ; Eu inicio o SBT com parâmetros da JVM a partir do terminal no IntelliJ:

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

Depois disso, posso iniciar a depuração remota no localhost: 5005

Estou adicionando outra resposta aqui, porque encontrei esta pergunta ao procurar um problema relacionado: Depurando classes de teste usando pontos de interrupção.

Estou usando o ScalaTest e normalmente executo um conjunto usando o comando 'test-only' do sbt. Agora, quando quero usar o depurador interativo, posso fazer o seguinte:

Crie uma nova Configuração de Execução / Depuração do tipo 'ScalaTest', coloque o nome principal "Classe de Teste:" e escolha "Antes de iniciar: Execute a Ação do SBT 'compilar' '. É isso, você pode colocar pontos de interrupção agora nas fontes de teste e executar esta configuração.

Nenhuma dessas respostas ou links fornecidos funcionou para mim; portanto, depois que eu descobri isso, pensei em compartilhar ...

incluindo o conhecimento de fundo que eu não tinha quando comecei ...

Isso se baseia principalmente nas instruções aqui, apenas com explicações adicionais que me levaram a isso.

Meu ambiente: Scala 2.10.2, SBT 0.13 e IntelliJ 13.1

Fundo:

• Por qualquer motivo, o uso do SBT para compilar o Scala no IntelliJ não está integrado da maneira que os projetos do Maven (que permitem a depuração com muita facilidade).
• Parece que, ao compilar com o SBT, você está compilando em um processo separado; portanto, é necessário depurar remotamente.

O que é depuração?

• A depuração é um modo no qual você pode executar sua JVM ou aplicativo que permite controlar o fluxo de execução do código.
• A Ferramenta de Depuração usada pode emitir comandos para o Mecanismo de Depuração, que informa "execute a próxima linha de código e faça uma pausa novamente" ou "continue executando" ou "obtenha o valor da variável armazenada aqui na memória".

O que é depuração remota?

• A depuração remota está depurando em uma conexão de rede (soquete).
• Essa conexão de rede permite que você emita os comandos para o Mecanismo de depuração de uma máquina remota.
• Isso é útil para quando você deseja depurar o código que está sendo executado em um servidor remoto, MAS
• Também é útil para situações como o código Scala executando no SBT e iniciando através de um servidor Web, como Jetty ou Tomcat, separado do seu ambiente IntelliJ.

Referenciando o link acima, as seguintes explicações / modificações são úteis:

1. Configure o IntelliJ para iniciar o SBT com as configurações da JVM "enable debugging", incluindo a porta a ser usada ao configurar o soquete de rede. (inalterado) adicione os parâmetros VM nomeados às suas configurações do IntelliJ.
2. Verifique se o número da porta aqui corresponde às configurações da JVM da Etapa 1.
3. Quando você inicia o SBT, é necessário fazê-lo a partir do plug-in do SBT Console (que é o que você configurou na Etapa 1). Se você estiver executando o SBT fora do IntelliJ (na linha de comando), precisará iniciar o SBT com os mesmos parâmetros de VM da Etapa 1 (não fiz isso; portanto, não há instruções). Após esta etapa, o SBT está em execução (mas seu código ainda não está) e a JVM está configurada para Depuração Remota.
4. Isso inicia a IntelliJ Debugging Tool, que se conecta à JVM iniciada na Etapa 3.
5. Por fim, você inicia a compilação no console do SBT. Você pode fazer isso com qualquer comando de compilação, incluindo um comando de compilação contínua. Se a recompilação contínua ocorrer, a recompilação ocorrerá, mas não enquanto a execução do código estiver em pausa pelo depurador.

Também estou lutando com a depuração no Windows com um aplicativo Spray-can / Akka / Scala criado via SBT, usando o Intellij. Reunindo várias sugestões, a abordagem mais simples para mim foi:

1. Verifique se você possui sbt.Revolver no arquivo project / plugsin.sbt, por exemplo

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

2. Defina javaoptions no arquivo build.sbt:

   javaOptions: = Seq ("- Xdebug", "-Xrunjdwp: transport = dt_socket, servidor = y, suspensão = y, endereço = 5005")

Em particular, use a opção suspend = y. Isso manterá o aplicativo até você conectar um depurador remoto da Intellij

3. Defina uma configuração do depurador no Intellij através do menu Executar / Editar Configurações. Pressione o botão +, selecione a opção "Remoto". Verifique se as entradas correspondem às javaoptions acima, em particular ao endereço da porta 5005. Atribua à configuração um nome como 'Spray'.

4. No console do SBT, use o comando reiniciar. Você deve ver o endereço da porta 5005 na saída de feedback.

5. No Intellij, defina seus pontos de interrupção.

6. No Intellij, selecione o Run \ Debug 'Spray'. Isso deve se conectar ao servidor da web de lata de spray. Você poderá ver muitos threads na janela de depuração.

7. Lembre-se de que algumas das diretivas Get do Spray parecem ser executadas na inicialização, mas não repetidamente ao ligar para o site.

Usando o Scala 2.10 e o SBT 0.12, consegui funcionar assim: http://tuliodomingos.blogspot.com.es/2014/01/scala-remote-debugging-in-sbts-jetty.html

Para o que vale a pena no Windows, edite %SBT_HOME%\bin\sbt.bate localize as seguintes linhas de código:

:run

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

substitua-os por este código:

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

O melhor que posso fazer para obter o mesmo comportamento -jvm-debugquando visto no iniciador de scripts Bash

NB. Eu não acho %SBT_HOME%que exista realmente fora deste script, a menos que você tenha criado explicitamente em seu ambiente, mas de qualquer maneira você entendeu: D

Arquivo-> Configurações-> Outras Configurações-> Parâmetros da VM do SBT -Xmx512M -XX: MaxPermSize = 256M -Xdebug -Xrunjdwp: transport = dt_socket, servidor = y, suspensão = n, endereço = 5005

Executar-> Editar configurações Pressione + e selecione remoto Pressione Aplicar

Agora, no console do SBT (iniciado dentro pelo intelliJ), quando você executa o comando 'run', você verá "Ouvindo o transporte dt_socket no endereço: 5005"

Agora pressione Executar-> Depurar. Você verá os menus de depuração abaixo ativados. Possui duas guias Depurador e Console.

Use F7 para da próxima linha para a próxima

Eu escolhi suspender para ser n. Sendo y quando eu executei o comando run, ele estava preso

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

tente isso

Eu também tenho o mesmo problema, gosto de compartilhar como resolvi. A propósito, eu estou usando o Ubuntu 14.04 e IntelliJ 15.

1. Em Configuração -> SBT -> Colado abaixo da linha na caixa de texto Parâmetros da VM:

   -XX: MaxPermSize = 384M -Xdebug -Xrunjdwp: transporte = dt_socket, servidor = y, suspensão = n, endereço = 5005

2. Abriu o Termilal no IntelliJ e execute:

   sbt -jvm-debug 5005

   Nota: você deve ver esta linha no terminal: "Escutando transporte dt_socket no endereço: 5005"

3. Editar configurações -> Clique em + -> Selecionar '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. Selecione DebugMyModule na Edit Configurationscaixa de listagem e clique em Debug .

   Nota: Você verá a tela Debug aberta e, no console de depuração, poderá ver "Conectado à VM de destino, endereço:, '127.0.0.1:5005'transporte: 'soquete'"

5. Coloque pontos de interrupção em alguns casos de teste em sua classe de teste.

6. Venha para o Terminal, onde você corre " sbt -jvm-debug 5005" e corre como abaixo

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

   Por exemplo: com.myproject.module.AddServiceTest [Spec]

7. Você pode ver a depuração iniciada no ponto de interrupção do seu caso de teste.

O plug-in AttachMe IntelliJ é uma maneira potencialmente mais rápida de anexar o depurador sem precisar mexer nos números das portas:

O AttachMe conectará o depurador IntelliJ automaticamente, mesmo se você iniciar o aplicativo pelo terminal (ou de qualquer outra maneira). Você não precisa acionar a Attach to processação manualmente.

O post e o leia - me do blog têm instruções de configuração, no entanto, tive que alterá-los um pouco para que funcionasse na minha máquina

1. Download do installer.shscript do repositório oficial

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

2. Conceda permissões executáveis chmod u+x installer.sh
3. Execute-o com ./installer.sh
4. Isso deve instalar o agente em /.config/attachme/agent.jare criar ~/.attachmearquivo

5. Modifique ~/.attachmepara conter

   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. Instale o plug-in Attachme correspondente e reinicie: IntelliJ | Preferences | Plugins

7. Crie a Attachmeconfiguração de execução:Run | Edit configurations... | Add new configuration | Attachme debugger registry | OK

Após essas travessuras pontuais, podemos anexar um depurador automaticamente

1. Iniciar Attachmeconfiguração de execução
2. source ~/.attachme
3. Inicie a aplicação do terminal, talvez, sbt "runMain example.Hello"
4. O depurador deve anexar e parar automaticamente em qualquer ponto de interrupção

Conforme a resposta de Roberto Tyley acima, mas no Windows também precisamos definir as seguintes variáveis ​​de ambiente após a instalação do sbt:

SBT_HOME
C: \ Arquivos de Programas (x86) \ sbt \
[ou onde quer que o sbt esteja instalado]

SBT_OPTS
-Xdebug -runjdwp: transporte = dt_socket, servidor = y, suspensão = n, endereço = 5005

[pelo exemplo IntelliJ da RT]

Adicionar ao caminho:% SBT_HOME% \ bin;% SBT_OPTS%

Em seguida, execute o seguinte na linha de comando na pasta do projeto "sbt run -jvm -debug 5005".

Se isso estiver funcionando corretamente, a linha de comando exibirá inicialmente uma linha re "Escutando transporte dt_socket no endereço: 5005".

Defina o ponto de interrupção no IntelliJ.

Abra o site no navegador para acionar o ponto de interrupção do depurador, por exemplo, " http: // localhost: 9000 / ".