Cannot open shared library when debugging with CodeLLDB - visual-studio-code

I am working on a proof-of-concept app, written in Rust, with the end goal being to produce a shared library (.dll/.so) callable via C ABI from a number of other languages (C++, C#, etc). I have two simple components; poc is a Rust console app, which references poclib which exposes some simple functions. The app itself builds and runs fine so far, but I am stuck on how to debug it in VSCode using CodeLLDB.
I have a top level "workspace" like this:
[workspace]
members = [
"poc",
"poclib"
]
poc/cargo.toml looks like this:
[package]
name = "poc"
version = "0.1.0"
edition = "2018"
[dependencies.poclib]
path = "../poclib"
[dependencies]
And poclib/cargo.toml looks like this:
[package]
name = "poclib"
version = "0.1.0"
edition = "2018"
[lib]
crate_type = ["cdylib"]
[dependencies]
unicode-segmentation = "1.7.1"
My launch.json looks like this:
{
"version": "0.2.0",
"configurations": [
{
"type": "lldb",
"request": "launch",
"name": "Debug executable 'poc'",
"cargo": {
"args": [
"build",
"--bin=poc",
"--package=poc"
],
"filter": {
"name": "poc",
"kind": "bin"
}
},
"args": [ ],
"cwd": "${workspaceFolder}"
}
]
}
When I try to launch and debug in VSCode with the CodeLLDB extension installed, the app builds but then raises an error: /home/username/src/rustpoc/target/debug/poc: error while loading shared libraries: libpoclib.so: cannot open shared object file: No such file or directory. If I just do cargo run instead, it builds and runs fine, and I can verify that libpoclib.so is being built and placed in the ./target/debug folder.
If I comment out the crate_type option in the poclib/cargo.toml, it launches fine and I can hit breakpoints, but the shared library is no longer created.
I've tried adding an LD_LIBRARY_PATH setting to the launch.json, like this:
"env": {
"LD_LIBRARY_PATH": "${workspaceFolder}/target/debug"
},
That doesn't fix anything, but it does change the error message - with that setting I get /home/username/src/rustpoc/target/debug/poc: error while loading shared libraries: libstd-0a9489cf400f65e4.so: cannot open shared object file: No such file or directory
How can I enable debugging Rust in VSCode while still producing shared libraries?

I don't understand why it worked at all initially, but the solution was to fix the crate_type option so that I'm producing both C ABI libraries and native Rust libraries.
crate_type = ["cdylib","lib"]
With that setting the build output contains both a libpoclib.so for use from C, and a libpoclib.rlib which the poc binary can link statically against, and LLDB debugging works as expected.

Related

How do I change the working directory for debugging in VS Code + CMakeTools

I have a VS Code project based on a CMakeLists.txt file, and using the CMakeTools extension I can successfully build the target executable.
However, I need to run the executable in a different directory to the build directory. I cannot find a setting to either:
The built executable is placed in a different directory to the build directory and then run from there
The build executable is run from a different working directory
How can I achieve my goal?
You can change the output directory for the executable using the RUNTIME_OUTPUT_DIRECTORY property. When debugging, the executable is run in that directory. For example:
set_target_properties(my_target
PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
)
If you only want to change the current working directory (cwd), you can create your custom .vscode/launch.json. The content may depend on your OS and compiler:
{
"version": "0.2.0",
"configurations": [
{
"name": "Run CMake Target",
"type": "cppvsdbg", // use cppdbg on linux
"request": "launch",
"program": "${command:cmake.launchTargetPath}",
"cwd": "${workspaceFolder}/bin"
}
]
}

VSCode with PHP5

I'm struggling with setting up environment for old tech project with PHP5.
My OS is Windows and I have installed so far VSCode plugins: PHP Debug, PHP Intelephense, PHPUnit, PHPUnit Test Explorer.
I downloaded phpunit-5.7.27.phar and configured VSCode according to documentation.
Settings.json
{
"php.validate.executablePath": "C:/wamp64/bin/php/php5.6.40/php.exe",
"phpunit.phpunit": "C:/wamp64/bin/php/php5.6.40/phpunit-5.7.27.phar",
"phpunit.php": "C:/wamp64/bin/php/php5.6.40/php.exe",
"intelephense.environment.phpVersion": "5.6.40",
"intelephense.environment.includePaths": [
"C:/wamp64/bin/php/php5.6.40/phpunit-5.7.27.phar",
"C:/wamp64/bin/php/php5.6.40/php.exe",
"C:/wamp64/bin/php/php5.6.40/"
]
}
Launch.json
{
"version": "0.2.0",
"configurations": [
{
"name": "Listen for XDebug",
"type": "php",
"request": "launch",
"port": 9000,
"xdebugSettings": {
"max_children": 256,
"max_data": 500,
"max_depth": 3
}
},
]
}
What works for me fine is breakpointing on running app with xdebug and running unittests with Cmd+Shift+P.
What I need help with are as follows:
Code editor shows error for PHP unit classes and methods (even though unittests are executing fine as is). Do I need to add to path something besides phar file? Is VSCode non-compatible with phar files? The same happens for PHPUnit\Framework\TestCase.
I can't figure out how to configure Test Explorer plugin to show nicely tests tree. Does it require some configuration in Launch.json? Launching tests with Cmd+Shift+P displays results only in terminal.
PHP Intelephense requires installed PHPUnit with composer in workspace.
composer require --dev phpunit/phpunit
PHPUnit Test Explorer has by default Phpunit: Files setting set to {test,tests}/**/*Test.php, so changing it to proper glob should allow plugin to detect all tests.

Visual Studio Code launch.json file for JUnit?

Can someone point me toward a sample launch.json file for JUnit 4 so I can run tests from Visual Studio Code? I am unable to find an example of this online and all attempts to create one have failed.
I am able to run tests manually from the command line. (FWIW, I'm using CentOS.) Here's what I do to run them:
cd /opt/ABBYY/FREngine12/Samples/Java/Hello_VSC/src/test/java
java -cp .:/opt/junit/junit-4.12.jar:/opt/junit/hamcrest-core-1.3.jar org.junit.runner.JUnitCore Hello.AppTest
My Java project is set up to support Maven (I'm not really using Maven -- I've only set it up with Maven because Java debugging in Visual Studio Code will not work without it). So in the .classpath file I've added the following entries, which should add the .jar files from my command line call to the code path:
<classpathentry kind="lib" path="/opt/junit/junit-4.12.jar" />
<classpathentry kind="lib" path="/opt/junit/hamcrest-core-1.3.jar" />
When I try to set up the launch.json file, I'm attempting to do something like this:
{
"type": "java",
"name": "Test-<Hello_VSC>",
"request": "launch",
"cwd": "/opt/ABBYY/FREngine12/Samples/Java/Hello_VSC/src/test/java/",
"console": "internalConsole",
"stopOnEntry": false,
"mainClass": "Hello.AppTest",
"projectName": "Hello_VSC",
"args": "org.junit.runner.JUnitCore Hello.AppTest",
},
However, I get this error message:
Error: Main method not found in class Hello.AppTest, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application
Even if I change cwd to a completely bogus directory, I get the same error message. I don't know if my type parameter is wrong, my cwd parameter is wrong, or if it's something else.
Any suggestions?
Never mind -- I figured it out. I guess I had everything set up correctly with my project, but didn't realize that the proper way to run tests with the Java extensions for Visual Studio Code was to simply click on the Explorer (file) icon, then expand the "Test Explorer" option, explore down to whatever test(s) you want to run, right-click, and then choose your testing options. There is no need to use the launch.json file to do this.
If you search for tasks.json (instead of launch.json), you will get this example
/*
Example for quick Java compilation and unit tests in VS Code.
Works well with simple BlueJ projects.
Hit Ctrl+Shift+B to compile currently open file with javac.
Hit Ctrl+Shift+T to test currently open test class.
See red wiggles for compilation errors / failed assertions or click exclamation mark in the status bar.
Uses a few workarounds for individual commands per task and filename without extension.
This is written for Windows but it should be easy to adopt for Linux and Mac.
*/
{
"version": "0.1.0",
"isShellCommand": true,
"suppressTaskName": true,
"showOutput": "silent",
"windows": {
"command": "powershell",
"args": ["-Command"],
"tasks": [
{
// tests the currently open test class. java has to be in %PATH% and the jUnit-jar in %CLASSPATH%.
"taskName": "junit",
"args": ["$env:CLASSPATH += ';${fileDirname}'; $class = [System.IO.Path]::GetFileNameWithoutExtension('${fileBasename}'); java org.junit.runner.JUnitCore $class | Select-String -NotMatch -Pattern 'at (?!.+${fileBasename})'"],
"isTestCommand": true,
"problemMatcher": {
"owner": "java",
"fileLocation": ["relative", "${fileDirname}"],
"pattern": [
{
"regexp": "^(.*)$",
"message": 1
},
{
"regexp": "^\\s*at .+\\((.+):([0-9]+)\\)$",
"file": 1,
"line": 2
}
]
}
},
]
}
}
But it is in "0.1.0", so you will have to convert it to 2.0.0 first.

Show all warnings and errors in visual studio code

I'am using Visual Studio Code Version 1.6.0.
Is there any possibility to show errors and warnings of all files in the current root folder?
At the moment it shows only errors and warnings for open files.
UPDATE 2019
ES-Lint has introduced a new task in VS Code. You have to enable it in the workspace setings.
"eslint.lintTask.enable": true
Just go to terminal menu and select run task, then choose
eslint: lint whole folder
You can also auto-fix most problems by running the following command in the terminal:
.\node_modules\.bin\eslint.cmd --fix .
Reference: https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint
While we still await the problem scanner in VS Code, this is a good enough alternative if you use eslint.
OLD ANSWER
Here is how you can see all problems in less than 10 seconds.
You use a little trick.
Open replace all in files Ctrl + Shift + H.
Replace ; with ;
Hit replace all. That's it. Now, check Problems.
The assumption here is that all files have at least one semicolon. For
bigger projects, if you get a warning asking you to refine your
search, just enter something that is common in all files but is not
present a lot.
Very important: Make sure to check the Super cool! But i don't use eslint section! Wich provide a global solution! By setting up tasks! And explained in details!
Note: If you feel the document is blottered! Make sure to skim and get to the titles that catch you! Even though every section may matter! (TLDS (TOO LONG DO SKIM)).
Javascript and Eslint
To add upon #Ajay Raghav answer!
This section show how to run the task on question! And the output of the execution!
For javascript, Vscode Eslint extension provide such a feature! Which if you are using Eslint (and not jshint) then you are having it already installed!
Usage as described on #Ajay Raghav answer! Are explained on the Eslint extension page!
https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint
eslint.lintTask.enable: whether the extension contributes a lint task to lint a whole workspace folder.
eslint.lintTask.options: Command line options applied when running the task for linting the whole workspace (https://eslint.org/docs/user-guide/command-line-interface). An example to point to a custom .eslintrc.json file and a custom .eslintignore is:
{
"eslint.lintTask.options": "-c C:/mydirectory/.eslintrc.json --ignore-path C:/mydirectory/.eslintignore ."
}
Using the extension with VS Code's task running
From the doc:
The extension is linting an individual file only on typing. If you want to lint the whole workspace set eslint.lintTask.enable to true and the extension will also contribute the eslint: lint whole folder task. There is no need anymore to define a custom task in tasks.json.
If you are not familiar with task! Here how you use the above!
Go to Command pallet (CTRL + P + SHIFT)
> tasks run
Hit Tasks: run Task
You'll find eslint: lint whole folder
Hit and that's it
If eslint have no configuration setup! You'll get the following error!
If as such, Run eslint --init
And follow the interactive terminal!
Note if you don't have eslint command avaialble globally!
Intall it globally by running npm i -g eslint!
Result of the run
First the task run on the terminal!
You can see a detailed report! You can use the click link on terminal feature (CTRL + CLICK)! To directly open the file in question!
You can see too that the problems will automatically be listed in the problems tab! Which is cool!
Super cool! But i don't use eslint
Typescript and TSLINT
If you are a typescript user and you use TSLINT!
Then we need to go to the global way! And that's by creating a task!
Just like eslint did! (problemMatcher: $tsc) [you'll get to know what that is just a bit bellow].
(Make sure to check TSLINT is deprecated title)!
I use a complete other language (c#, java, c++, php, python ...)
Yup yup! We need a global way! And the global way is through creating a task!
Creating a task (The global way)
(Support all languages (to be configured for each))
We need to create a task!
The vscode documentation explains it pretty awesomely and in details!
https://code.visualstudio.com/docs/editor/tasks
Check the documentation!
Now in short! I would resume what a task is in:
A vscode tool and feature! That allow us to setup tasks based on tools and scripts and run them within vscode! Analyse there output within vscode! And activating and profiting from other vscode features! That includes Click link navigation on terminal! And problems listing on problem tab! Auto fixing and suggestions! Integration with the debugging tool! ...etc! It depends on the task type!
A task get set through a setting file (task.json)! For a workspace or the whole user! (Some tasks types need to be set for only a workspace! They depends on the variables of a workspace)!
Also the task feature contains a lot of options and features! And is a big piece! For more just check the documentation!
Back to our problem!
We want linting of a whole project! And errors detection!
We need to have the errors listed on the problems tab! And preferably too with fixes suggestions!
All this gonna be done through a task.
Setting up the task! And core elements
Through vscode task features and integration! We need to configure it to allow good output! And integration with the problems tab!
The config will go as such:
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
{
"type": "npm",
"script": "lint",
"problemMatcher": ["$eslint-stylish"]
}
]
}
(Here eslint through npm run lint)
The most important thing here to see! Is the type which determine the category and the task handling and launch setup! The script which define what get executed! And lastly and importantly problemMatcher!
For the whole tasks setting up! And options you can check the doc!
Here another example for typescript:
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
{
"type": "typescript",
"tsconfig": "tsconfig.json",
"problemMatcher": ["$tsc"],
"group": {
"kind": "build",
"isDefault": true
}
}
]
}
TSLINT is deprecated
Yo ! You just shown how, a line above! Yea there is something important!
We can see typescript problems through tsc compile process! Or Through TSLINT! TSLINT will support code style rules and so on! BUT mmmm TSLINT is deprecated! And ESLINT is taking on! And in simple words use Eslint! And so we can use Eslint for Typescript! And that can be more rich!
Check the link bellow from the official link:
https://code.visualstudio.com/api/advanced-topics/tslint-eslint-migration
And humor face: Don't be affraid to do this
Already did!
Should i migrate Tslint to eslint
Another reason would be: TSLint is a linter that can only be used for TypeScript, while ESLint supports both JavaScript and TypeScript.
Reason for the choice and deprecation is:
In the TypeScript 2019 Roadmap, the TypeScript core team explains that ESLint has a more performant architecture than TSLint and that they will only be focusing on ESLint when providing editor linting integration for TypeScript.
Check it here and how to setup .eslintrc.js without the migration tool!
or https://www.npmjs.com/package/#typescript-eslint/eslint-plugin
Which in short would be like:
module.exports = {
"parser": "#typescript-eslint/parser", // set eslint parser
"parserOptions": {
"ecmaVersion": 12, // latest ecma script features
"sourceType": "module" // Allows for the use of imports
},
"plugins": [
"#typescript-eslint"
],
extends: [
"plugin:#typescript-eslint/recommended" // Uses the recommended rules from the #typescript-eslint/eslint-plugin
],
rules: {
// Place to specify ESLint rules. Can be used to overwrite rules specified from the extended configs
// e.g. "#typescript-eslint/explicit-function-return-type": "off",
}
};
And sure : npm install --save-dev eslint #typescript-eslint/parser #typescript-eslint/eslint-plugin
Make sure to use eslint --ext .js,.ts when executing eslint! Since by default eslint will only search for .js files.
Make sure to use the code styles versions that support typescript like this one for airbnb:
https://www.npmjs.com/package/eslint-config-airbnb-typescript
(The next section is the most important)!
Processing task output with problem matchers
https://code.visualstudio.com/docs/editor/tasks#_processing-task-output-with-problem-matchers
VS Code can process the output from a task with a problem matcher. Problem matchers scan the task output text for known warning or error strings, and report these inline in the editor and in the Problems panel. VS Code ships with several problem matchers 'in-the-box':
TypeScript: $tsc assumes that file names in the output are relative to the opened folder.
TypeScript Watch: $tsc-watch matches problems reported from the tsc compiler when executed in watch mode.
JSHint: $jshint assumes that file names are reported as an absolute path.
JSHint Stylish: $jshint-stylish assumes that file names are reported as an absolute path.
ESLint Compact: $eslint-compact assumes that file names in the output are relative to the opened folder.
ESLint Stylish: $eslint-stylish assumes that file names in the output are relative to the opened folder.
Go: $go matches problems reported from the go compiler. Assumes that file names are relative to the opened folder.
CSharp and VB Compiler: $mscompile assumes that file names are reported as an absolute path.
Lessc compiler: $lessc assumes that file names are reported as absolute path.
Node Sass compiler: $node-sass assumes that file names are reported as an absolute path.
OK but you said JAVA, C/C++, PHP, Python ...
=> We need to write our own problemMatcher
C/C++ (GCC)
The c/c++ support in vscode is added through the official ms extension ms-vscode.cpptools
https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools
The extension provide $gcc problemMatcher!
A task will go as:
{
"version": "2.0.0",
"tasks": [
{
"type": "shell",
"label": "g++ build all",
"command": "/usr/bin/g++",
"args": ["${workspaceFolder}/src/*.cpp", "-o", "${workspaceFolder}/build"],
"options": {
"cwd": "/usr/bin"
},
"problemMatcher": ["$gcc"],
"group": {
"kind": "build",
"isDefault": true
}
}
]
}
Note that i just made the compilation to go for files in src (one level)
One can use cmake to build!
May like to check :
https://code.visualstudio.com/docs/cpp/config-linux#_build-helloworldcpp
Defining a problem matcher
You can check the doc section bellow:
https://code.visualstudio.com/docs/editor/tasks#_defining-a-problem-matcher
An example for gcc was given for c/c++!
A compilation outcome will be like:
helloWorld.c:5:3: warning: implicit declaration of function ‘prinft’
We set a matcher by the following
{
// The problem is owned by the cpp language service.
"owner": "cpp",
// The file name for reported problems is relative to the opened folder.
"fileLocation": ["relative", "${workspaceFolder}"],
// The actual pattern to match problems in the output.
"pattern": {
// The regular expression. Example to match: helloWorld.c:5:3: warning: implicit declaration of function ‘printf’ [-Wimplicit-function-declaration]
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
// The first match group matches the file name which is relative.
"file": 1,
// The second match group matches the line on which the problem occurred.
"line": 2,
// The third match group matches the column at which the problem occurred.
"column": 3,
// The fourth match group matches the problem's severity. Can be ignored. Then all problems are captured as errors.
"severity": 4,
// The fifth match group matches the message.
"message": 5
}
}
Directly in the task config that can go as:
{
"version": "2.0.0",
"tasks": [
{
"label": "build",
"command": "g++",
"args": ["${workspaceFolder}/src/*.cpp", "-o", "${workspaceFolder}/build"],
"problemMatcher": {
"owner": "cpp",
"fileLocation": ["relative", "${workspaceFolder}"],
"pattern": {
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
"file": 1,
"line": 2,
"column": 3,
"severity": 4,
"message": 5
}
}
}
]
}
You can see how staight forward the setting is!
You can check the doc link above for more details!
Defining multiple line problem matcher
https://code.visualstudio.com/docs/editor/tasks#_defining-a-multiline-problem-matcher
Some tools spread problems found in a source file over several lines, especially if stylish reporters are used. An example is ESLint; in stylish mode it produces output like this:
test.js
1:0 error Missing "use strict" statement strict
✖ 1 problems (1 errors, 0 warnings)
I'll not go about the details check the doc! it explains it well (check the loop property too!
{
"owner": "javascript",
"fileLocation": ["relative", "${workspaceFolder}"],
"pattern": [
{
"regexp": "^([^\\s].*)$",
"file": 1
},
{
"regexp": "^\\s+(\\d+):(\\d+)\\s+(error|warning|info)\\s+(.*)\\s\\s+(.*)$",
"line": 1,
"column": 2,
"severity": 3,
"message": 4,
"code": 5,
"loop": true
}
]
}
Modifying an existing problem matcher
https://code.visualstudio.com/docs/editor/tasks#_modifying-an-existing-problem-matcher
Simply check the doc!
JAVA
oK now we know, how to make problems matchers! We didn't do java yet! So let's do that for it! (Wait i just googled and here someone that did it)
{
// compiles all files in the folder of the currently opened file
"taskName": "javac all",
"args": ["$env:CLASSPATH += ';${fileDirname}'; javac ${fileDirname}\\*.java -Xlint"],
"showOutput": "silent",
"problemMatcher": {
"owner": "java",
"fileLocation": "absolute",
"pattern": {
"regexp": "^(.*):([0-9]+): (error|warning): (.*)$",
"file": 1,
"line": 2,
"severity": 3,
"message": 4
}
}
}
PHP
Here a php task too that use code sniff!
src (googling again): https://github.com/bmewburn/vscode-intelephense/issues/1102
{
"version": "2.0.0",
"tasks": [
{
"label": "PHP: CodeSniff Workspace",
"type": "shell",
"command": "${config:phpcs.executablePath}",
"args": [
"--standard=${config:phpcs.standard}",
"--extensions=module,inc,install,php,theme,test,js,css",
"--report=csv",
"--basepath=${workspaceFolder}",
"web/modules/custom"
],
"options": {
"cwd": "${workspaceFolder}"
},
"problemMatcher": {
"owner": "php",
"fileLocation": [
"relative",
"${workspaceFolder}"
],
"pattern": {
"regexp": "^\"(.*?)\",(\\d+),(\\d+),(error|warning),\"(.*)\",.*$",
"file": 1,
"line": 2,
"column": 3,
"severity": 4,
"message": 5
}
}
}
]
}
Problem matcher and auto fixing
Ok so how the problem matcher make the auto fixing suggestions? The answer is it doesn't! It can be clear! Or you may said at the first time you get to see the problem matcher, hey it may have a relation!
It isn't! The languages support or linters extensions are what provide such a feature! And that through using vscode Action api!
Check
https://code.visualstudio.com/api/references/vscode-api#CodeAction
https://code.visualstudio.com/api/references/vscode-api#CodeActionKind
https://code.visualstudio.com/api/references/vscode-api#CodeActionProvider%3CT%3E
So simply: The problemMatcher set how the output of a task run is parsed and outputed on the problems tab!
And the languages support extension implement the auto fixes! Or linters! (Extensions) [I can make a play ground extension if i want]!
To note too that the yellow bulbe in the problems tab! Works and allow auto fixing! Because the problem matcher provide the line for the problem! That get mapped with the output of the extension fixing suggestions range! That get precised on the CodeActionProvider!
Is not possible right now, the VSCode team have a request for that feature that they are working in, so we must wait.
An alternative is to use a task runner to lint all errors in the project like the one created in this guide.
Visual code has an Extention for ESLINT to integrate the lint errors into the IDE. Whenever you save file, it will show its lint errors. See it: https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint
For any like me who have encountered this question dozens of times with variations on the google search "c# vs code show all errors in all files", my issue was that I had too many files associated with my project – the C# extension by default starts error checking only open files when you exceed 1000 files total.
Go to Settings => Workspace => Max Project File Count For Diagnostic Analysis, and increase the value to wherever you think is reasonable.
Equivalently, add the following line to your existing settings.json, which increases the file count cutoff to 10,000.
{
// Rest of settings.json file here
"csharp.maxProjectFileCountForDiagnosticAnalysis": 10000,
}
Just run:
npx eslint --init
And configure it as needed

VSCode launch.json for vagrant plugin

I try to set up a launch.json for a vagrant-plugin on windows. My current version look like this:
{
"version": "0.2.0",
"configurations": [
{
"name": "Launch Vagrant",
"type": "Ruby",
"request": "launch",
"cwd": "${workspaceRoot}",
"program": "${workspaceRoot}/bin/vagrant",
"args": ["up"],
"env": {
"VAGRANT_CWD": "${workspaceRoot}/development"
}
}
]
}
When starting the plugin now, vagrant misses the external dependencies. So I get the error:
The executable 'curl' Vagrant is trying to run was not
found in the %PATH% variable. This is an error. Please verify
this software is installed and on the path.
Adding the needed dependencies to my path sound like trouble (cp.exe, dir.exe, ...).
I tried:
"env": {
"PATH": "/HashiCorp/Vagrant/embedded/bin;${PATH}",
"VAGRANT_CWD": "${workspaceRoot}/development"
}
But then i get Debugger terminal error: Process failed: spawn rdebug-ide.bat ENOENT.
Is there a way the expend the PATH environment Variable in the launch.json?
For the question of:
Is there a way the expend the PATH environment Variable in the
launch.json?
From the documentation:
You can also reference environment variables through ${env.Name} (e.g.
${env.PATH}). Be sure to match the environment variable name's casing,
for example env.Path on Windows.
At: http://code.visualstudio.com/docs/editor/tasks#_variable-substitution
For example I often use this for Ruby apps in my launch.json in Visual Studio Code:
...
"pathToBundler": "${env.HOME}/.rvm/gems/ruby-2.3.0/wrappers/bundle",
...
#sschoof If you are trying to run VS Code from the windows host machine I'd suggest reading this post.
I've current just started configuring a development workspace for use with nodejs, VS Code, and Azure using my Mac OSX host. My solution is working but I have not a done a windows implementation so I currently cannot offer more experienced advice.