Skip to content

CPP Client

Akram El Assas edited this page Jul 18, 2025 · 1 revision

Prerequisites

Windows

  • Install MSYS2
  • Open the MSYS2 MinGW 64-bit shell and run:
pacman -Syu         # Update package database and core system
pacman -Su          # Finish update (may require closing/reopening terminal)

pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-curl

Linux

On Debian/Ubuntu:

sudo apt update
sudo apt install libcurl4-openssl-dev build-essential

On Fedora:

sudo dnf install libcurl-devel gcc-c++

On Arch Linux:

sudo pacman -S curl

Client Sample

Here is a sample C++ client client.cpp:

#include <iostream>
#include <string>
#include <curl/curl.h>

static size_t WriteCallback(void *contents, size_t size, size_t nmemb, std::string *s)
{
  size_t totalSize = size * nmemb;
  s->append((char *)contents, totalSize);
  return totalSize;
}

std::string login(const std::string &baseUrl, const std::string &username, const std::string &password)
{
  CURL *curl = curl_easy_init();
  if (!curl)
    throw std::runtime_error("Failed to init curl");

  std::string url = baseUrl + "/login";
  std::string readBuffer;
  std::string jsonData = "{\"username\":\"" + username + "\",\"password\":\"" + password + "\",\"stayConnected\":false}";

  struct curl_slist *headers = nullptr;
  headers = curl_slist_append(headers, "Content-Type: application/json");

  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonData.c_str());

  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

  CURLcode res = curl_easy_perform(curl);
  if (res != CURLE_OK)
  {
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    throw std::runtime_error(std::string("curl_easy_perform() failed: ") + curl_easy_strerror(res));
  }

  long http_code = 0;
  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
  curl_slist_free_all(headers);
  curl_easy_cleanup(curl);

  if (http_code != 200)
    throw std::runtime_error("Login failed with HTTP code " + std::to_string(http_code));

  // Simple parsing to extract access_token value from JSON response
  // For production, use a JSON parser like nlohmann/json
  auto startPos = readBuffer.find("\"access_token\":\"");
  if (startPos == std::string::npos)
    throw std::runtime_error("access_token not found in response");

  startPos += strlen("\"access_token\":\"");
  auto endPos = readBuffer.find("\"", startPos);
  if (endPos == std::string::npos)
    throw std::runtime_error("Malformed access_token in response");

  return readBuffer.substr(startPos, endPos - startPos);
}

std::string startWorkflow(const std::string &baseUrl, const std::string &token, int workflowId)
{
  CURL *curl = curl_easy_init();
  if (!curl)
    throw std::runtime_error("Failed to init curl");

  std::string url = baseUrl + "/start?w=" + std::to_string(workflowId);
  std::string readBuffer;

  struct curl_slist *headers = nullptr;
  std::string authHeader = "Authorization: Bearer " + token;

  headers = curl_slist_append(headers, authHeader.c_str());
  headers = curl_slist_append(headers, "Content-Type: application/json");
  headers = curl_slist_append(headers, "Content-Length: 0");

  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(curl, CURLOPT_POST, 1L);

  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

  CURLcode res = curl_easy_perform(curl);
  if (res != CURLE_OK)
  {
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    throw std::runtime_error(std::string("curl_easy_perform() failed: ") + curl_easy_strerror(res));
  }

  long http_code = 0;
  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
  curl_slist_free_all(headers);
  curl_easy_cleanup(curl);

  if (http_code != 200)
    throw std::runtime_error("Start workflow failed with HTTP code " + std::to_string(http_code));

  return readBuffer;
}

int main()
{
  const std::string baseUrl = "http://localhost:8000/api/v1";
  const std::string username = "admin";
  const std::string password = "wexflow2018";
  const int workflowId = 41;

  try
  {
    std::string token = login(baseUrl, username, password);
    std::string jobId = startWorkflow(baseUrl, token, workflowId);
    std::cout << "Workflow " << workflowId << " started successfully. Job ID: " << jobId << std::endl;
  }
  catch (const std::exception &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
    return 1;
  }
  return 0;
}

