cmake-server.7.rst 21.7 KB
Newer Older
1 2 3 4 5 6 7 8 9
.. cmake-manual-description: CMake Server

cmake-server(7)
***************

.. only:: html

   .. contents::

10 11 12 13 14
.. deprecated:: 3.15

  This will be removed from a future version of CMake.
  Clients should use the :manual:`cmake-file-api(7)` instead.

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
Introduction
============

:manual:`cmake(1)` is capable of providing semantic information about
CMake code it executes to generate a buildsystem.  If executed with
the ``-E server`` command line options, it starts in a long running mode
and allows a client to request the available information via a JSON protocol.

The protocol is designed to be useful to IDEs, refactoring tools, and
other tools which have a need to understand the buildsystem in entirety.

A single :manual:`cmake-buildsystem(7)` may describe buildsystem contents
and build properties which differ based on
:manual:`generation-time context <cmake-generator-expressions(7)>`
including:

* The Platform (eg, Windows, APPLE, Linux).
* The build configuration (eg, Debug, Release, Coverage).
* The Compiler (eg, MSVC, GCC, Clang) and compiler version.
* The language of the source files compiled.
* Available compile features (eg CXX variadic templates).
* CMake policies.

The protocol aims to provide information to tooling to satisfy several
needs:

#. Provide a complete and easily parsed source of all information relevant
   to the tooling as it relates to the source code.  There should be no need
   for tooling to parse generated buildsystems to access include directories
   or compile definitions for example.
#. Semantic information about the CMake buildsystem itself.
#. Provide a stable interface for reading the information in the CMake cache.
#. Information for determining when cmake needs to be re-run as a result of
   file changes.


Operation
=========

Start :manual:`cmake(1)` in the server command mode, supplying the path to
the build directory to process::

57
  cmake -E server (--debug|--pipe=<NAMED_PIPE>)
58

59
The server will communicate using stdin/stdout (with the ``--debug`` parameter)
60 61 62
or using a named pipe (with the ``--pipe=<NAMED_PIPE>`` parameter).  Note
that "named pipe" refers to a local domain socket on Unix and to a named pipe
on Windows.
63 64 65

When connecting to the server (via named pipe or by starting it in ``--debug``
mode), the server will reply with a hello message::
66

67
  [== "CMake Server" ==[
68
  {"supportedProtocolVersions":[{"major":1,"minor":0}],"type":"hello"}
69
  ]== "CMake Server" ==]
70 71 72

Messages sent to and from the process are wrapped in magic strings::

73
  [== "CMake Server" ==[
74 75 76
  {
    ... some JSON message ...
  }
77
  ]== "CMake Server" ==]
78

79 80
The server is now ready to accept further requests via the named pipe
or stdin.
81 82


83 84 85 86 87 88 89 90 91 92 93 94 95 96
Debugging
=========

CMake server mode can be asked to provide statistics on execution times, etc.
or to dump a copy of the response into a file. This is done passing a "debug"
JSON object as a child of the request.

The debug object supports the "showStats" key, which takes a boolean and makes
the server mode return a "zzzDebug" object with stats as part of its response.
"dumpToFile" takes a string value and will cause the cmake server to copy
the response into the given filename.

This is a response from the cmake server with "showStats" set to true::

97
  [== "CMake Server" ==[
98 99 100 101 102 103 104 105 106 107 108 109
  {
    "cookie":"",
    "errorMessage":"Waiting for type \"handshake\".",
    "inReplyTo":"unknown",
   "type":"error",
    "zzzDebug": {
      "dumpFile":"/tmp/error.txt",
      "jsonSerialization":0.011016,
      "size":111,
      "totalTime":0.025995
    }
  }
110
  ]== "CMake Server" ==]
111 112 113 114 115 116

The server has made a copy of this response into the file /tmp/error.txt and
took 0.011 seconds to turn the JSON response into a string, and it took 0.025
seconds to process the request in total. The reply has a size of 111 bytes.


