1 2 3 4 5 6 7 8 9 10 11 12 13 14 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 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/host/corp_heartbeat_service_client.h"
#include <string_view>
#include "base/strings/stringize_macros.h"
#include "remoting/base/protobuf_http_client.h"
#include "remoting/host/host_details.h"
#include "remoting/host/version.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
namespace remoting {
CorpHeartbeatServiceClient::CorpHeartbeatServiceClient(
const std::string& directory_id,
const std::string& refresh_token,
const std::string& service_account_email,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
std::unique_ptr<net::ClientCertStore> client_cert_store)
: directory_id_(directory_id),
client_(refresh_token,
service_account_email,
url_loader_factory,
std::move(client_cert_store)) {}
CorpHeartbeatServiceClient::~CorpHeartbeatServiceClient() = default;
void CorpHeartbeatServiceClient::SendFullHeartbeat(
bool is_initial_heartbeat,
std::optional<std::string> signaling_id,
std::optional<std::string> offline_reason,
HeartbeatResponseCallback callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (offline_reason.has_value() && !offline_reason->empty()) {
// We ignore 'is_initial_heartbeat' because the host is offline so we're
// just updating the Directory to indicate that, we don't need to send a
// heartbeat afterwards.
MakeUpdateRemoteAccessHostCall(
signaling_id, offline_reason,
base::BindOnce(&CorpHeartbeatServiceClient::OnReportHostOffline,
weak_factory_.GetWeakPtr(), std::move(callback)));
} else if (is_initial_heartbeat) {
MakeUpdateRemoteAccessHostCall(
signaling_id, offline_reason,
base::BindOnce(
&CorpHeartbeatServiceClient::OnUpdateRemoteAccessHostResponse,
weak_factory_.GetWeakPtr(), std::move(callback)));
} else {
SendLiteHeartbeat(std::move(callback));
}
}
void CorpHeartbeatServiceClient::SendLiteHeartbeat(
HeartbeatResponseCallback callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
client_.SendHeartbeat(
directory_id_,
base::BindOnce(&CorpHeartbeatServiceClient::OnSendHeartbeatResponse,
weak_factory_.GetWeakPtr(), std::move(callback)));
}
void CorpHeartbeatServiceClient::CancelPendingRequests() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
client_.CancelPendingRequests();
}
void CorpHeartbeatServiceClient::OnSendHeartbeatResponse(
HeartbeatResponseCallback callback,
const HttpStatus& status,
std::unique_ptr<Empty>) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
RunHeartbeatResponseCallback(std::move(callback), status);
}
void CorpHeartbeatServiceClient::OnUpdateRemoteAccessHostResponse(
HeartbeatResponseCallback callback,
const HttpStatus& status,
std::unique_ptr<internal::RemoteAccessHostV1Proto>) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (status.ok()) {
SendLiteHeartbeat(std::move(callback));
} else {
RunHeartbeatResponseCallback(std::move(callback), status);
}
}
void CorpHeartbeatServiceClient::OnReportHostOffline(
HeartbeatResponseCallback callback,
const HttpStatus& status,
std::unique_ptr<internal::RemoteAccessHostV1Proto>) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
RunHeartbeatResponseCallback(std::move(callback), status);
}
void CorpHeartbeatServiceClient::MakeUpdateRemoteAccessHostCall(
std::optional<std::string> signaling_id,
std::optional<std::string> offline_reason,
CorpServiceClient::UpdateRemoteAccessHostCallback callback) {
constexpr char kHostVersion[] = STRINGIZE(VERSION);
client_.UpdateRemoteAccessHost(directory_id_, kHostVersion, signaling_id,
offline_reason, GetHostOperatingSystemName(),
GetHostOperatingSystemVersion(),
std::move(callback));
}
void CorpHeartbeatServiceClient::RunHeartbeatResponseCallback(
HeartbeatResponseCallback callback,
const HttpStatus& status) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!status.ok()) {
OnError(std::move(callback), status);
return;
}
// TODO: joedow - Return wait interval from the service and pass it through.
// TODO: joedow - Return primary email from the service and pass it through.
std::move(callback).Run(status, /*wait_interval=*/std::nullopt,
/*primary_user_email=*/"",
/*require_session_authorization=*/std::nullopt,
/*use_lite_heartbeat=*/true);
}
} // namespace remoting
|