Пример #1
0
  void ConnectionManager::EdgeCheck(const int &)
  {
    qDebug() << "Checking edges";
    QList<QSharedPointer<Edge> > edges_to_close;
    qint64 now = Utils::Time::GetInstance().MSecsSinceEpoch();
    qint64 check_time = now - EdgeCheckTimeout;
    qint64 close_time = now - EdgeCloseTimeout;

    foreach(const QSharedPointer<Edge> &edge, _con_tab.GetEdges()) {
      qint64 last_msg = edge->GetLastIncomingMessage();
      if(check_time < last_msg) {
        continue;
      } else if(last_msg < close_time) {
        QSharedPointer<Connection> con = _con_tab.GetConnection(edge.data());
        if(con && (con->GetRemoteId() == _local_id)) {
          qDebug() << "Attempted to close loopback connection.";
          continue;
        }
        qDebug() << "Closing edge:" << edge->ToString();
        edge->Stop("Timed out");
      } else {
        QSharedPointer<Messaging::ISender> sender = _con_tab.GetConnection(edge.data());
        if(!sender) {
          sender = edge;
        }
        qDebug() << "Testing:" << sender->ToString();
        _rpc->SendRequest(sender, "CM::Ping", QVariant(), _ping_handler, true);
      }
    }
  }
Пример #2
0
  void RpcHandler::SendNotification(const QSharedPointer<ISender> &to,
      const QString &method, const QVariant &data)
  {
    int id = IncrementId();
    QVariantList container = Request::BuildNotification(id, method, data);

    QByteArray msg;
    QDataStream stream(&msg, QIODevice::WriteOnly);
    stream << container;

    qDebug() << "RpcHandler: Sending notification" << id << "for" << method <<
      "to" << to->ToString();
    to->Send(msg);
  }
Пример #3
0
  void ConnectionManager::Disconnect(const Request &notification)
  {
    QSharedPointer<Connection> con =
      notification.GetFrom().dynamicCast<Connection>();

    if(!con) {
      qWarning() << "Received DisconnectResponse from a non-connection: " <<
        notification.GetFrom()->ToString();
      return;
    }

    qDebug() << "Received disconnect for: " << con->ToString();
    _con_tab.Disconnect(con.data());
    con->GetEdge()->Stop("Remote disconnect");
  }
Пример #4
0
  void ConnectionManager::BindEdge(const QSharedPointer<Edge> &edge,
      const Id &rem_id)
  {
    /// @TODO add an extra variable to the connection message such as a session
    ///token so that quick reconnects can be enabled.
    if(_con_tab.GetConnection(rem_id) != 0) {
      qDebug() << "Already have a connection to: " << rem_id.ToString() << 
        " closing Edge: " << edge->ToString();

      _rpc->SendNotification(edge, "CM::Close", QVariant());
      Address addr = edge->GetRemoteAddress();
      edge->Stop("Duplicate connection");
      emit ConnectionAttemptFailure(addr, "Duplicate connection");
      return;
    }
  
    _rpc->SendNotification(edge, "CM::Connect", _local_id.GetByteArray());
    CreateConnection(edge, rem_id);
  }
Пример #5
0
  int RpcHandler::SendRequest(const QSharedPointer<ISender> &to,
      const QString &method, const QVariant &data,
      const QSharedPointer<ResponseHandler> &cb, bool timeout)
  {
    int id = IncrementId();
    qint64 ctime = Utils::Time::GetInstance().MSecsSinceEpoch();

    TimerCallback *callback = new TimerCallback(this, &RpcHandler::Timeout, id);
    Utils::TimerEvent timer = Utils::Timer::GetInstance().QueueCallback(callback,
        TimeoutDelta);

    _requests[id] = QSharedPointer<RequestState>(
        new RequestState(to, cb, ctime, timer, timeout));
    QVariantList container = Request::BuildRequest(id, method, data);

    QByteArray msg;
    QDataStream stream(&msg, QIODevice::WriteOnly);
    stream << container;
    qDebug() << "RpcHandler: Sending request" << id << "for" << method <<
      "to" << to->ToString();
    to->Send(msg);
    return id;
  }