117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
Protocol API
============


General Message Layout
----------------------

All messages need to have a "type" value, which identifies the type of
message that is passed back or forth. E.g. the initial message sent by the
server is of type "hello". Messages without a type will generate an response
of type "error".

All requests sent to the server may contain a "cookie" value. This value
will he handed back unchanged in all responses triggered by the request.

All responses will contain a value "inReplyTo", which may be empty in
case of parse errors, but will contain the type of the request message
in all other cases.


Type "reply"
^^^^^^^^^^^^

This type is used by the server to reply to requests.

The message may -- depending on the type of the original request --
contain values.

Example::

147
  [== "CMake Server" ==[
148
  {"cookie":"zimtstern","inReplyTo":"handshake","type":"reply"}
149
  ]== "CMake Server" ==]
150 151 152 153 154 155 156 157 158 159


Type "error"
^^^^^^^^^^^^

This type is used to return an error condition to the client. It will
contain an "errorMessage".

Example::

160
  [== "CMake Server" ==[
161
  {"cookie":"","errorMessage":"Protocol version not supported.","inReplyTo":"handshake","type":"error"}
162
  ]== "CMake Server" ==]
163 164 165 166 167 168 169 170 171


Type "progress"
^^^^^^^^^^^^^^^

When the server is busy for a long time, it is polite to send back replies of
type "progress" to the client. These will contain a "progressMessage" with a
string describing the action currently taking place as well as
"progressMinimum", "progressMaximum" and "progressCurrent" with integer values
Luz Paz's avatar
Luz Paz committed
172
describing the range of progress.
173 174 175 176 177 178 179 180

Messages of type "progress" will be followed by more "progress" messages or with
a message of type "reply" or "error" that complete the request.

"progress" messages may not be emitted after the "reply" or "error" message for
the request that triggered the responses was delivered.


181 182 183 184 185 186 187 188 189 190
Type "message"
^^^^^^^^^^^^^^

A message is triggered when the server processes a request and produces some
form of output that should be displayed to the user. A Message has a "message"
with the actual text to display as well as a "title" with a suggested dialog
box title.

Example::

191
  [== "CMake Server" ==[
192
  {"cookie":"","message":"Something happened.","title":"Title Text","inReplyTo":"handshake","type":"message"}
193
  ]== "CMake Server" ==]
194 195


196 197 198 199 200 201 202 203
Type "signal"
^^^^^^^^^^^^^

The server can send signals when it detects changes in the system state. Signals
are of type "signal", have an empty "cookie" and "inReplyTo" field and always
have a "name" set to show which signal was sent.


204 205 206 207 208 209 210 211 212 213 214 215 216 217
Specific Signals
----------------

The cmake server may sent signals with the following names:

"dirty" Signal
^^^^^^^^^^^^^^

The "dirty" signal is sent whenever the server determines that the configuration
of the project is no longer up-to-date. This happens when any of the files that have
an influence on the build system is changed.

The "dirty" signal may look like this::

218
  [== "CMake Server" ==[
219 220 221 222 223
  {
    "cookie":"",
    "inReplyTo":"",
    "name":"dirty",
    "type":"signal"}
224
  ]== "CMake Server" ==]
225 226 227 228 229 230 231 232 233 234 235


"fileChange" Signal
^^^^^^^^^^^^^^^^^^^

The "fileChange" signal is sent whenever a watched file is changed. It contains
the "path" that has changed and a list of "properties" with the kind of change
that was detected. Possible changes are "change" and "rename".

The "fileChange" signal looks like this::

236
  [== "CMake Server" ==[
237 238 239 240 241 242 243
  {
    "cookie":"",
    "inReplyTo":"",
    "name":"fileChange",
    "path":"/absolute/CMakeLists.txt",
    "properties":["change"],
    "type":"signal"}
244
  ]== "CMake Server" ==]
245 246


