Skip to content

GitLab

T
tangled
Commit 2126e939 authored by Timothy Loh's avatar Timothy Loh Committed by Commit Bot
Browse files
Options

Reduce copy-paste in concierge_client.cc 

This CL reduces the code duplication for calling DBus methods in
concierge_client.cc.

Change-Id: Id5a9ca03f7faad049460f047c6f1ca63c2ea847f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1778442Reviewed-by: default avatarSteven Bennetts <stevenjb@chromium.org>
Commit-Queue: Timothy Loh <timloh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#692976}
parent a025aa6c
Hide whitespace changes
Inline Side-by-side
Showing with 41 additions and 248 deletions
chromeos/dbus/concierge_client.cc
View file @ 2126e939
...@@ -18,6 +18,8 @@ ...@@ -18,6 +18,8 @@
namespace chromeos { namespace chromeos {
using namespace vm_tools::concierge;
class ConciergeClientImpl : public ConciergeClient { class ConciergeClientImpl : public ConciergeClient {
public: public:
ConciergeClientImpl() {} ConciergeClientImpl() {}
...@@ -52,44 +54,14 @@ class ConciergeClientImpl : public ConciergeClient { ...@@ -52,44 +54,14 @@ class ConciergeClientImpl : public ConciergeClient {
const vm_tools::concierge::CreateDiskImageRequest& request, const vm_tools::concierge::CreateDiskImageRequest& request,
DBusMethodCallback<vm_tools::concierge::CreateDiskImageResponse> callback) DBusMethodCallback<vm_tools::concierge::CreateDiskImageResponse> callback)
override { override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kCreateDiskImageMethod, request, std::move(callback));
vm_tools::concierge::kCreateDiskImageMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode CreateDiskImageRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::CreateDiskImageResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void DestroyDiskImage( void DestroyDiskImage(
const vm_tools::concierge::DestroyDiskImageRequest& request, const vm_tools::concierge::DestroyDiskImageRequest& request,
DBusMethodCallback<vm_tools::concierge::DestroyDiskImageResponse> DBusMethodCallback<vm_tools::concierge::DestroyDiskImageResponse>
callback) override { callback) override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kDestroyDiskImageMethod, request, std::move(callback));
vm_tools::concierge::kDestroyDiskImageMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode DestroyDiskImageRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::DestroyDiskImageResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void ImportDiskImage( void ImportDiskImage(
...@@ -121,131 +93,41 @@ class ConciergeClientImpl : public ConciergeClient { ...@@ -121,131 +93,41 @@ class ConciergeClientImpl : public ConciergeClient {
const vm_tools::concierge::CancelDiskImageRequest& request, const vm_tools::concierge::CancelDiskImageRequest& request,
DBusMethodCallback<vm_tools::concierge::CancelDiskImageResponse> callback) DBusMethodCallback<vm_tools::concierge::CancelDiskImageResponse> callback)
override { override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kCancelDiskImageMethod, request, std::move(callback));
vm_tools::concierge::kCancelDiskImageMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode CancelDiskImageRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::CancelDiskImageResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void DiskImageStatus( void DiskImageStatus(
const vm_tools::concierge::DiskImageStatusRequest& request, const vm_tools::concierge::DiskImageStatusRequest& request,
DBusMethodCallback<vm_tools::concierge::DiskImageStatusResponse> callback) DBusMethodCallback<vm_tools::concierge::DiskImageStatusResponse> callback)
override { override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kDiskImageStatusMethod, request, std::move(callback));
vm_tools::concierge::kDiskImageStatusMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode DiskImageStatusRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::DiskImageStatusResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void ListVmDisks(const vm_tools::concierge::ListVmDisksRequest& request, void ListVmDisks(const vm_tools::concierge::ListVmDisksRequest& request,
DBusMethodCallback<vm_tools::concierge::ListVmDisksResponse> DBusMethodCallback<vm_tools::concierge::ListVmDisksResponse>
callback) override { callback) override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kListVmDisksMethod, request, std::move(callback));
vm_tools::concierge::kListVmDisksMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode ListVmDisksRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::ListVmDisksResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void StartTerminaVm(const vm_tools::concierge::StartVmRequest& request, void StartTerminaVm(const vm_tools::concierge::StartVmRequest& request,
DBusMethodCallback<vm_tools::concierge::StartVmResponse> DBusMethodCallback<vm_tools::concierge::StartVmResponse>
callback) override { callback) override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface,
vm_tools::concierge::kStartVmMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode StartVmRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
// TODO(nverne): revert to TIMEOUT_USE_DEFAULT when StartVm no longer // TODO(nverne): revert to TIMEOUT_USE_DEFAULT when StartVm no longer
// requires unnecessary long running crypto calculations. // requires unnecessary long running crypto calculations.
constexpr int kStartVmTimeoutMs = 160 * 1000; constexpr int kStartVmTimeoutMs = 160 * 1000;
concierge_proxy_->CallMethod( CallMethod(kStartVmMethod, request, std::move(callback), kStartVmTimeoutMs);
&method_call, kStartVmTimeoutMs,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::StartVmResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void StopVm(const vm_tools::concierge::StopVmRequest& request, void StopVm(const vm_tools::concierge::StopVmRequest& request,
DBusMethodCallback<vm_tools::concierge::StopVmResponse> callback) DBusMethodCallback<vm_tools::concierge::StopVmResponse> callback)
override { override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kStopVmMethod, request, std::move(callback));
vm_tools::concierge::kStopVmMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode StopVmRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::StopVmResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void GetVmInfo(const vm_tools::concierge::GetVmInfoRequest& request, void GetVmInfo(const vm_tools::concierge::GetVmInfoRequest& request,
DBusMethodCallback<vm_tools::concierge::GetVmInfoResponse> DBusMethodCallback<vm_tools::concierge::GetVmInfoResponse>
callback) override { callback) override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kGetVmInfoMethod, request, std::move(callback));
vm_tools::concierge::kGetVmInfoMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode GetVmInfoRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::GetVmInfoResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void GetVmEnterpriseReportingInfo( void GetVmEnterpriseReportingInfo(
...@@ -253,48 +135,15 @@ class ConciergeClientImpl : public ConciergeClient { ...@@ -253,48 +135,15 @@ class ConciergeClientImpl : public ConciergeClient {
DBusMethodCallback< DBusMethodCallback<
vm_tools::concierge::GetVmEnterpriseReportingInfoResponse> callback) vm_tools::concierge::GetVmEnterpriseReportingInfoResponse> callback)
override { override {
dbus::MethodCall method_call( CallMethod(kGetVmEnterpriseReportingInfoMethod, request,
vm_tools::concierge::kVmConciergeInterface, std::move(callback));
vm_tools::concierge::kGetVmEnterpriseReportingInfoMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR)
<< "Failed to encode GetVmEnterpriseReportingInfoRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(
&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::GetVmEnterpriseReportingInfoResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void SetVmCpuRestriction( void SetVmCpuRestriction(
const vm_tools::concierge::SetVmCpuRestrictionRequest& request, const vm_tools::concierge::SetVmCpuRestrictionRequest& request,
DBusMethodCallback<vm_tools::concierge::SetVmCpuRestrictionResponse> DBusMethodCallback<vm_tools::concierge::SetVmCpuRestrictionResponse>
callback) override { callback) override {
dbus::MethodCall method_call( CallMethod(kSetVmCpuRestrictionMethod, request, std::move(callback));
vm_tools::concierge::kVmConciergeInterface,
vm_tools::concierge::kSetVmCpuRestrictionMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode SetVmCpuRestrictionRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::SetVmCpuRestrictionResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void WaitForServiceToBeAvailable( void WaitForServiceToBeAvailable(
...@@ -307,112 +156,35 @@ class ConciergeClientImpl : public ConciergeClient { ...@@ -307,112 +156,35 @@ class ConciergeClientImpl : public ConciergeClient {
const vm_tools::concierge::ContainerSshKeysRequest& request, const vm_tools::concierge::ContainerSshKeysRequest& request,
DBusMethodCallback<vm_tools::concierge::ContainerSshKeysResponse> DBusMethodCallback<vm_tools::concierge::ContainerSshKeysResponse>
callback) override { callback) override {
dbus::MethodCall method_call( CallMethod(kGetContainerSshKeysMethod, request, std::move(callback));
vm_tools::concierge::kVmConciergeInterface,
vm_tools::concierge::kGetContainerSshKeysMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode ContainerSshKeysRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::ContainerSshKeysResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void AttachUsbDevice(base::ScopedFD fd, void AttachUsbDevice(
base::ScopedFD fd,
const vm_tools::concierge::AttachUsbDeviceRequest& request, const vm_tools::concierge::AttachUsbDeviceRequest& request,
DBusMethodCallback<vm_tools::concierge::AttachUsbDeviceResponse> callback) DBusMethodCallback<vm_tools::concierge::AttachUsbDeviceResponse> callback)
override { override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kAttachUsbDeviceMethod, request, std::move(callback));
vm_tools::concierge::kAttachUsbDeviceMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode AttachUsbDeviceRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
writer.AppendFileDescriptor(fd.get());
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::AttachUsbDeviceResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void DetachUsbDevice( void DetachUsbDevice(
const vm_tools::concierge::DetachUsbDeviceRequest& request, const vm_tools::concierge::DetachUsbDeviceRequest& request,
DBusMethodCallback<vm_tools::concierge::DetachUsbDeviceResponse> callback) DBusMethodCallback<vm_tools::concierge::DetachUsbDeviceResponse> callback)
override { override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kDetachUsbDeviceMethod, request, std::move(callback));
vm_tools::concierge::kDetachUsbDeviceMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode DetachUsbDeviceRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::DetachUsbDeviceResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void ListUsbDevices( void ListUsbDevices(
const vm_tools::concierge::ListUsbDeviceRequest& request, const vm_tools::concierge::ListUsbDeviceRequest& request,
DBusMethodCallback<vm_tools::concierge::ListUsbDeviceResponse> callback) DBusMethodCallback<vm_tools::concierge::ListUsbDeviceResponse> callback)
override { override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kListUsbDeviceMethod, request, std::move(callback));
vm_tools::concierge::kListUsbDeviceMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode ListUsbDeviceRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::ListUsbDeviceResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
void StartArcVm(const vm_tools::concierge::StartArcVmRequest& request, void StartArcVm(const vm_tools::concierge::StartArcVmRequest& request,
DBusMethodCallback<vm_tools::concierge::StartVmResponse> DBusMethodCallback<vm_tools::concierge::StartVmResponse>
callback) override { callback) override {
dbus::MethodCall method_call(vm_tools::concierge::kVmConciergeInterface, CallMethod(kStartArcVmMethod, request, std::move(callback));
vm_tools::concierge::kStartArcVmMethod);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode StartArcVmRequest protobuf";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<
vm_tools::concierge::StartVmResponse>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
} }
protected: protected:
...@@ -442,6 +214,27 @@ class ConciergeClientImpl : public ConciergeClient { ...@@ -442,6 +214,27 @@ class ConciergeClientImpl : public ConciergeClient {
} }
private: private:
template <typename RequestProto, typename ResponseProto>
void CallMethod(const std::string& method_name,
const RequestProto& request,
DBusMethodCallback<ResponseProto> callback,
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) {
dbus::MethodCall method_call(kVmConciergeInterface, method_name);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to encode protobuf for " << method_name;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
return;
}
concierge_proxy_->CallMethod(
&method_call, timeout_ms,
base::BindOnce(&ConciergeClientImpl::OnDBusProtoResponse<ResponseProto>,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
template <typename ResponseProto> template <typename ResponseProto>
void OnDBusProtoResponse(DBusMethodCallback<ResponseProto> callback, void OnDBusProtoResponse(DBusMethodCallback<ResponseProto> callback,
dbus::Response* dbus_response) { dbus::Response* dbus_response) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment