diff options
Diffstat (limited to 'cpp/test/uwp/controller/ControllerView.xaml.cpp')
| -rw-r--r-- | cpp/test/uwp/controller/ControllerView.xaml.cpp | 517 |
1 files changed, 517 insertions, 0 deletions
diff --git a/cpp/test/uwp/controller/ControllerView.xaml.cpp b/cpp/test/uwp/controller/ControllerView.xaml.cpp new file mode 100644 index 00000000000..9ad8b372e85 --- /dev/null +++ b/cpp/test/uwp/controller/ControllerView.xaml.cpp @@ -0,0 +1,517 @@ +// ********************************************************************** +// +// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved. +// +// This copy of Ice is licensed to you under the terms described in the +// ICE_LICENSE file included in this distribution. +// +// ********************************************************************** + +#include "ControllerView.xaml.h" + +#include <Ice/Ice.h> +#include <Controller.h> +#include <TestHelper.h> + +#include <string> +#include <iostream> +#include <memory> +#include <condition_variable> + +using namespace std; +using namespace Test; +using namespace Test::Common; + +using namespace Platform; +using namespace Windows::Foundation; +using namespace Windows::Foundation::Collections; +using namespace Windows::UI::Core; +using namespace Windows::UI::Xaml; +using namespace Windows::UI::Xaml::Controls; +using namespace Windows::UI::Xaml::Controls::Primitives; +using namespace Windows::UI::Xaml::Data; +using namespace Windows::UI::Xaml::Input; +using namespace Windows::UI::Xaml::Media; +using namespace Windows::UI::Xaml::Navigation; + +using namespace Windows::Networking::Connectivity; + +using namespace Platform::Collections; + +namespace +{ + +typedef Test::TestHelper* (*CREATE_HELPER_ENTRY_POINT)(); + +class ControllerHelperI : public Test::ControllerHelper, + public enable_shared_from_this<Test::ControllerHelper> +{ +public: + + ControllerHelperI(const string&, const StringSeq&); + + virtual bool redirect() const; + + virtual std::string getOutput() const; + virtual std::string loggerPrefix() const; + virtual void join(); + virtual void print(const std::string&); + virtual void serverReady(); + virtual void shutdown(); + + virtual int waitSuccess(int) const; + virtual void waitReady(int) const; + + void run(); + void completed(int); + +private: + + string _dll; + StringSeq _args; + bool _ready; + bool _completed; + int _status; + ostringstream _out; + thread _thread; + mutable mutex _mutex; + mutable condition_variable _condition; + // + // DLL cache + // + static std::map<std::string, HINSTANCE> _dlls; + HINSTANCE loadDll(const string&); + + unique_ptr<Test::TestHelper> _helper; +}; + +std::map<std::string, HINSTANCE> ControllerHelperI::_dlls; + +class ProcessI : public Process +{ +public: + + ProcessI(const Test::ControllerHelperPtr&); + + void waitReady(int, const Ice::Current&); + int waitSuccess(int, const Ice::Current&); + string terminate(const Ice::Current&); + +private: + + Test::ControllerHelperPtr _controllerHelper; +}; + +class ProcessControllerI : public ProcessController +{ +public: + + ProcessControllerI(ControllerView^); + shared_ptr<ProcessPrx> start(string, string, StringSeq, const Ice::Current&); + virtual string getHost(string, bool, const Ice::Current&); + +private: + + ControllerView^ _controller; + string _host; +}; + +class ControllerI +{ +public: + + ControllerI(ControllerView^); + virtual ~ControllerI(); + + void + registerProcessController(ControllerView^, + const Ice::ObjectAdapterPtr&, + const shared_ptr<ProcessControllerRegistryPrx>&, + const shared_ptr<ProcessControllerPrx>&); + +private: + + shared_ptr<Ice::Communicator> _communicator; + shared_ptr<Test::Common::ProcessControllerRegistryPrx> _registry; +}; + +} + +ControllerHelperI::ControllerHelperI(const string& dll, const StringSeq& args) : + _dll(dll), + _args(args), + _ready(false), + _completed(false), + _status(0) +{ +} + +void +ControllerHelperI::serverReady() +{ + unique_lock<mutex> lock(_mutex); + _ready = true; + _condition.notify_all(); +} + +bool +ControllerHelperI::redirect() const +{ + return _dll.find("client") != string::npos || _dll.find("collocated") != string::npos; +} + +void + +ControllerHelperI::print(const std::string& msg) +{ + _out << msg; +} + +void +ControllerHelperI::run() +{ + thread t([this]() + { + HINSTANCE hnd = loadDll(_dll); + if(hnd == 0) + { + ostringstream os; + os << "failed to load `" << _dll << "': error code: " << GetLastError(); + print(os.str()); + completed(1); + return; + } + + FARPROC sym = GetProcAddress(hnd, "createHelper"); + if(sym == 0) + { + print("failed to find createHelper function from `" + _dll + "'"); + completed(1); + return; + } + + CREATE_HELPER_ENTRY_POINT createHelper = reinterpret_cast<CREATE_HELPER_ENTRY_POINT>(sym); + char** argv = new char*[_args.size() + 1]; + for(unsigned int i = 0; i < _args.size(); ++i) + { + argv[i] = const_cast<char*>(_args[i].c_str()); + } + argv[_args.size()] = 0; + try + { + StreamHelper streamHelper(shared_from_this(), redirect()); + _helper.reset(createHelper()); + _helper->setControllerHelper(shared_from_this()); + _helper->run(static_cast<int>(_args.size()), argv); + completed(0); + } + catch(const std::exception& ex) + { + print("unexpected exception while running `" + _args[0] + "':\n" + ex.what()); + completed(1); + } + catch(...) + { + print("unexpected unknown exception while running `" + _args[0] + "'"); + completed(1); + } + delete[] argv; + }); + _thread = move(t); +} + +void +ControllerHelperI::join() +{ + _thread.join(); +} + +void +ControllerHelperI::completed(int status) +{ + unique_lock<mutex> lock(_mutex); + _completed = true; + _status = status; + _condition.notify_all(); +} + +void +ControllerHelperI::waitReady(int timeout) const +{ + unique_lock<mutex> lock(_mutex); + while(!_ready && !_completed) + { + if(_condition.wait_for(lock, chrono::seconds(timeout)) == cv_status::timeout) + { + throw ProcessFailedException("timed out waiting for the process to be ready"); + } + } + if(_completed && _status == EXIT_FAILURE) + { + throw ProcessFailedException(_out.str()); + } +} + +int +ControllerHelperI::waitSuccess(int timeout) const +{ + unique_lock<mutex> lock(_mutex); + while(!_completed) + { + if(_condition.wait_for(lock, chrono::seconds(timeout)) == cv_status::timeout) + { + throw ProcessFailedException("timed out waiting for the process to succeed"); + } + } + return _status; +} + +string +ControllerHelperI::getOutput() const +{ + assert(_completed); + return _out.str(); +} + +string +ControllerHelperI::loggerPrefix() const +{ + return _dll; +} + +void +ControllerHelperI::shutdown() +{ + unique_lock<mutex> lock(_mutex); + if(_completed) + { + return; + } + + if(_helper) + { + Ice::CommunicatorPtr communicator = _helper->communicator(); + if(communicator) + { + communicator->shutdown(); + } + } +} + +HINSTANCE +ControllerHelperI::loadDll(const string& name) +{ + unique_lock<mutex> lock(_mutex); + map<string, HINSTANCE>::iterator p = _dlls.find(name); + if (p == _dlls.end()) + { + HINSTANCE hnd = LoadPackagedLibrary(Ice::stringToWstring(name).c_str(), 0); + p = _dlls.insert(make_pair(name, hnd)).first; + } + return p->second; +} + +ProcessI::ProcessI(const ControllerHelperPtr& controllerHelper) : + _controllerHelper(controllerHelper) +{ +} + +void +ProcessI::waitReady(int timeout, const Ice::Current&) +{ + _controllerHelper->waitReady(timeout); +} + +int +ProcessI::waitSuccess(int timeout, const Ice::Current&) +{ + return _controllerHelper->waitSuccess(timeout); +} + +string +ProcessI::terminate(const Ice::Current& current) +{ + _controllerHelper->shutdown(); + current.adapter->remove(current.id); + _controllerHelper->join(); + return _controllerHelper->getOutput(); +} + +ProcessControllerI::ProcessControllerI(ControllerView^ controller) : + _controller(controller), + _host(_controller->getHost()) +{ +} + +shared_ptr<ProcessPrx> +ProcessControllerI::start(string testSuite, string exe, StringSeq args, const Ice::Current& c) +{ + ostringstream os; + os << "starting " << testSuite << " " << exe << "... "; + _controller->println(os.str()); + replace(testSuite.begin(), testSuite.end(), '/', '_'); + args.insert(args.begin(), testSuite + '_' + exe + ".dll"); + auto helper = make_shared<ControllerHelperI>(testSuite + '_' + exe + ".dll", args); + helper->run(); + return Ice::uncheckedCast<ProcessPrx>(c.adapter->addWithUUID(make_shared<ProcessI>(helper))); +} + +string +ProcessControllerI::getHost(string, bool, const Ice::Current&) +{ + return _host; +} + +ControllerI::ControllerI(ControllerView^ controller) +{ + Ice::InitializationData initData = Ice::InitializationData(); + initData.properties = Ice::createProperties(); + initData.properties->setProperty("Ice.ThreadPool.Client.SizeMax", "10"); + initData.properties->setProperty("Ice.Default.Host", "127.0.0.1"); + initData.properties->setProperty("Ice.Override.ConnectTimeout", "1000"); + //initData.properties->setProperty("Ice.Trace.Network", "3"); + //initData.properties->setProperty("Ice.Trace.Protocol", "1"); + initData.properties->setProperty("ControllerAdapter.AdapterId", Ice::generateUUID()); + + _communicator = Ice::initialize(initData); + + auto registry = Ice::uncheckedCast<ProcessControllerRegistryPrx>( + _communicator->stringToProxy("Util/ProcessControllerRegistry:tcp -h 127.0.0.1 -p 15001")); + Ice::ObjectAdapterPtr adapter = _communicator->createObjectAdapterWithEndpoints("ControllerAdapter", ""); + Ice::Identity ident = { "ProcessController", "UWP"}; + auto processController = + Ice::uncheckedCast<ProcessControllerPrx>(adapter->add(make_shared<ProcessControllerI>(controller), ident)); + adapter->activate(); + + registerProcessController(controller, adapter, registry, processController); +} + +void +ControllerI::registerProcessController(ControllerView^ controller, + const Ice::ObjectAdapterPtr& adapter, + const shared_ptr<ProcessControllerRegistryPrx>& registry, + const shared_ptr<ProcessControllerPrx>& processController) +{ + registry->ice_pingAsync( + [this, controller, adapter, registry, processController]() + { + auto connection = registry->ice_getCachedConnection(); + connection->setAdapter(adapter); + connection->setACM(5, Ice::ACMClose::CloseOff, Ice::ACMHeartbeat::HeartbeatAlways); + connection->setCloseCallback([=](const shared_ptr<Ice::Connection>&) + { + controller->println("connection with process controller registry closed"); + std::this_thread::sleep_for(2s); + registerProcessController(controller, adapter, registry, processController); + }); + + registry->setProcessControllerAsync(processController, nullptr, + [controller](exception_ptr e) + { + try + { + rethrow_exception(e); + } + catch(const Ice::CommunicatorDestroyedException&) + { + } + catch(const std::exception& ex) + { + ostringstream os; + os << "unexpected exception while connecting to process controller registry:\n" << ex.what(); + controller->println(os.str()); + } + }); + }, + [this, controller, adapter, registry, processController](exception_ptr e) + { + try + { + rethrow_exception(e); + } + catch(const Ice::ConnectFailedException&) + { + std::this_thread::sleep_for(2s); + registerProcessController(controller, adapter, registry, processController); + } + catch(const Ice::TimeoutException&) + { + std::this_thread::sleep_for(2s); + registerProcessController(controller, adapter, registry, processController); + } + catch(const Ice::CommunicatorDestroyedException&) + { + } + catch(const std::exception& ex) + { + ostringstream os; + os << "unexpected exception while connecting to process controller registry:\n" << ex.what(); + controller->println(os.str()); + } + }); +} + +ControllerI::~ControllerI() +{ + _communicator->destroy(); +} + +static ControllerI* controllerI = 0; + +ControllerView::ControllerView() +{ + InitializeComponent(); + auto hostnames = NetworkInformation::GetHostNames(); + ipv4Addresses->Items->Append("127.0.0.1"); + for(unsigned int i = 0; i < hostnames->Size; ++i) + { + auto hostname = hostnames->GetAt(i); + if(hostname->Type == Windows::Networking::HostNameType::Ipv4) + { + ipv4Addresses->Items->Append(hostname->RawName); + } + } + ipv4Addresses->SelectedIndex = 0; +} + +string +ControllerView::getHost() const +{ + return Ice::wstringToString(ipv4Addresses->SelectedItem->ToString()->Data()); +} + +void +ControllerView::Hostname_SelectionChanged(Platform::Object^, Windows::UI::Xaml::Controls::SelectionChangedEventArgs^) +{ + if(controllerI) + { + delete controllerI; + controllerI = 0; + } + controllerI = new ControllerI(this); +} + +void +ControllerView::println(const string& s) +{ + if(!s.empty()) + { + Dispatcher->RunAsync( + CoreDispatcherPriority::Normal, + ref new DispatchedHandler([=]() + { + Output->Items->Append(ref new String(Ice::stringToWstring(s).c_str())); + Output->SelectedIndex = Output->Items->Size - 1; + Output->ScrollIntoView(Output->SelectedItem); + })); + } +} + +ControllerView::~ControllerView() +{ + if(controllerI) + { + delete controllerI; + controllerI = 0; + } +} |