247 248 249 250 251 252 253 254 255 256 257 258 259
Specific Message Types
----------------------


Type "hello"
^^^^^^^^^^^^

The initial message send by the cmake server on startup is of type "hello".
This is the only message ever sent by the server that is not of type "reply",
"progress" or "error".

It will contain "supportedProtocolVersions" with an array of server protocol
versions supported by the cmake server. These are JSON objects with "major" and
260 261 262
"minor" keys containing non-negative integer values. Some versions may be marked
as experimental. These will contain the "isExperimental" key set to true. Enabling
these requires a special command line argument when starting the cmake server mode.
263

264 265 266 267 268
Within a "major" version all "minor" versions are fully backwards compatible.
New "minor" versions may introduce functionality in such a way that existing
clients of the same "major" version will continue to work, provided they
ignore keys in the output that they do not know about.

269 270
Example::

271
  [== "CMake Server" ==[
272
  {"supportedProtocolVersions":[{"major":0,"minor":1}],"type":"hello"}
273
  ]== "CMake Server" ==]
274 275 276 277 278 279 280 281 282


Type "handshake"
^^^^^^^^^^^^^^^^

The first request that the client may send to the server is of type "handshake".

This request needs to pass one of the "supportedProtocolVersions" of the "hello"
type response received earlier back to the server in the "protocolVersion" field.
283 284 285
Giving the "major" version of the requested protocol version will make the server
use the latest minor version of that protocol. Use this if you do not explicitly
need to depend on a specific minor version.
286 287 288 289 290 291

Protocol version 1.0 requires the following attributes to be set:

  * "sourceDirectory" with a path to the sources
  * "buildDirectory" with a path to the build directory
  * "generator" with the generator name
292 293 294
  * "extraGenerator" (optional!) with the extra generator to be used
  * "platform" with the generator platform (if supported by the generator)
  * "toolset" with the generator toolset (if supported by the generator)
295

296 297 298 299
Protocol version 1.2 makes all but the build directory optional, provided
there is a valid cache in the build directory that contains all the other
information already.

300 301
Example::

302
  [== "CMake Server" ==[
303 304 305
  {"cookie":"zimtstern","type":"handshake","protocolVersion":{"major":0},
   "sourceDirectory":"/home/code/cmake", "buildDirectory":"/tmp/testbuild",
   "generator":"Ninja"}
306
  ]== "CMake Server" ==]
307 308 309

which will result in a response type "reply"::

310
  [== "CMake Server" ==[
311
  {"cookie":"zimtstern","inReplyTo":"handshake","type":"reply"}
312
  ]== "CMake Server" ==]
313 314

indicating that the server is ready for action.
315 316 317 318 319 320 321 322 323 324


Type "globalSettings"
^^^^^^^^^^^^^^^^^^^^^

This request can be sent after the initial handshake. It will return a
JSON structure with information on cmake state.

Example::

325
  [== "CMake Server" ==[
326
  {"type":"globalSettings"}
327
  ]== "CMake Server" ==]
328 329 330

which will result in a response type "reply"::

331
  [== "CMake Server" ==[
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
  {
    "buildDirectory": "/tmp/test-build",
    "capabilities": {
      "generators": [
        {
          "extraGenerators": [],
          "name": "Watcom WMake",
          "platformSupport": false,
          "toolsetSupport": false
        },
        <...>
      ],
      "serverMode": false,
      "version": {
        "isDirty": false,
        "major": 3,
        "minor": 6,
        "patch": 20160830,
        "string": "3.6.20160830-gd6abad",
        "suffix": "gd6abad"
      }
    },
    "checkSystemVars": false,
    "cookie": "",
    "extraGenerator": "",
    "generator": "Ninja",
    "debugOutput": false,
    "inReplyTo": "globalSettings",
    "sourceDirectory": "/home/code/cmake",
    "trace": false,
    "traceExpand": false,
    "type": "reply",
    "warnUninitialized": false,
    "warnUnused": false,
    "warnUnusedCli": true
  }
368
  ]== "CMake Server" ==]
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385


