qi3pc.cpp

#include <QDebug>
 
#include "qi3pc.h"
 
Q_LOGGING_CATEGORY(Qi3pcLogger, "qi3pc", QtMsgType::QtDebugMsg)
 
qi3pc::qi3pc(QObject* parent)
  : qi3pc(FindSocketPath(), parent)
{}
 
qi3pc::qi3pc(const QString& serverPath, QObject* parent)
  : QObject(parent)
{
  m_socketPath = serverPath;
 
  m_barConfigs = std::make_pair(QJsonObject(), QDateTime::currentMSecsSinceEpoch());
  if (m_socketPath.isEmpty()) {
    throw std::invalid_argument("The provided server path must not be empty.");
  }
 
  QObject::connect(
        &m_eventSocket, &QLocalSocket::readyRead, this, &qi3pc::processEvent);
  QObject::connect(
        &m_messageSocket, &QLocalSocket::readyRead, this, &qi3pc::processReply);
}
 
qi3pc::~qi3pc()
{
  m_eventSocket.close();
  m_messageSocket.close();
 
  m_eventSocket.abort();
  m_messageSocket.abort();
}
 
void
qi3pc::processEvent()
{
  Message m = processMessage(m_eventSocket);
  if (!m) {
    return;
  }
 
  auto [data, type] = m.value();
 
  if (type & (1u << 31)) {
    switch (static_cast<IpcEvent>(type)) {
      case IpcEvent::Workspace:
        processWorkspaceEvent(data);
        break;
      case IpcEvent::Output:
        processOutputEvent(data);
        break;
      case IpcEvent::Mode:
        processModeEvent(data);
        break;
      case IpcEvent::Window:
        processWindowEvent(data);
        break;
      case IpcEvent::BarUpdate:
        processBarUpdateEvent(data);
        break;
      case IpcEvent::Binding:
        processBindingEvent(data);
        break;
      case IpcEvent::Shutdown:
        processShutdownEvent(data);
        break;
      case IpcEvent::Tick:
        processTickEvent(data);
        break;
      default:
        std::string log = "Received event of unsupported type IpcType::%u";
        qCWarning(Qi3pcLogger, log.c_str(), type, IpcType::Subscribe);
        break;
    }
  } else {
    switch (static_cast<IpcType>(type)) {
      case IpcType::Subscribe:
        emit subscribed(data["success"].toBool());
        break;
      case IpcType::Tick:
        processTickReply(data);
        break;
      default:
        std::string log = "Received message IpcType::%u while expecting IpcEvent, IpcType::Subscribe (IpcType::%u),"
                          "or IpcType::Tick (IpcType::%u)";
        qCWarning(Qi3pcLogger, log.c_str(), type, IpcType::Subscribe, IpcType::Tick);
        break;
    }
  }
}
 
void
qi3pc::processReply()
{
  Message m = processMessage(m_messageSocket);
  if (!m) {
    return;
  }
 
  auto [data, type] = m.value();
 
  std::string log;
  switch (static_cast<IpcType>(type)) {
    case IpcType::Command:
      processCommandReply(data);
      break;
    case IpcType::Workspaces:
      processWorkspaceReply(data);
      break;
    case IpcType::Subscribe:
      log = "Received reply of type IpcType::Subscribe (IpcType::%u): unexpected.";
      qCWarning(Qi3pcLogger, log.c_str(), IpcType::Subscribe);
      break;
    case IpcType::Outputs:
      processOutputReply(data);
      break;
    case IpcType::Tree:
      processTreeReply(data);
      break;
    case IpcType::Marks:
      processMarkReply(data);
      break;
    case IpcType::BarConfig:
      processBarConfigReply(data);
      break;
    case IpcType::Version:
      processVersionReply(data);
      break;
    case IpcType::BindingModes:
      processBindingModesReply(data);
      break;
    case IpcType::Config:
      processConfigReply(data);
      break;
    case IpcType::Tick:
      log = "Received reply of type IpcType::Tick (IpcType::%u): unexpected.";
      qCWarning(Qi3pcLogger, log.c_str(), IpcType::Tick);
      break;
    case IpcType::Sync:
      processSyncReply(data);
      break;
    case IpcType::BindingState:
      processBindingStateReply(data);
      break;
    default:
      log = "Received reply of unsupported type IpcType::%u.";
      qCWarning(Qi3pcLogger, log.c_str(), type);
      break;
  }
}
 
