Source/cmFileAPI.cxx

   1 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2    file Copyright.txt or https://cmake.org/licensing for details.  */
   3 #include "cmFileAPI.h"
   4
   5 #include <algorithm>
   6 #include <cassert>
   7 #include <chrono>
   8 #include <ctime>
   9 #include <iomanip>
  10 #include <sstream>
  11 #include <utility>
  12
  13 #include "cmsys/Directory.hxx"
  14 #include "cmsys/FStream.hxx"
  15
  16 #include "cmCryptoHash.h"
  17 #include "cmFileAPICMakeFiles.h"
  18 #include "cmFileAPICache.h"
  19 #include "cmFileAPICodemodel.h"
  20 #include "cmFileAPIConfigureLog.h"
  21 #include "cmFileAPIToolchains.h"
  22 #include "cmGlobalGenerator.h"
  23 #include "cmStringAlgorithms.h"
  24 #include "cmSystemTools.h"
  25 #include "cmTimestamp.h"
  26 #include "cmake.h"
  27
  28 cmFileAPI::cmFileAPI(cmake* cm)
  29   : CMakeInstance(cm)
  30 {
  31   this->APIv1 =
  32     this->CMakeInstance->GetHomeOutputDirectory() + "/.cmake/api/v1";
  33
  34   Json::CharReaderBuilder rbuilder;
  35   rbuilder["collectComments"] = false;
  36   rbuilder["failIfExtra"] = true;
  37   rbuilder["rejectDupKeys"] = false;
  38   rbuilder["strictRoot"] = true;
  39   this->JsonReader =
  40     std::unique_ptr<Json::CharReader>(rbuilder.newCharReader());
  41
  42   Json::StreamWriterBuilder wbuilder;
  43   wbuilder["indentation"] = "\t";
  44   this->JsonWriter =
  45     std::unique_ptr<Json::StreamWriter>(wbuilder.newStreamWriter());
  46 }
  47
  48 void cmFileAPI::ReadQueries()
  49 {
  50   std::string const query_dir = this->APIv1 + "/query";
  51   this->QueryExists = cmSystemTools::FileIsDirectory(query_dir);
  52   if (!this->QueryExists) {
  53     return;
  54   }
  55
  56   // Load queries at the top level.
  57   std::vector<std::string> queries = cmFileAPI::LoadDir(query_dir);
  58
  59   // Read the queries and save for later.
  60   for (std::string& query : queries) {
  61     if (cmHasLiteralPrefix(query, "client-")) {
  62       this->ReadClient(query);
  63     } else if (!cmFileAPI::ReadQuery(query, this->TopQuery.Known)) {
  64       this->TopQuery.Unknown.push_back(std::move(query));
  65     }
  66   }
  67 }
  68
  69 std::vector<unsigned long> cmFileAPI::GetConfigureLogVersions()
  70 {
  71   std::vector<unsigned long> versions;
  72   auto getConfigureLogVersions = [&versions](Query const& q) {
  73     for (Object const& o : q.Known) {
  74       if (o.Kind == ObjectKind::ConfigureLog) {
  75         versions.emplace_back(o.Version);
  76       }
  77     }
  78   };
  79   getConfigureLogVersions(this->TopQuery);
  80   for (auto const& client : this->ClientQueries) {
  81     getConfigureLogVersions(client.second.DirQuery);
  82   }
  83   std::sort(versions.begin(), versions.end());
  84   versions.erase(std::unique(versions.begin(), versions.end()),
  85                  versions.end());
  86   return versions;
  87 }
  88
  89 void cmFileAPI::WriteReplies()
  90 {
  91   if (this->QueryExists) {
  92     cmSystemTools::MakeDirectory(this->APIv1 + "/reply");
  93     this->WriteJsonFile(this->BuildReplyIndex(), "index", ComputeSuffixTime);
  94   }
  95
  96   this->RemoveOldReplyFiles();
  97 }
  98
  99 std::vector<std::string> cmFileAPI::LoadDir(std::string const& dir)
 100 {
 101   std::vector<std::string> files;
 102   cmsys::Directory d;
 103   d.Load(dir);
 104   for (unsigned long i = 0; i < d.GetNumberOfFiles(); ++i) {
 105     std::string f = d.GetFile(i);
 106     if (f != "." && f != "..") {
 107       files.push_back(std::move(f));
 108     }
 109   }
 110   std::sort(files.begin(), files.end());
 111   return files;
 112 }
 113
 114 void cmFileAPI::RemoveOldReplyFiles()
 115 {
 116   std::string const reply_dir = this->APIv1 + "/reply";
 117   std::vector<std::string> files = this->LoadDir(reply_dir);
 118   for (std::string const& f : files) {
 119     if (this->ReplyFiles.find(f) == this->ReplyFiles.end()) {
 120       std::string file = cmStrCat(reply_dir, "/", f);
 121       cmSystemTools::RemoveFile(file);
 122     }
 123   }
 124 }
 125
 126 bool cmFileAPI::ReadJsonFile(std::string const& file, Json::Value& value,
 127                              std::string& error)
 128 {
 129   std::vector<char> content;
 130
 131   cmsys::ifstream fin;
 132   if (!cmSystemTools::FileIsDirectory(file)) {
 133     fin.open(file.c_str(), std::ios::binary);
 134   }
 135   auto finEnd = fin.rdbuf()->pubseekoff(0, std::ios::end);
 136   if (finEnd > 0) {
 137     size_t finSize = finEnd;
 138     try {
 139       // Allocate a buffer to read the whole file.
 140       content.resize(finSize);
 141
 142       // Now read the file from the beginning.
 143       fin.seekg(0, std::ios::beg);
 144       fin.read(content.data(), finSize);
 145     } catch (...) {
 146       fin.setstate(std::ios::failbit);
 147     }
 148   }
 149   fin.close();
 150   if (!fin) {
 151     value = Json::Value();
 152     error = "failed to read from file";
 153     return false;
 154   }
 155
 156   // Parse our buffer as json.
 157   if (!this->JsonReader->parse(content.data(), content.data() + content.size(),
 158                                &value, &error)) {
 159     value = Json::Value();
 160     return false;
 161   }
 162
 163   return true;
 164 }
 165
 166 std::string cmFileAPI::WriteJsonFile(
 167   Json::Value const& value, std::string const& prefix,
 168   std::string (*computeSuffix)(std::string const&))
 169 {
 170   std::string fileName;
 171
 172   // Write the json file with a temporary name.
 173   std::string const& tmpFile = this->APIv1 + "/tmp.json";
 174   cmsys::ofstream ftmp(tmpFile.c_str());
 175   this->JsonWriter->write(value, &ftmp);
 176   ftmp << "\n";
 177   ftmp.close();
 178   if (!ftmp) {
 179     cmSystemTools::RemoveFile(tmpFile);
 180     return fileName;
 181   }
 182
 183   // Compute the final name for the file.
 184   fileName = prefix + "-" + computeSuffix(tmpFile) + ".json";
 185
 186   // Create the destination.
 187   std::string file = this->APIv1 + "/reply";
 188   cmSystemTools::MakeDirectory(file);
 189   file += "/";
 190   file += fileName;
 191
 192   // If the final name already exists then assume it has proper content.
 193   // Otherwise, atomically place the reply file at its final name
 194   if (cmSystemTools::FileExists(file, true) ||
 195       !cmSystemTools::RenameFile(tmpFile, file)) {
 196     cmSystemTools::RemoveFile(tmpFile);
 197   }
 198
 199   // Record this among files we have just written.
 200   this->ReplyFiles.insert(fileName);
 201
 202   return fileName;
 203 }
 204
 205 Json::Value cmFileAPI::MaybeJsonFile(Json::Value in, std::string const& prefix)
 206 {
 207   Json::Value out;
 208   if (in.isObject() || in.isArray()) {
 209     out = Json::objectValue;
 210     out["jsonFile"] = this->WriteJsonFile(in, prefix);
 211   } else {
 212     out = std::move(in);
 213   }
 214   return out;
 215 }
 216
 217 std::string cmFileAPI::ComputeSuffixHash(std::string const& file)
 218 {
 219   cmCryptoHash hasher(cmCryptoHash::AlgoSHA3_256);
 220   std::string hash = hasher.HashFile(file);
 221   hash.resize(20, '0');
 222   return hash;
 223 }
 224
 225 std::string cmFileAPI::ComputeSuffixTime(std::string const&)
 226 {
 227   std::chrono::milliseconds ms =
 228     std::chrono::duration_cast<std::chrono::milliseconds>(
 229       std::chrono::system_clock::now().time_since_epoch());
 230   std::chrono::seconds s =
 231     std::chrono::duration_cast<std::chrono::seconds>(ms);
 232
 233   std::time_t ts = s.count();
 234   std::size_t tms = ms.count() % 1000;
 235
 236   cmTimestamp cmts;
 237   std::ostringstream ss;
 238   ss << cmts.CreateTimestampFromTimeT(ts, "%Y-%m-%dT%H-%M-%S", true) << '-'
 239      << std::setfill('0') << std::setw(4) << tms;
 240   return ss.str();
 241 }
 242
 243 bool cmFileAPI::ReadQuery(std::string const& query,
 244                           std::vector<Object>& objects)
 245 {
 246   // Parse the "<kind>-" syntax.
 247   std::string::size_type sep_pos = query.find('-');
 248   if (sep_pos == std::string::npos) {
 249     return false;
 250   }
 251   std::string kindName = query.substr(0, sep_pos);
 252   std::string verStr = query.substr(sep_pos + 1);
 253   if (kindName == ObjectKindName(ObjectKind::CodeModel)) {
 254     Object o;
 255     o.Kind = ObjectKind::CodeModel;
 256     if (verStr == "v2") {
 257       o.Version = 2;
 258     } else {
 259       return false;
 260     }
 261     objects.push_back(o);
 262     return true;
 263   }
 264   if (kindName == ObjectKindName(ObjectKind::ConfigureLog)) {
 265     Object o;
 266     o.Kind = ObjectKind::ConfigureLog;
 267     if (verStr == "v1") {
 268       o.Version = 1;
 269     } else {
 270       return false;
 271     }
 272     objects.push_back(o);
 273     return true;
 274   }
 275   if (kindName == ObjectKindName(ObjectKind::Cache)) {
 276     Object o;
 277     o.Kind = ObjectKind::Cache;
 278     if (verStr == "v2") {
 279       o.Version = 2;
 280     } else {
 281       return false;
 282     }
 283     objects.push_back(o);
 284     return true;
 285   }
 286   if (kindName == ObjectKindName(ObjectKind::CMakeFiles)) {
 287     Object o;
 288     o.Kind = ObjectKind::CMakeFiles;
 289     if (verStr == "v1") {
 290       o.Version = 1;
 291     } else {
 292       return false;
 293     }
 294     objects.push_back(o);
 295     return true;
 296   }
 297   if (kindName == ObjectKindName(ObjectKind::Toolchains)) {
 298     Object o;
 299     o.Kind = ObjectKind::Toolchains;
 300     if (verStr == "v1") {
 301       o.Version = 1;
 302     } else {
 303       return false;
 304     }
 305     objects.push_back(o);
 306     return true;
 307   }
 308   if (kindName == ObjectKindName(ObjectKind::InternalTest)) {
 309     Object o;
 310     o.Kind = ObjectKind::InternalTest;
 311     if (verStr == "v1") {
 312       o.Version = 1;
 313     } else if (verStr == "v2") {
 314       o.Version = 2;
 315     } else {
 316       return false;
 317     }
 318     objects.push_back(o);
 319     return true;
 320   }
 321   return false;
 322 }
 323
 324 void cmFileAPI::ReadClient(std::string const& client)
 325 {
 326   // Load queries for the client.
 327   std::string clientDir = this->APIv1 + "/query/" + client;
 328   std::vector<std::string> queries = this->LoadDir(clientDir);
 329
 330   // Read the queries and save for later.
 331   ClientQuery& clientQuery = this->ClientQueries[client];
 332   for (std::string& query : queries) {
 333     if (query == "query.json") {
 334       clientQuery.HaveQueryJson = true;
 335       this->ReadClientQuery(client, clientQuery.QueryJson);
 336     } else if (!this->ReadQuery(query, clientQuery.DirQuery.Known)) {
 337       clientQuery.DirQuery.Unknown.push_back(std::move(query));
 338     }
 339   }
 340 }
 341
 342 void cmFileAPI::ReadClientQuery(std::string const& client, ClientQueryJson& q)
 343 {
 344   // Read the query.json file.
 345   std::string queryFile = this->APIv1 + "/query/" + client + "/query.json";
 346   Json::Value query;
 347   if (!this->ReadJsonFile(queryFile, query, q.Error)) {
 348     return;
 349   }
 350   if (!query.isObject()) {
 351     q.Error = "query root is not an object";
 352     return;
 353   }
 354
 355   Json::Value const& clientValue = query["client"];
 356   if (!clientValue.isNull()) {
 357     q.ClientValue = clientValue;
 358   }
 359   q.RequestsValue = std::move(query["requests"]);
 360   q.Requests = this->BuildClientRequests(q.RequestsValue);
 361 }
 362
 363 Json::Value cmFileAPI::BuildReplyIndex()
 364 {
 365   Json::Value index(Json::objectValue);
 366
 367   // Report information about this version of CMake.
 368   index["cmake"] = this->BuildCMake();
 369
 370   // Reply to all queries that we loaded.
 371   Json::Value& reply = index["reply"] = this->BuildReply(this->TopQuery);
 372   for (auto const& client : this->ClientQueries) {
 373     std::string const& clientName = client.first;
 374     ClientQuery const& clientQuery = client.second;
 375     reply[clientName] = this->BuildClientReply(clientQuery);
 376   }
 377
 378   // Move our index of generated objects into its field.
 379   Json::Value& objects = index["objects"] = Json::arrayValue;
 380   for (auto& entry : this->ReplyIndexObjects) {
 381     objects.append(std::move(entry.second)); // NOLINT(*)
 382   }
 383
 384   return index;
 385 }
 386
 387 Json::Value cmFileAPI::BuildCMake()
 388 {
 389   Json::Value cmake = Json::objectValue;
 390   cmake["version"] = this->CMakeInstance->ReportVersionJson();
 391   Json::Value& cmake_paths = cmake["paths"] = Json::objectValue;
 392   cmake_paths["cmake"] = cmSystemTools::GetCMakeCommand();
 393   cmake_paths["ctest"] = cmSystemTools::GetCTestCommand();
 394   cmake_paths["cpack"] = cmSystemTools::GetCPackCommand();
 395   cmake_paths["root"] = cmSystemTools::GetCMakeRoot();
 396   cmake["generator"] = this->CMakeInstance->GetGlobalGenerator()->GetJson();
 397   return cmake;
 398 }
 399
 400 Json::Value cmFileAPI::BuildReply(Query const& q)
 401 {
 402   Json::Value reply = Json::objectValue;
 403   for (Object const& o : q.Known) {
 404     std::string const& name = ObjectName(o);
 405     reply[name] = this->AddReplyIndexObject(o);
 406   }
 407
 408   for (std::string const& name : q.Unknown) {
 409     reply[name] = cmFileAPI::BuildReplyError("unknown query file");
 410   }
 411   return reply;
 412 }
 413
 414 Json::Value cmFileAPI::BuildReplyError(std::string const& error)
 415 {
 416   Json::Value e = Json::objectValue;
 417   e["error"] = error;
 418   return e;
 419 }
 420
 421 Json::Value const& cmFileAPI::AddReplyIndexObject(Object const& o)
 422 {
 423   Json::Value& indexEntry = this->ReplyIndexObjects[o];
 424   if (!indexEntry.isNull()) {
 425     // The reply object has already been generated.
 426     return indexEntry;
 427   }
 428
 429   // Generate this reply object.
 430   Json::Value const& object = this->BuildObject(o);
 431   assert(object.isObject());
 432
 433   // Populate this index entry.
 434   indexEntry = Json::objectValue;
 435   indexEntry["kind"] = object["kind"];
 436   indexEntry["version"] = object["version"];
 437   indexEntry["jsonFile"] = this->WriteJsonFile(object, ObjectName(o));
 438   return indexEntry;
 439 }
 440
 441 const char* cmFileAPI::ObjectKindName(ObjectKind kind)
 442 {
 443   // Keep in sync with ObjectKind enum.
 444   static const char* objectKindNames[] = {
 445     "codemodel",    //
 446     "configureLog", //
 447     "cache",        //
 448     "cmakeFiles",   //
 449     "toolchains",   //
 450     "__test"        //
 451   };
 452   return objectKindNames[static_cast<size_t>(kind)];
 453 }
 454
 455 std::string cmFileAPI::ObjectName(Object const& o)
 456 {
 457   std::string name = cmStrCat(ObjectKindName(o.Kind), "-v", o.Version);
 458   return name;
 459 }
 460
 461 Json::Value cmFileAPI::BuildVersion(unsigned int major, unsigned int minor)
 462 {
 463   Json::Value version;
 464   version["major"] = major;
 465   version["minor"] = minor;
 466   return version;
 467 }
 468
 469 Json::Value cmFileAPI::BuildObject(Object const& object)
 470 {
 471   Json::Value value;
 472
 473   switch (object.Kind) {
 474     case ObjectKind::CodeModel:
 475       value = this->BuildCodeModel(object);
 476       break;
 477     case ObjectKind::ConfigureLog:
 478       value = this->BuildConfigureLog(object);
 479       break;
 480     case ObjectKind::Cache:
 481       value = this->BuildCache(object);
 482       break;
 483     case ObjectKind::CMakeFiles:
 484       value = this->BuildCMakeFiles(object);
 485       break;
 486     case ObjectKind::Toolchains:
 487       value = this->BuildToolchains(object);
 488       break;
 489     case ObjectKind::InternalTest:
 490       value = this->BuildInternalTest(object);
 491       break;
 492   }
 493
 494   return value;
 495 }
 496
 497 cmFileAPI::ClientRequests cmFileAPI::BuildClientRequests(
 498   Json::Value const& requests)
 499 {
 500   ClientRequests result;
 501   if (requests.isNull()) {
 502     result.Error = "'requests' member missing";
 503     return result;
 504   }
 505   if (!requests.isArray()) {
 506     result.Error = "'requests' member is not an array";
 507     return result;
 508   }
 509
 510   result.reserve(requests.size());
 511   for (Json::Value const& request : requests) {
 512     result.emplace_back(this->BuildClientRequest(request));
 513   }
 514
 515   return result;
 516 }
 517
 518 cmFileAPI::ClientRequest cmFileAPI::BuildClientRequest(
 519   Json::Value const& request)
 520 {
 521   ClientRequest r;
 522
 523   if (!request.isObject()) {
 524     r.Error = "request is not an object";
 525     return r;
 526   }
 527
 528   Json::Value const& kind = request["kind"];
 529   if (kind.isNull()) {
 530     r.Error = "'kind' member missing";
 531     return r;
 532   }
 533   if (!kind.isString()) {
 534     r.Error = "'kind' member is not a string";
 535     return r;
 536   }
 537   std::string const& kindName = kind.asString();
 538
 539   if (kindName == this->ObjectKindName(ObjectKind::CodeModel)) {
 540     r.Kind = ObjectKind::CodeModel;
 541   } else if (kindName == this->ObjectKindName(ObjectKind::ConfigureLog)) {
 542     r.Kind = ObjectKind::ConfigureLog;
 543   } else if (kindName == this->ObjectKindName(ObjectKind::Cache)) {
 544     r.Kind = ObjectKind::Cache;
 545   } else if (kindName == this->ObjectKindName(ObjectKind::CMakeFiles)) {
 546     r.Kind = ObjectKind::CMakeFiles;
 547   } else if (kindName == this->ObjectKindName(ObjectKind::Toolchains)) {
 548     r.Kind = ObjectKind::Toolchains;
 549   } else if (kindName == this->ObjectKindName(ObjectKind::InternalTest)) {
 550     r.Kind = ObjectKind::InternalTest;
 551   } else {
 552     r.Error = "unknown request kind '" + kindName + "'";
 553     return r;
 554   }
 555
 556   Json::Value const& version = request["version"];
 557   if (version.isNull()) {
 558     r.Error = "'version' member missing";
 559     return r;
 560   }
 561   std::vector<RequestVersion> versions;
 562   if (!cmFileAPI::ReadRequestVersions(version, versions, r.Error)) {
 563     return r;
 564   }
 565
 566   switch (r.Kind) {
 567     case ObjectKind::CodeModel:
 568       this->BuildClientRequestCodeModel(r, versions);
 569       break;
 570     case ObjectKind::ConfigureLog:
 571       this->BuildClientRequestConfigureLog(r, versions);
 572       break;
 573     case ObjectKind::Cache:
 574       this->BuildClientRequestCache(r, versions);
 575       break;
 576     case ObjectKind::CMakeFiles:
 577       this->BuildClientRequestCMakeFiles(r, versions);
 578       break;
 579     case ObjectKind::Toolchains:
 580       this->BuildClientRequestToolchains(r, versions);
 581       break;
 582     case ObjectKind::InternalTest:
 583       this->BuildClientRequestInternalTest(r, versions);
 584       break;
 585   }
 586
 587   return r;
 588 }
 589
 590 Json::Value cmFileAPI::BuildClientReply(ClientQuery const& q)
 591 {
 592   Json::Value reply = this->BuildReply(q.DirQuery);
 593
 594   if (!q.HaveQueryJson) {
 595     return reply;
 596   }
 597
 598   Json::Value& reply_query_json = reply["query.json"];
 599   ClientQueryJson const& qj = q.QueryJson;
 600
 601   if (!qj.Error.empty()) {
 602     reply_query_json = this->BuildReplyError(qj.Error);
 603     return reply;
 604   }
 605
 606   if (!qj.ClientValue.isNull()) {
 607     reply_query_json["client"] = qj.ClientValue;
 608   }
 609
 610   if (!qj.RequestsValue.isNull()) {
 611     reply_query_json["requests"] = qj.RequestsValue;
 612   }
 613
 614   reply_query_json["responses"] = this->BuildClientReplyResponses(qj.Requests);
 615
 616   return reply;
 617 }
 618
 619 Json::Value cmFileAPI::BuildClientReplyResponses(
 620   ClientRequests const& requests)
 621 {
 622   Json::Value responses;
 623
 624   if (!requests.Error.empty()) {
 625     responses = this->BuildReplyError(requests.Error);
 626     return responses;
 627   }
 628
 629   responses = Json::arrayValue;
 630   for (ClientRequest const& request : requests) {
 631     responses.append(this->BuildClientReplyResponse(request));
 632   }
 633
 634   return responses;
 635 }
 636
 637 Json::Value cmFileAPI::BuildClientReplyResponse(ClientRequest const& request)
 638 {
 639   Json::Value response;
 640   if (!request.Error.empty()) {
 641     response = this->BuildReplyError(request.Error);
 642     return response;
 643   }
 644   response = this->AddReplyIndexObject(request);
 645   return response;
 646 }
 647
 648 bool cmFileAPI::ReadRequestVersions(Json::Value const& version,
 649                                     std::vector<RequestVersion>& versions,
 650                                     std::string& error)
 651 {
 652   if (version.isArray()) {
 653     for (Json::Value const& v : version) {
 654       if (!ReadRequestVersion(v, /*inArray=*/true, versions, error)) {
 655         return false;
 656       }
 657     }
 658   } else {
 659     if (!ReadRequestVersion(version, /*inArray=*/false, versions, error)) {
 660       return false;
 661     }
 662   }
 663   return true;
 664 }
 665
 666 bool cmFileAPI::ReadRequestVersion(Json::Value const& version, bool inArray,
 667                                    std::vector<RequestVersion>& result,
 668                                    std::string& error)
 669 {
 670   if (version.isUInt()) {
 671     RequestVersion v;
 672     v.Major = version.asUInt();
 673     result.push_back(v);
 674     return true;
 675   }
 676
 677   if (!version.isObject()) {
 678     if (inArray) {
 679       error = "'version' array entry is not a non-negative integer or object";
 680     } else {
 681       error =
 682         "'version' member is not a non-negative integer, object, or array";
 683     }
 684     return false;
 685   }
 686
 687   Json::Value const& major = version["major"];
 688   if (major.isNull()) {
 689     error = "'version' object 'major' member missing";
 690     return false;
 691   }
 692   if (!major.isUInt()) {
 693     error = "'version' object 'major' member is not a non-negative integer";
 694     return false;
 695   }
 696
 697   RequestVersion v;
 698   v.Major = major.asUInt();
 699
 700   Json::Value const& minor = version["minor"];
 701   if (minor.isUInt()) {
 702     v.Minor = minor.asUInt();
 703   } else if (!minor.isNull()) {
 704     error = "'version' object 'minor' member is not a non-negative integer";
 705     return false;
 706   }
 707
 708   result.push_back(v);
 709
 710   return true;
 711 }
 712
 713 std::string cmFileAPI::NoSupportedVersion(
 714   std::vector<RequestVersion> const& versions)
 715 {
 716   std::ostringstream msg;
 717   msg << "no supported version specified";
 718   if (!versions.empty()) {
 719     msg << " among:";
 720     for (RequestVersion const& v : versions) {
 721       msg << " " << v.Major << "." << v.Minor;
 722     }
 723   }
 724   return msg.str();
 725 }
 726
 727 // The "codemodel" object kind.
 728
 729 // Update Help/manual/cmake-file-api.7.rst when updating this constant.
 730 static unsigned int const CodeModelV2Minor = 7;
 731
 732 void cmFileAPI::BuildClientRequestCodeModel(
 733   ClientRequest& r, std::vector<RequestVersion> const& versions)
 734 {
 735   // Select a known version from those requested.
 736   for (RequestVersion const& v : versions) {
 737     if ((v.Major == 2 && v.Minor <= CodeModelV2Minor)) {
 738       r.Version = v.Major;
 739       break;
 740     }
 741   }
 742   if (!r.Version) {
 743     r.Error = NoSupportedVersion(versions);
 744   }
 745 }
 746
 747 Json::Value cmFileAPI::BuildCodeModel(Object const& object)
 748 {
 749   Json::Value codemodel = cmFileAPICodemodelDump(*this, object.Version);
 750   codemodel["kind"] = this->ObjectKindName(object.Kind);
 751
 752   Json::Value& version = codemodel["version"];
 753   if (object.Version == 2) {
 754     version = BuildVersion(2, CodeModelV2Minor);
 755   } else {
 756     return codemodel; // should be unreachable
 757   }
 758
 759   return codemodel;
 760 }
 761
 762 // The "configureLog" object kind.
 763
 764 // Update Help/manual/cmake-file-api.7.rst when updating this constant.
 765 static unsigned int const ConfigureLogV1Minor = 0;
 766
 767 void cmFileAPI::BuildClientRequestConfigureLog(
 768   ClientRequest& r, std::vector<RequestVersion> const& versions)
 769 {
 770   // Select a known version from those requested.
 771   for (RequestVersion const& v : versions) {
 772     if ((v.Major == 1 && v.Minor <= ConfigureLogV1Minor)) {
 773       r.Version = v.Major;
 774       break;
 775     }
 776   }
 777   if (!r.Version) {
 778     r.Error = NoSupportedVersion(versions);
 779   }
 780 }
 781
 782 Json::Value cmFileAPI::BuildConfigureLog(Object const& object)
 783 {
 784   Json::Value configureLog = cmFileAPIConfigureLogDump(*this, object.Version);
 785   configureLog["kind"] = this->ObjectKindName(object.Kind);
 786
 787   Json::Value& version = configureLog["version"];
 788   if (object.Version == 1) {
 789     version = BuildVersion(1, ConfigureLogV1Minor);
 790   } else {
 791     return configureLog; // should be unreachable
 792   }
 793
 794   return configureLog;
 795 }
 796
 797 // The "cache" object kind.
 798
 799 static unsigned int const CacheV2Minor = 0;
 800
 801 void cmFileAPI::BuildClientRequestCache(
 802   ClientRequest& r, std::vector<RequestVersion> const& versions)
 803 {
 804   // Select a known version from those requested.
 805   for (RequestVersion const& v : versions) {
 806     if ((v.Major == 2 && v.Minor <= CacheV2Minor)) {
 807       r.Version = v.Major;
 808       break;
 809     }
 810   }
 811   if (!r.Version) {
 812     r.Error = NoSupportedVersion(versions);
 813   }
 814 }
 815
 816 Json::Value cmFileAPI::BuildCache(Object const& object)
 817 {
 818   Json::Value cache = cmFileAPICacheDump(*this, object.Version);
 819   cache["kind"] = this->ObjectKindName(object.Kind);
 820
 821   Json::Value& version = cache["version"];
 822   if (object.Version == 2) {
 823     version = BuildVersion(2, CacheV2Minor);
 824   } else {
 825     return cache; // should be unreachable
 826   }
 827
 828   return cache;
 829 }
 830
 831 // The "cmakeFiles" object kind.
 832
 833 static unsigned int const CMakeFilesV1Minor = 1;
 834
 835 void cmFileAPI::BuildClientRequestCMakeFiles(
 836   ClientRequest& r, std::vector<RequestVersion> const& versions)
 837 {
 838   // Select a known version from those requested.
 839   for (RequestVersion const& v : versions) {
 840     if ((v.Major == 1 && v.Minor <= CMakeFilesV1Minor)) {
 841       r.Version = v.Major;
 842       break;
 843     }
 844   }
 845   if (!r.Version) {
 846     r.Error = NoSupportedVersion(versions);
 847   }
 848 }
 849
 850 Json::Value cmFileAPI::BuildCMakeFiles(Object const& object)
 851 {
 852   Json::Value cmakeFiles = cmFileAPICMakeFilesDump(*this, object.Version);
 853   cmakeFiles["kind"] = this->ObjectKindName(object.Kind);
 854
 855   Json::Value& version = cmakeFiles["version"];
 856   if (object.Version == 1) {
 857     version = BuildVersion(1, CMakeFilesV1Minor);
 858   } else {
 859     return cmakeFiles; // should be unreachable
 860   }
 861
 862   return cmakeFiles;
 863 }
 864
 865 // The "toolchains" object kind.
 866
 867 static unsigned int const ToolchainsV1Minor = 0;
 868
 869 void cmFileAPI::BuildClientRequestToolchains(
 870   ClientRequest& r, std::vector<RequestVersion> const& versions)
 871 {
 872   // Select a known version from those requested.
 873   for (RequestVersion const& v : versions) {
 874     if ((v.Major == 1 && v.Minor <= ToolchainsV1Minor)) {
 875       r.Version = v.Major;
 876       break;
 877     }
 878   }
 879   if (!r.Version) {
 880     r.Error = NoSupportedVersion(versions);
 881   }
 882 }
 883
 884 Json::Value cmFileAPI::BuildToolchains(Object const& object)
 885 {
 886   Json::Value toolchains = cmFileAPIToolchainsDump(*this, object.Version);
 887   toolchains["kind"] = this->ObjectKindName(object.Kind);
 888
 889   Json::Value& version = toolchains["version"];
 890   if (object.Version == 1) {
 891     version = BuildVersion(1, ToolchainsV1Minor);
 892   } else {
 893     return toolchains; // should be unreachable
 894   }
 895
 896   return toolchains;
 897 }
 898
 899 // The "__test" object kind is for internal testing of CMake.
 900
 901 static unsigned int const InternalTestV1Minor = 3;
 902 static unsigned int const InternalTestV2Minor = 0;
 903
 904 void cmFileAPI::BuildClientRequestInternalTest(
 905   ClientRequest& r, std::vector<RequestVersion> const& versions)
 906 {
 907   // Select a known version from those requested.
 908   for (RequestVersion const& v : versions) {
 909     if ((v.Major == 1 && v.Minor <= InternalTestV1Minor) || //
 910         (v.Major == 2 && v.Minor <= InternalTestV2Minor)) {
 911       r.Version = v.Major;
 912       break;
 913     }
 914   }
 915   if (!r.Version) {
 916     r.Error = NoSupportedVersion(versions);
 917   }
 918 }
 919
 920 Json::Value cmFileAPI::BuildInternalTest(Object const& object)
 921 {
 922   Json::Value test = Json::objectValue;
 923   test["kind"] = this->ObjectKindName(object.Kind);
 924   Json::Value& version = test["version"];
 925   if (object.Version == 2) {
 926     version = BuildVersion(2, InternalTestV2Minor);
 927   } else {
 928     version = BuildVersion(1, InternalTestV1Minor);
 929   }
 930   return test;
 931 }
 932
 933 Json::Value cmFileAPI::ReportCapabilities()
 934 {
 935   Json::Value capabilities = Json::objectValue;
 936   Json::Value& requests = capabilities["requests"] = Json::arrayValue;
 937
 938   {
 939     Json::Value request = Json::objectValue;
 940     request["kind"] = ObjectKindName(ObjectKind::CodeModel);
 941     Json::Value& versions = request["version"] = Json::arrayValue;
 942     versions.append(BuildVersion(2, CodeModelV2Minor));
 943     requests.append(std::move(request)); // NOLINT(*)
 944   }
 945
 946   {
 947     Json::Value request = Json::objectValue;
 948     request["kind"] = ObjectKindName(ObjectKind::ConfigureLog);
 949     Json::Value& versions = request["version"] = Json::arrayValue;
 950     versions.append(BuildVersion(1, ConfigureLogV1Minor));
 951     requests.append(std::move(request)); // NOLINT(*)
 952   }
 953
 954   {
 955     Json::Value request = Json::objectValue;
 956     request["kind"] = ObjectKindName(ObjectKind::Cache);
 957     Json::Value& versions = request["version"] = Json::arrayValue;
 958     versions.append(BuildVersion(2, CacheV2Minor));
 959     requests.append(std::move(request)); // NOLINT(*)
 960   }
 961
 962   {
 963     Json::Value request = Json::objectValue;
 964     request["kind"] = ObjectKindName(ObjectKind::CMakeFiles);
 965     Json::Value& versions = request["version"] = Json::arrayValue;
 966     versions.append(BuildVersion(1, CMakeFilesV1Minor));
 967     requests.append(std::move(request)); // NOLINT(*)
 968   }
 969
 970   {
 971     Json::Value request = Json::objectValue;
 972     request["kind"] = ObjectKindName(ObjectKind::Toolchains);
 973     Json::Value& versions = request["version"] = Json::arrayValue;
 974     versions.append(BuildVersion(1, ToolchainsV1Minor));
 975     requests.append(std::move(request)); // NOLINT(*)
 976   }
 977
 978   return capabilities;
 979 }
 980
 981 bool cmFileAPI::AddProjectQuery(cmFileAPI::ObjectKind kind,
 982                                 unsigned majorVersion, unsigned minorVersion)
 983 {
 984   switch (kind) {
 985     case ObjectKind::CodeModel:
 986       if (majorVersion != 2 || minorVersion > CodeModelV2Minor) {
 987         return false;
 988       }
 989       break;
 990     case ObjectKind::Cache:
 991       if (majorVersion != 2 || minorVersion > CacheV2Minor) {
 992         return false;
 993       }
 994       break;
 995     case ObjectKind::CMakeFiles:
 996       if (majorVersion != 1 || minorVersion > CMakeFilesV1Minor) {
 997         return false;
 998       }
 999       break;
1000     case ObjectKind::Toolchains:
1001       if (majorVersion != 1 || minorVersion > ToolchainsV1Minor) {
1002         return false;
1003       }
1004       break;
1005     // These cannot be requested by the project
1006     case ObjectKind::ConfigureLog:
1007     case ObjectKind::InternalTest:
1008       return false;
1009   }
1010
1011   Object query;
1012   query.Kind = kind;
1013   query.Version = majorVersion;
1014   if (std::find(this->TopQuery.Known.begin(), this->TopQuery.Known.end(),
1015                 query) == this->TopQuery.Known.end()) {
1016     this->TopQuery.Known.emplace_back(query);
1017     this->QueryExists = true;
1018   }
1019
1020   return true;
1021 }