Run the Client

Windows

Open the MSYS2 MinGW 64-bit shell (not the default MSYS shell) and run:

g++ client.cpp -o wexflow_client.exe -lcurl -lws2_32 -lcrypt32
./wexflow_client.exe

Linux

g++ client.cpp -o wexflow_client -lcurl
./wexflow_client
  1. Installing
    1. Windows (.NET 4.8 - Legacy)
      1. Installation Instructions
    2. Windows (.NET 9.0+ - Stable)
      1. Accessing the Admin Panel
      2. Configuration
      3. Running Wexflow as a Windows Service using NSSM
      4. Deleting the Wexflow Windows Service
    3. Linux (.NET 9.0+ - Stable)
      1. Installing the Admin Panel on NGINX
      2. Installing the Admin Panel on Apache2
      3. MongoDB Configuration
      4. Updating Wexflow
    4. macOS (.NET 9.0+ - Stable)
    5. Installing the Admin Panel on a Web Server
      1. .NET 4.8 - Legacy
      2. .NET 9.0+ - Stable
  2. HTTPS/SSL
  3. Screenshots
  4. Docker
  5. Configuration
    1. Wexflow Server
    2. Wexflow.xml
    3. Admin Panel
    4. Authentication
  6. Persistence Providers
  7. Getting Started
  8. Android App
  9. Local Variables
  10. Global Variables
  11. REST Variables
  12. Functions
  13. Cron Scheduling
  14. Command Line Interface (CLI)
  15. REST API Reference
    1. Introduction
    2. JWT Authentication
    3. Sample Clients
      1. C# Client
      2. JavaScript Client
      3. PHP Client
      4. Python Client
      5. Go Client
      6. Rust Client
      7. Ruby Client
      8. Java Client
      9. C++ Client
    4. Security Considerations
    5. Swagger
    6. Workflow Notifications via SSE
      1. C# SSE Client
      2. JavaScript SSE Client
      3. PHP SSE Client
      4. Python SSE Client
      5. Go SSE Client
      6. Rust SSE Client
      7. Ruby SSE Client
      8. Java SSE Client
      9. C++ SSE Client
    7. Endpoints
  16. Samples
    1. Sequential workflows
    2. Execution graph
    3. Flowchart workflows
      1. If
      2. While
      3. Switch
    4. Approval workflows
      1. Simple approval workflow
      2. OnRejected workflow event
      3. YouTube approval workflow
      4. Form submission approval workflow
    5. Workflow events
  17. Logging
  18. Custom Tasks
    1. Introduction
    2. General
      1. Creating a Custom Task
      2. Wexflow Task Class Example
      3. Task Status
      4. Settings
      5. Loading Files
      6. Loading Entities
      7. Need A Starting Point?
    3. Installing Your Custom Task in Wexflow
      1. .NET Framework 4.8 (Legacy Version)
      2. .NET 8.0+ (Stable Version)
      3. Referenced Assemblies
      4. Updating a Custom Task
      5. Using Your Custom Task
    4. Suspend/Resume
    5. Logging
    6. Files
    7. Entities
    8. Shared Memory
    9. Designer Integration
      1. Registering the Task
      2. Adding Settings
  19. Debugging
  20. Built-in Tasks
    1. File system tasks
    2. Encryption tasks
    3. Compression tasks
    4. Iso tasks
    5. Speech tasks
    6. Hashing tasks
    7. Process tasks
    8. Network tasks
    9. XML tasks
    10. SQL tasks
    11. WMI tasks
    12. Image tasks
    13. Audio and video tasks
    14. Email tasks
    15. Workflow tasks
    16. Social media tasks
    17. Waitable tasks
    18. Reporting tasks
    19. Web tasks
    20. Script tasks
    21. JSON and YAML tasks
    22. Entities tasks
    23. Flowchart tasks
    24. Approval tasks
    25. Notification tasks
    26. SMS tasks
  21. Run from Source
Clone this wiki locally