void
qi3pc::processCommandReply(const QJsonDocument& doc)
{
  auto results = doc.array();
  if (results.empty()) {
    qCWarning(Qi3pcLogger) << "Received empty command reply:" << doc.toJson();
    emit commandRan({{false, ParseError{}}});
  }
 
  CommandResults result;
  for (auto jsonObject: std::as_const(results)) {
    auto object = jsonObject.toObject();
    if (!object.contains("success")) {
      qCWarning(Qi3pcLogger) << "Command reply does not contain success key. Skipping:" << object;
      continue;
    }
 
    if (auto success = object["success"].toBool(); success) {
      result.push_back({true, {}});
    } else {
      result.push_back({false, ParseError::FromJSON(object)});
    }
  }
 
  emit commandRan(result);
}
 
void
qi3pc::processWorkspaceReply(const QJsonDocument& doc)
{
  m_workspaces = std::make_pair(doc.array(), QDateTime::currentMSecsSinceEpoch());
  emit workspacesUpdated(m_workspaces);
}
 
void
qi3pc::processOutputReply(const QJsonDocument& doc)
{
  m_outputs = std::make_pair(doc.array(), QDateTime::currentMSecsSinceEpoch());
  emit outputsUpdated(m_outputs);
}
 
void
qi3pc::processTreeReply(const QJsonDocument& doc)
{
  m_tree = std::make_pair(doc.object(), QDateTime::currentMSecsSinceEpoch());
  emit treeUpdated(m_tree);
}
 
void
qi3pc::processMarkReply(const QJsonDocument& doc)
{
  m_marks = std::make_pair(doc.array(), QDateTime::currentMSecsSinceEpoch());
  emit marksUpdated(m_marks);
}
 
void
qi3pc::processBarConfigReply(const QJsonDocument& doc)
{
  if (const auto& ids = doc.array(); !ids.isEmpty()) {
    for (auto ref : ids) {
      if (auto id = ref.toString();
          m_barConfigs->first[id] == QJsonValue::Null) {
        emit newBarConfig(id);
      }
    }
  } else {
    auto id = doc["id"].toString();
    auto config = doc.object();
    m_barConfigs->first[id] = config;
    m_barConfigs->second = QDateTime::currentMSecsSinceEpoch();
    emit barConfigUpdated(config);
  }
}
 
void
qi3pc::processVersionReply(const QJsonDocument& doc)
{
  m_version = std::make_pair(doc.object(), QDateTime::currentMSecsSinceEpoch());
  emit versionUpdated(m_version);
}
 
void
qi3pc::processBindingModesReply(const QJsonDocument& doc)
{
  m_bindingModes = std::make_pair(doc.array(), QDateTime::currentMSecsSinceEpoch());
  emit bindingModesUpdated(m_bindingModes);
}
 
void
qi3pc::processConfigReply(const QJsonDocument& doc)
{
  m_config = std::make_pair(doc.object(), QDateTime::currentMSecsSinceEpoch());
  emit configUpdated(m_config);
}
 
void
qi3pc::processTickReply(const QJsonDocument& doc)
{
  emit tickSent(doc["success"].toBool());
}
 
void
qi3pc::processSyncReply(const QJsonDocument& doc)
{
  emit synced(doc["success"].toBool());
}
 
void
qi3pc::processBindingStateReply(const QJsonDocument& doc)
{
  m_bindingState = std::make_pair(doc["name"].toString(), QDateTime::currentMSecsSinceEpoch());
  emit bindingStateUpdated(m_bindingState);
}
 
void
qi3pc::processWorkspaceEvent(const QJsonDocument& doc)
{
  auto change = WorkspaceChangeFromString(doc["change"].toString());
 
  if (change == WorkspaceChange::Unknown) {
    qCWarning(Qi3pcLogger) << "Received workspace event with unknown change string" << doc["change"].toString();
    return;
  }
 
  auto old = doc["old"].toObject();
  auto current = doc["current"].toObject();
  emit workspaceEvent(change, current, old);
}
 