Type "setGlobalSettings"
^^^^^^^^^^^^^^^^^^^^^^^^

This request can be sent to change the global settings attributes. Unknown
attributes are going to be ignored. Read-only attributes reported by
"globalSettings" are all capabilities, buildDirectory, generator,
extraGenerator and sourceDirectory. Any attempt to set these will be ignored,
too.

All other settings will be changed.

The server will respond with an empty reply message or an error.

Example::

386
  [== "CMake Server" ==[
387
  {"type":"setGlobalSettings","debugOutput":true}
388
  ]== "CMake Server" ==]
389 390 391

CMake will reply to this with::

392
  [== "CMake Server" ==[
393
  {"inReplyTo":"setGlobalSettings","type":"reply"}
394
  ]== "CMake Server" ==]
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412


Type "configure"
^^^^^^^^^^^^^^^^

This request will configure a project for build.

To configure a build directory already containing cmake files, it is enough to
set "buildDirectory" via "setGlobalSettings". To create a fresh build directory
you also need to set "currentGenerator" and "sourceDirectory" via "setGlobalSettings"
in addition to "buildDirectory".

You may a list of strings to "configure" via the "cacheArguments" key. These
strings will be interpreted similar to command line arguments related to
cache handling that are passed to the cmake command line client.

Example::

413
  [== "CMake Server" ==[
414
  {"type":"configure", "cacheArguments":["-Dsomething=else"]}
415
  ]== "CMake Server" ==]
416 417 418

CMake will reply like this (after reporting progress for some time)::

419
  [== "CMake Server" ==[
420
  {"cookie":"","inReplyTo":"configure","type":"reply"}
421
  ]== "CMake Server" ==]
422 423 424 425 426


Type "compute"
^^^^^^^^^^^^^^

427
This request will generate build system files in the build directory and
428 429 430 431
is only available after a project was successfully "configure"d.

Example::

432
  [== "CMake Server" ==[
433
  {"type":"compute"}
434
  ]== "CMake Server" ==]
435 436 437

CMake will reply (after reporting progress information)::

438
  [== "CMake Server" ==[
439
  {"cookie":"","inReplyTo":"compute","type":"reply"}
440
  ]== "CMake Server" ==]
441 442 443 444 445 446 447 448 449


Type "codemodel"
^^^^^^^^^^^^^^^^

The "codemodel" request can be used after a project was "compute"d successfully.

It will list the complete project structure as it is known to cmake.

450 451 452 453 454 455 456 457 458 459 460 461 462
The reply will contain a key "configurations", which will contain a list of
configuration objects. Configuration objects are used to destinquish between
different configurations the build directory might have enabled. While most
generators only support one configuration, others might support several.

Each configuration object can have the following keys:

"name"
  contains the name of the configuration. The name may be empty.
"projects"
  contains a list of project objects, one for each build project.

Project objects define one (sub-)project defined in the cmake build system.
463 464 465 466 467

Each project object can have the following keys:

"name"
  contains the (sub-)projects name.
468 469 470
"minimumCMakeVersion"
  contains the minimum cmake version allowed for this project, null if the
  project doesn't specify one.
471 472
"hasInstallRule"
  true if the project contains any install rules, false otherwise.
473 474 475 476 477
"sourceDirectory"
  contains the current source directory
"buildDirectory"
  contains the current build directory.
"targets"
478
  contains a list of build system target objects.
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495

Target objects define individual build targets for a certain configuration.

Each target object can have the following keys:

"name"
  contains the name of the target.
"type"
  defines the type of build of the target. Possible values are
  "STATIC_LIBRARY", "MODULE_LIBRARY", "SHARED_LIBRARY", "OBJECT_LIBRARY",
  "EXECUTABLE", "UTILITY" and "INTERFACE_LIBRARY".
