[native] Make manage links modal consistent with web
ClosedPublic
Actions

	#pragma once			#pragma once

				#include "BaseReactor.h"

	#include <grpcpp/grpcpp.h>			#include <grpcpp/grpcpp.h>

	namespace comm {			namespace comm {
	namespace network {			namespace network {
	namespace reactor {			namespace reactor {

	template <class Request, class Response>			template <class Request, class Response>
	class ClientBidiReactorBase			class ClientBidiReactorBase : public grpc::ClientBidiReactor<Request, Response>,
	: public grpc::ClientBidiReactor<Request, Response> {			public BaseReactor {
				std::shared_ptr<ReactorUtility> utility;
	std::shared_ptr<Response> response = nullptr;			std::shared_ptr<Response> response = nullptr;
	bool terminated = false;
	bool done = false;
	bool initialized = 0;

	void nextWrite();			void nextWrite();

	protected:			protected:
	Request request;			Request request;
	grpc::Status status = grpc::Status::OK;

	public:			public:
	grpc::ClientContext context;			grpc::ClientContext context;

	void start();			void start();
	void terminate(const grpc::Status &status);
	bool isTerminated();			void validate() override{};
	bool isDone();			void doneCallback() override{};
				void terminateCallback() override{};

	void OnWriteDone(bool ok) override;			void OnWriteDone(bool ok) override;
	void OnReadDone(bool ok) override;			void OnReadDone(bool ok) override;
				void terminate(const grpc::Status &status) override;
	void OnDone(const grpc::Status &status) override;			void OnDone(const grpc::Status &status) override;
				std::shared_ptr<ReactorUtility> getUtility() override;

	virtual std::unique_ptr<grpc::Status> prepareRequest(			virtual std::unique_ptr<grpc::Status> prepareRequest(
	Request &request,			Request &request,
	std::shared_ptr<Response> previousResponse) = 0;			std::shared_ptr<Response> previousResponse) = 0;
	virtual void validate(){};
	virtual void doneCallback(){};
	virtual void terminateCallback(){};
	};			};

	template <class Request, class Response>			template <class Request, class Response>
	void ClientBidiReactorBase<Request, Response>::nextWrite() {			void ClientBidiReactorBase<Request, Response>::nextWrite() {
	this->request = Request();			this->request = Request();
	try {			try {
	std::unique_ptr<grpc::Status> status =			std::unique_ptr<grpc::Status> status =
	this->prepareRequest(this->request, this->response);			this->prepareRequest(this->request, this->response);
	if (status != nullptr) {			if (status != nullptr) {
	this->terminate(*status);			this->terminate(*status);
	return;			return;
	}			}
	} catch (std::runtime_error &e) {			} catch (std::runtime_error &e) {
	this->terminate(grpc::Status(grpc::StatusCode::INTERNAL, e.what()));			this->terminate(grpc::Status(grpc::StatusCode::INTERNAL, e.what()));
	return;			return;
	}			}
	this->StartWrite(&this->request);			this->StartWrite(&this->request);
	if (!this->initialized) {
	this->StartCall();
	this->initialized = true;
	}
	}			}

	template <class Request, class Response>			template <class Request, class Response>
	void ClientBidiReactorBase<Request, Response>::start() {			void ClientBidiReactorBase<Request, Response>::start() {
	this->nextWrite();			if (this->utility->state != ReactorState::NONE) {
	}

	template <class Request, class Response>
	void ClientBidiReactorBase<Request, Response>::terminate(
	const grpc::Status &status) {
	if (this->status.ok()) {
	this->status = status;
	}
	if (!this->status.ok()) {
	std::cout << "error: " << this->status.error_message() << std::endl;
	}
	if (this->terminated) {
	return;			return;
	}			}
	this->terminateCallback();			this->utility->state = ReactorState::RUNNING;
	try {			this->nextWrite();
	this->validate();			this->StartCall();
	} catch (std::runtime_error &e) {
	this->status = grpc::Status(grpc::StatusCode::INTERNAL, e.what());
	}
	this->StartWritesDone();
	this->terminated = true;
	}

	template <class Request, class Response>
	bool ClientBidiReactorBase<Request, Response>::isTerminated() {
	return this->terminated;
	}

	template <class Request, class Response>
	bool ClientBidiReactorBase<Request, Response>::isDone() {
	return this->done;
	}			}

	template <class Request, class Response>			template <class Request, class Response>
	void ClientBidiReactorBase<Request, Response>::OnWriteDone(bool ok) {			void ClientBidiReactorBase<Request, Response>::OnWriteDone(bool ok) {
	if (this->response == nullptr) {			if (this->response == nullptr) {
	this->response = std::make_shared<Response>();			this->response = std::make_shared<Response>();
	}			}
	this->StartRead(&(*this->response));			this->StartRead(&(*this->response));
	}			}

	template <class Request, class Response>			template <class Request, class Response>
	void ClientBidiReactorBase<Request, Response>::OnReadDone(bool ok) {			void ClientBidiReactorBase<Request, Response>::OnReadDone(bool ok) {
	if (!ok) {			if (!ok) {
	// Ending a connection on the other side results in the `ok` flag being set			// Ending a connection on the other side results in the `ok` flag being set
	// to false. It makes it impossible to detect a failure based just on the			// to false. It makes it impossible to detect a failure based just on the
	// flag. We should manually check if the data we received is valid			// flag. We should manually check if the data we received is valid
	this->terminate(grpc::Status::OK);			this->terminate(grpc::Status::OK);
	return;			return;
	}			}
	this->nextWrite();			this->nextWrite();
	}			}

	template <class Request, class Response>			template <class Request, class Response>
				void ClientBidiReactorBase<Request, Response>::terminate(
				const grpc::Status &status) {
				if (this->utility->getStatus().ok()) {
				this->utility->setStatus(status);
				}
				if (!this->utility->getStatus().ok()) {
				std::cout << "error: " << this->utility->getStatus().error_message()
				<< std::endl;
				}
				if (this->utility->state != ReactorState::RUNNING) {
				return;
				}
				this->terminateCallback();
				try {
				this->validate();
				} catch (std::runtime_error &e) {
				this->utility->setStatus(
				grpc::Status(grpc::StatusCode::INTERNAL, e.what()));
				}
				this->StartWritesDone();
				this->utility->state = ReactorState::TERMINATED;
				}
				karolAuthorUnsubmitted Done Inline Actions In https://phabricator.ashoat.com/D3800#107105 Tomek said: It seems like we should hold a mutex for the whole duration of this function. I think it will be hard to prove that nothing could go wrong when multiple threads would concurrently set and get the status in this function. For example, one thread can enter the first if, then another thread would enter the same if, then the first thread would set a status and then the second thread would set it to a different value. karol: In https://phabricator.ashoat.com/D3800#107105 Tomek said: > It seems like we should hold a…

				template <class Request, class Response>
	void ClientBidiReactorBase<Request, Response>::OnDone(			void ClientBidiReactorBase<Request, Response>::OnDone(
	const grpc::Status &status) {			const grpc::Status &status) {
				this->utility->state = ReactorState::DONE;
	this->terminate(status);			this->terminate(status);
	this->done = true;
	this->doneCallback();			this->doneCallback();
	}			}

				template <class Request, class Response>
				std::shared_ptr<ReactorUtility>
				ClientBidiReactorBase<Request, Response>::getUtility() {
				return this->utility;
				}

	} // namespace reactor			} // namespace reactor
	} // namespace network			} // namespace network
	} // namespace comm			} // namespace comm

[native] Make manage links modal consistent with webClosedPublicActions

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 28478

native/invite-links/manage-public-link-screen.react.js

[native] Make manage links modal consistent with web
ClosedPublic
Actions

Revision Contents
Changeset List