void
qi3pc::processOutputEvent(const QJsonDocument& data)
{
  auto change = OutputChangeFromString(data["change"].toString());
 
  if (change == OutputChange::Unknown) {
    qCWarning(Qi3pcLogger) << "Received output event with unknown change string" << data["change"].toString();
    return;
  }
 
  emit outputEvent(change);
}
 
void
qi3pc::processModeEvent(const QJsonDocument& doc)
{
  emit modeEvent(doc["change"].toString(), doc["pango_markup"].toBool());
}
 
void
qi3pc::processWindowEvent(const QJsonDocument& doc)
{
  auto change = WindowChangeFromString(doc["change"].toString());
 
  if (change == WindowChange::Unknown) {
    qCWarning(Qi3pcLogger) << "Received window event with unknown change string" << doc["change"].toString();
    return;
  }
 
  emit windowEvent(change, doc["container"].toObject());
}
 
void
qi3pc::processBarUpdateEvent(const QJsonDocument& doc)
{
  emit barUpdateEvent(doc.object());
}
 
void
qi3pc::processBindingEvent(const QJsonDocument& doc)
{
  auto change = BindingChangeFromString(doc["change"].toString());
 
  if (change == BindingChange::Unknown) {
    qCWarning(Qi3pcLogger) << "Received binding event with unknown change string" << doc["change"].toString();
    return;
  }
 
  emit bindingEvent(change, doc["binding"].toObject(), doc["mode"].toString());
}
 
void
qi3pc::processShutdownEvent(const QJsonDocument& doc)
{
  auto change = ShutdownChangeFromString(doc["change"].toString());
 
  if (change == ShutdownChange::Unknown) {
    qCWarning(Qi3pcLogger) << "Received shutdown event with unknown change string" << doc["change"].toString();
    return;
  }
 
  emit shutdownEvent(change);
}
 
void
qi3pc::processTickEvent(const QJsonDocument& doc)
{
  if(auto first = doc["first"].toBool(); !first) {
    emit tickEvent(doc["payload"].toString());
  }
}
 
qi3pc::WorkspaceChange
qi3pc::WorkspaceChangeFromString(const QString& s)
{
  if (s == "focus") {
    return WorkspaceChange::Focus;
  } else if (s == "init") {
    return WorkspaceChange::Init;
  } else if (s == "empty") {
    return WorkspaceChange::Empty;
  } else if (s == "urgent") {
    return WorkspaceChange::Urgent;
  } else if (s == "reload") {
    return WorkspaceChange::Reload;
  } else if (s == "rename") {
    return WorkspaceChange::Rename;
  } else if (s == "restored") {
    return WorkspaceChange::Restored;
  } else if (s == "move") {
    return WorkspaceChange::Move;
  } else {
    return WorkspaceChange::Unknown;
  }
}
 
qi3pc::WindowChange
qi3pc::WindowChangeFromString(const QString& s)
{
  if (s == "new") {
    return WindowChange::New;
  } else if (s == "close") {
    return WindowChange::Close;
  } else if (s == "focus") {
    return WindowChange::Focus;
  } else if (s == "title") {
    return WindowChange::Title;
  } else if (s == "fullscreen_mode") {
    return WindowChange::Fullscreen;
  } else if (s == "move") {
    return WindowChange::Move;
  } else if (s == "floating") {
    return WindowChange::Floating;
  } else if (s == "urgent") {
    return WindowChange::Urgent;
  } else if (s == "mark") {
    return WindowChange::Mark;
  } else {
    return WindowChange::Unknown;
  }
}
 
qi3pc::ShutdownChange
qi3pc::ShutdownChangeFromString(const QString& s)
{
  if (s == "restart") {
    return ShutdownChange::Restart;
  } else if (s == "exit") {
    return ShutdownChange::Exit;
  } else {
    return ShutdownChange::Unknown;
  }
}
 
qi3pc::OutputChange
qi3pc::OutputChangeFromString(const QString& s)
{
  if (s == "unspecified") {
    return OutputChange::Unspecified;
  } else {
    return OutputChange::Unknown;
  }
}
 
qi3pc::BindingChange
qi3pc::BindingChangeFromString(const QString& s)
{
  if (s == "run") {
    return BindingChange::Run;
  } else {
    return BindingChange::Unknown;
  }
}
 