"fullName"
  contains the full name of the build result (incl. extensions, etc.).
"sourceDirectory"
  contains the current source directory.
"buildDirectory"
  contains the current build directory.
496 497
"isGeneratorProvided"
  true if the target is auto-created by a generator, false otherwise
498 499 500 501
"hasInstallRule"
  true if the target contains any install rules, false otherwise.
"installPaths"
  full path to the destination directories defined by target install rules.
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
"artifacts"
  with a list of build artifacts. The list is sorted with the most
  important artifacts first (e.g. a .DLL file is listed before a
  .PDB file on windows).
"linkerLanguage"
  contains the language of the linker used to produce the artifact.
"linkLibraries"
  with a list of libraries to link to. This value is encoded in the
  system's native shell format.
"linkFlags"
  with a list of flags to pass to the linker. This value is encoded in
  the system's native shell format.
"linkLanguageFlags"
  with the flags for a compiler using the linkerLanguage. This value is
  encoded in the system's native shell format.
"frameworkPath"
  with the framework path (on Apple computers). This value is encoded
  in the system's native shell format.
"linkPath"
  with the link path. This value is encoded in the system's native shell
  format.
"sysroot"
  with the sysroot path.
"fileGroups"
  contains the source files making up the target.

FileGroups are used to group sources using similar settings together.

Each fileGroup object may contain the following keys:

"language"
  contains the programming language used by all files in the group.
"compileFlags"
  with a string containing all the flags passed to the compiler
  when building any of the files in this group. This value is encoded in
  the system's native shell format.
"includePath"
  with a list of include paths. Each include path is an object
  containing a "path" with the actual include path and "isSystem" with a bool
  value informing whether this is a normal include or a system include. This
  value is encoded in the system's native shell format.
"defines"
  with a list of defines in the form "SOMEVALUE" or "SOMEVALUE=42". This
  value is encoded in the system's native shell format.
"sources"
  with a list of source files.

All file paths in the fileGroup are either absolute or relative to the
sourceDirectory of the target.

Example::

554
  [== "CMake Server" ==[
555
  {"type":"codemodel"}
556
  ]== "CMake Server" ==]
557 558 559

CMake will reply::

560
  [== "CMake Server" ==[
561
  {
562
    "configurations": [
563
      {
564 565
        "name": "",
        "projects": [
566
          {
567 568 569 570
            "buildDirectory": "/tmp/build/Source/CursesDialog/form",
            "name": "CMAKE_FORM",
            "sourceDirectory": "/home/code/src/cmake/Source/CursesDialog/form",
            "targets": [
571
              {
572 573 574
                "artifacts": [ "/tmp/build/Source/CursesDialog/form/libcmForm.a" ],
                "buildDirectory": "/tmp/build/Source/CursesDialog/form",
                "fileGroups": [
575
                  {
576 577 578 579 580 581
                    "compileFlags": "  -std=gnu11",
                    "defines": [ "CURL_STATICLIB", "LIBARCHIVE_STATIC" ],
                    "includePath": [ { "path": "/tmp/build/Utilities" }, <...> ],
                    "isGenerated": false,
                    "language": "C",
                    "sources": [ "fld_arg.c", <...> ]
582 583
                  }
                ],
584 585 586 587
                "fullName": "libcmForm.a",
                "linkerLanguage": "C",
                "name": "cmForm",
                "sourceDirectory": "/home/code/src/cmake/Source/CursesDialog/form",
588
                "type": "STATIC_LIBRARY"
589 590
              }
            ]
591 592 593 594 595 596 597 598
          },
          <...>
        ]
      }
    ],
    "cookie": "",
    "inReplyTo": "codemodel",
    "type": "reply"
599
  }
600
  ]== "CMake Server" ==]
601

602

603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
Type "ctestInfo"
^^^^^^^^^^^^^^^^

The "ctestInfo" request can be used after a project was "compute"d successfully.