qi3pc::Message
qi3pc::processMessage(QLocalSocket& socket)
{
  char c[IpcMagicLength];
  if (auto read_size = socket.read(c, IpcMagicLength);
      read_size != IpcMagicLength) {
    qCWarning(Qi3pcLogger) << "Insufficient data read for IPC magic string. Seeked"
                           << IpcMagicLength <<"bytes. - Read" << read_size << "bytes.";
    return {};
  }
 
  if (auto s = std::string(c, IpcMagicLength); s != IpcMagicString) {
    qCWarning(Qi3pcLogger) << "Unexpected magic string in message. Expected"
                           << qi3pc::IpcMagicString << ". - Found" << s << ".";
    return {};
  }
 
  quint32 size;
  if (auto read_size = socket.read(reinterpret_cast<char*>(&size), sizeof size);
      read_size != sizeof size) {
    qCWarning(Qi3pcLogger) << "Insufficient data read for message size. Seeked"
                           << sizeof size <<"bytes. - Read" << read_size << "bytes.";
    return {};
  }
 
  quint32 type;
  if (auto read_size = socket.read(reinterpret_cast<char*>(&type), sizeof type);
      read_size != sizeof type) {
    qCWarning(Qi3pcLogger) << "Insufficient data read for message type. Seeked"
                           << sizeof type <<"bytes. - Read" << read_size << "bytes.";
    return {};
  }
 
  QJsonParseError parseError;
  auto payload = socket.read(size);
 
  if (socket.bytesAvailable() > 0) {
    emit socket.readyRead();
  }
 
  QJsonDocument data = QJsonDocument::fromJson(payload, &parseError);
  if (parseError.error != QJsonParseError::NoError) {
    qCWarning(Qi3pcLogger) << "Parsing message body failed - JSON parse error:"
                           << parseError.errorString() << "in:" << payload;
    return {};
  }
 
  return std::make_pair(data, type);
}
 
QString
qi3pc::FindSocketPath()
{
  if (auto path = QProcessEnvironment::systemEnvironment().value("I3SOCK");
      !path.isEmpty()) {
    return path;
  }
 
  // TODO: try to get socket path from root window property
  return FindSocketPathFromI3Binary();
}
 
QString
qi3pc::FindSocketPathFromI3Binary()
{
  QProcess process;
  process.start("i3", QStringList("--get-socketpath"));
  process.waitForReadyRead();
  auto path = QString(process.readAllStandardOutput()).trimmed();
  process.kill();
  process.waitForFinished();
  return path;
}
 
QString
qi3pc::socketPath() const
{
  return m_socketPath;
}
 
const
qi3pc::DataArray&
qi3pc::workspaces() const
{
  return m_workspaces;
}
 
const
qi3pc::DataObject&
qi3pc::tree() const
{
  return m_tree;
}
 
const
qi3pc::DataArray&
qi3pc::outputs() const
{
  return m_outputs;
}
 
const
qi3pc::DataArray&
qi3pc::marks() const
{
  return m_marks;
}
 
const
qi3pc::DataObject&
qi3pc::barConfigs() const
{
  return m_barConfigs;
}
 
const
qi3pc::DataObject&
qi3pc::version() const
{
  return m_version;
}
 
const
qi3pc::DataArray&
qi3pc::bindingModes() const
{
  return m_bindingModes;
}
 
const
qi3pc::DataObject&
qi3pc::config() const
{
  return m_config;
}
 
const
qi3pc::DataString&
qi3pc::bindingState() const
{
  return m_bindingState;
}
 
bool
qi3pc::connect()
{
 
  m_messageSocket.connectToServer(m_socketPath);
  m_eventSocket.connectToServer(m_socketPath);
 
  if (m_messageSocket.state() != QLocalSocket::ConnectedState)
  {
    m_messageSocket.waitForConnected();
  }
 
  if (m_eventSocket.state() != QLocalSocket::ConnectedState)
  {
    m_eventSocket.waitForConnected();
  }
 
  return m_messageSocket.state() == QLocalSocket::ConnectedState &&
      m_eventSocket.state() == QLocalSocket::ConnectedState;
}
 
bool
qi3pc::disconnect()
{
  m_messageSocket.disconnectFromServer();
  m_eventSocket.disconnectFromServer();
 
  if (m_messageSocket.state() != QLocalSocket::UnconnectedState)
  {
    m_messageSocket.waitForDisconnected();
  }
 
  if (m_eventSocket.state() != QLocalSocket::UnconnectedState)
  {
    m_eventSocket.waitForDisconnected();
  }
 
  return m_messageSocket.state() == QLocalSocket::UnconnectedState &&
      m_eventSocket.state() == QLocalSocket::UnconnectedState;
}
 
bool
qi3pc::isConnected()
{
  if (m_messageSocket.state() == QLocalSocket::ConnectingState ||
      m_eventSocket.state() == QLocalSocket::ConnectingState) {
    m_messageSocket.waitForConnected();
    m_eventSocket.waitForConnected();
  }
 
  return m_messageSocket.state() == QLocalSocket::ConnectedState &&
      m_eventSocket.state() == QLocalSocket::ConnectedState;
}
 
void
qi3pc::sendTick(const QByteArray& payload)
{
  WritePayload(m_eventSocket, payload, IpcType::Tick);
}
 
void
qi3pc::subscribe(const QStringList& events)
{
  if (events.isEmpty()) {
    qCWarning(Qi3pcLogger) << "Requested to subscibe to empty event list. Nothing to do.";
    return;
  }
 
  WritePayload(
        m_eventSocket,
        QJsonDocument(QJsonArray::fromStringList(events)).toJson(),
        IpcType::Subscribe);
  m_eventSocket.flush();
}
 
void
qi3pc::WritePayload(QLocalSocket& socket, const QByteArray& payload, IpcType type)
{
  QByteArray message;
  QDataStream stream(&message, QIODevice::WriteOnly);
 
  stream.writeRawData(qi3pc::IpcMagicString.data(), qi3pc::IpcMagicLength);
 
  qint32 size = payload.size();
  stream.writeRawData(reinterpret_cast<const char*>(&size), sizeof size);
  stream.writeRawData(reinterpret_cast<const char*>(&type), sizeof type);
 
  if (size > 0) {
    stream.writeRawData(payload.constData(), size);
  }
 
  socket.write(message);
}
 
void
qi3pc::fetchWorkspaces()
{
  sendMessage<IpcType::Workspaces>();
}
 
void
qi3pc::fetchTree()
{
  sendMessage<IpcType::Tree>();
}
 
void
qi3pc::fetchOutputs()
{
  sendMessage<IpcType::Outputs>();
}
 
void
qi3pc::fetchMarks()
{
  sendMessage<IpcType::Marks>();
}
 
void
qi3pc::fetchVersion()
{
  sendMessage<IpcType::Version>();
}
 
void
qi3pc::fetchBindingModes()
{
  sendMessage<IpcType::BindingModes>();
}
 
void
qi3pc::fetchConfig()
{
  sendMessage<IpcType::Config>();
}
 
void
qi3pc::fetchBarConfigs()
{
  sendMessage<IpcType::BarConfig>();
}
 
void
qi3pc::fetchBarConfig(const QString& id)
{
  QByteArray payload;
  payload.append(id.toStdString().c_str());
  sendMessage<IpcType::BarConfig>(payload);
}
 
void
qi3pc::fetchBindingState()
{
  sendMessage<IpcType::BindingState>();
}
 
qi3pc::Error
qi3pc::ParseError::FromJSON(const QJsonObject& json)
{
  if(!json.contains("parse_error")) {
    return {};
  }
  auto ret = ParseError {};
  for (const auto& [name, member]: ParseError::_MEMBERS) {
    if (json.contains(name)) {
      ret.*member = json[name].toString();
    }
  }
 
  return ret;
}
 
bool
qi3pc::ParseError::operator==(const ParseError& other) const {
  return error == other.error &&
      input == other.input &&
      errorPosition == other.errorPosition;
}
 
QString
qi3pc::ParseError::toString() const
{
  auto str = QString("{");
  for (const auto& [name, member]: ParseError::_MEMBERS) {
    str += QString(name) + ":'" + this->*member + "',";
  }
 
  return str + "}";
}