It will list the complete project test structure as it is known to cmake.

The reply will contain a key "configurations", which will contain a list of
configuration objects. Configuration objects are used to destinquish between
different configurations the build directory might have enabled. While most
generators only support one configuration, others might support several.

Each configuration object can have the following keys:

"name"
  contains the name of the configuration. The name may be empty.
"projects"
  contains a list of project objects, one for each build project.

Project objects define one (sub-)project defined in the cmake build system.

Each project object can have the following keys:

"name"
  contains the (sub-)projects name.
"ctestInfo"
629
  contains a list of test objects.
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647

Each test object can have the following keys:

"ctestName"
  contains the name of the test.
"ctestCommand"
  contains the test command.
"properties"
  contains a list of test property objects.

Each test property object can have the following keys:

"key"
  contains the test property key.
"value"
  contains the test property value.


648 649 650 651 652 653 654 655 656 657 658
Type "cmakeInputs"
^^^^^^^^^^^^^^^^^^

The "cmakeInputs" requests will report files used by CMake as part
of the build system itself.

This request is only available after a project was successfully
"configure"d.

Example::

659
  [== "CMake Server" ==[
660
  {"type":"cmakeInputs"}
661
  ]== "CMake Server" ==]
662 663 664

CMake will reply with the following information::

665
  [== "CMake Server" ==[
666 667 668 669 670 671 672 673 674 675 676 677
  {"buildFiles":
    [
      {"isCMake":true,"isTemporary":false,"sources":["/usr/lib/cmake/...", ... ]},
      {"isCMake":false,"isTemporary":false,"sources":["CMakeLists.txt", ...]},
      {"isCMake":false,"isTemporary":true,"sources":["/tmp/build/CMakeFiles/...", ...]}
    ],
    "cmakeRootDirectory":"/usr/lib/cmake",
    "sourceDirectory":"/home/code/src/cmake",
    "cookie":"",
    "inReplyTo":"cmakeInputs",
    "type":"reply"
  }
678
  ]== "CMake Server" ==]
679 680 681 682 683 684 685 686

All file names are either relative to the top level source directory or
absolute.

The list of files which "isCMake" set to true are part of the cmake installation.

The list of files witch "isTemporary" set to true are part of the build directory
and will not survive the build directory getting cleaned out.
687 688 689 690 691


Type "cache"
^^^^^^^^^^^^

692
The "cache" request will list the cached configuration values.
693 694 695

Example::

696
  [== "CMake Server" ==[
697
  {"type":"cache"}
698
  ]== "CMake Server" ==]
699 700 701

CMake will respond with the following output::

702
  [== "CMake Server" ==[
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
  {
    "cookie":"","inReplyTo":"cache","type":"reply",
    "cache":
    [
      {
        "key":"SOMEVALUE",
        "properties":
        {
          "ADVANCED":"1",
          "HELPSTRING":"This is not helpful"
        }
        "type":"STRING",
        "value":"TEST"}
    ]
  }
718
  ]== "CMake Server" ==]
719 720 721

The output can be limited to a list of keys by passing an array of key names
to the "keys" optional field of the "cache" request.
722 723 724 725 726 727 728 729 730 731


Type "fileSystemWatchers"
^^^^^^^^^^^^^^^^^^^^^^^^^

The server can watch the filesystem for changes. The "fileSystemWatchers"
command will report on the files and directories watched.

Example::

732
  [== "CMake Server" ==[
733
  {"type":"fileSystemWatchers"}
734
  ]== "CMake Server" ==]
735 736 737

CMake will respond with the following output::

738
  [== "CMake Server" ==[
739 740 741 742 743
  {
    "cookie":"","inReplyTo":"fileSystemWatchers","type":"reply",
    "watchedFiles": [ "/absolute/path" ],
    "watchedDirectories": [ "/absolute" ]
  }
744
  ]== "CMake Server" ==]