Пример #1
0
bool RedisClient::SshTransporter::connectToHost()
{
    ConnectionConfig config = m_connection->getConfig();

    if (config.isSshPasswordUsed())
        m_sshClient->setPassphrase(config.sshPassword());

    QString privateKey = config.getSshPrivateKey();

    if (!privateKey.isEmpty()) {
        m_sshClient->setKeyFiles("", privateKey);
    }    

    //connect to ssh server
    SignalWaiter waiter(config.connectionTimeout());
    waiter.addAbortSignal(this, &RedisClient::SshTransporter::errorOccurred);
    waiter.addSuccessSignal(m_sshClient.data(), &QxtSshClient::connected);

    emit logEvent("Connecting to SSH host...");

    m_sshClient->connectToHost(config.sshUser(), config.sshHost(), config.sshPort());

    if (!waiter.wait()) {
        emit errorOccurred("Cannot connect to SSH host");
        return false;
    }

    emit logEvent("SSH tunnel established. Connecting to redis-server...");    

    return openTcpSocket();
}
Пример #2
0
bool CGUIDialogBusy::Wait(IRunnable *runnable, unsigned int displaytime /* = 100 */, bool allowCancel /* = true */)
{
  if (!runnable)
    return false;
  CBusyWaiter waiter(runnable);
  return waiter.Wait(displaytime, allowCancel);
}
Пример #3
0
CDataHistoryInfo CDataFeed::GetQuoteHistoryFiles(const string& symbol, bool includeLevel2, CDateTime time, const uint32 timeoutInMilliseconds)
{
	Waiter<CFxDataHistoryResponse> waiter(timeoutInMilliseconds, cExternalSynchCall, *this);

	CFxDataHistoryRequest request(symbol);
	request.BarsNumber = 0;
	request.Time = time;
	request.PriceType = FxPriceType_None;
	request.ReportType = FX_REPORT_TYPE_FILE;
	request.GraphType = includeLevel2 ? FX_GRAPH_TYPE_LEVEL2 : FX_GRAPH_TYPE_TICKS;
	m_sender->VSendDataHistoryRequest(waiter.Id(), request);

	CFxDataHistoryResponse response = waiter.WaitForResponse();

	CDataHistoryInfo result;
	std::swap(result.Files, response.Files);
	if ((response.From > time) || (response.To < time))
	{
		result.Files.clear();
	}
	result.FromAll = response.FromAll;
	result.ToAll = response.ToAll;
	if (!result.Files.empty())
	{
		result.From = response.From;
		result.To = response.To;
	}
	std::swap(result.LastTickId, response.LastTickId);

	return result;
}
Пример #4
0
bool wait_queue_t::wait(duration_t* timeout) {
	if(FIBER_IMPL) {
		fiber_waiter_t waiter(FIBER_IMPL, SCHEDULER_IMPL);
		waiters_.push_back(waiter);

		auto wait_res = SCHEDULER_IMPL->wait_queue(lock_, timeout);

		waiters_.erase(waiters_.iterator_to(waiter));

		if(waiter.wakeup_next)
			notify_one();

		return wait_res == scheduler_impl_t::READY;
	} else {
		native_waiter_t waiter;
		waiter.queue_lock = lock_;

		waiters_.push_back(waiter);

		bool wait_successfull = waiter.wait(timeout);

		waiters_.erase(waiters_.iterator_to(waiter));

		if(waiter.wakeup_next)
			notify_one();

		return wait_successfull;
	}
}
Пример #5
0
int Socket::Read(ByteArray & buffer)
{
    char raw[MAX_BUFFER_SIZE];
    if (!open)
        return 0;

    buffer.v.clear();
    // Allow interruption of block.
    FlexWait waiter(2,this,&terminator);
    Blockable * result = waiter.Wait();
    // This happens if the call was shutdown on this side
    if (result == &terminator)
    {
        terminator.Reset();
        return 0;
    }
    // If we got here, we need to read the socket
    // Messages greater than MAX_BUFFER_SIZE are not handled gracefully.
    ssize_t received = recv(GetFD(), raw, MAX_BUFFER_SIZE, 0);
    for (int i=0;i<received;i++)
        buffer.v.push_back(raw[i]);
    if (received <=0)
        open = false;
    return received;
}
Пример #6
0
CDataHistoryInfo CDataFeed::GetBarsHistoryFiles(const string& symbol, int32 priceType, const string& period, CDateTime time, uint32 timeoutInMilliseconds)
{
	Waiter<CFxDataHistoryResponse> waiter(timeoutInMilliseconds, cExternalSynchCall, *this);

	CFxDataHistoryRequest request(symbol, period);
	request.BarsNumber = 0;
	request.Time = time;
	request.PriceType = priceType;
	request.ReportType = FX_REPORT_TYPE_FILE;
	request.GraphType = FX_GRAPH_TYPE_BARS;
	m_sender->VSendDataHistoryRequest(waiter.Id(), request);

	CFxDataHistoryResponse response = waiter.WaitForResponse();

	CDataHistoryInfo result;

	std::swap(result.Files, response.Files);

	result.FromAll = response.FromAll;
	result.ToAll = response.ToAll;
	if (!result.Files.empty())
	{
		result.From = response.From;
		result.To = response.To;
	}
	result.LastTickId = response.LastTickId;

	return result;
}
// Check that initialization / destruction works without crashing.
TEST(SocketWaiter, init) {
    ScopedPtr<SocketWaiter> waiter(SocketWaiter::create());

    unsigned events = ~0U;
    EXPECT_EQ(-1, waiter->nextPendingFd(&events));
    EXPECT_EQ(0, events);
}
TEST(SocketWaiter, update) {
    ScopedPtr<SocketWaiter> waiter(SocketWaiter::create());

    int s1, s2;

    ASSERT_EQ(0, socketCreatePair(&s1, &s2));

    waiter->update(s1, SocketWaiter::kEventRead);
    waiter->update(s2, SocketWaiter::kEventWrite);
    EXPECT_TRUE(waiter->hasFds());
    EXPECT_EQ(SocketWaiter::kEventRead, waiter->wantedEventsFor(s1));
    EXPECT_EQ(SocketWaiter::kEventWrite, waiter->wantedEventsFor(s2));

    waiter->update(s1, SocketWaiter::kEventWrite);
    waiter->update(s2, SocketWaiter::kEventRead);
    EXPECT_TRUE(waiter->hasFds());
    EXPECT_EQ(SocketWaiter::kEventWrite, waiter->wantedEventsFor(s1));
    EXPECT_EQ(SocketWaiter::kEventRead, waiter->wantedEventsFor(s2));

    waiter->update(s1, SocketWaiter::kEventRead | SocketWaiter::kEventWrite);
    waiter->update(s2, SocketWaiter::kEventRead | SocketWaiter::kEventWrite);
    EXPECT_TRUE(waiter->hasFds());
    EXPECT_EQ(SocketWaiter::kEventRead | SocketWaiter::kEventWrite,
              waiter->wantedEventsFor(s1));
    EXPECT_EQ(SocketWaiter::kEventRead | SocketWaiter::kEventWrite,
              waiter->wantedEventsFor(s2));

    waiter->reset();

    EXPECT_FALSE(waiter->hasFds());
    EXPECT_EQ(0U, waiter->wantedEventsFor(s1));
    EXPECT_EQ(0U, waiter->wantedEventsFor(s2));
}
Пример #9
0
bool CGUIDialogBusy::Wait(IRunnable *runnable)
{
  if (!runnable)
    return false;
  CBusyWaiter waiter(runnable);
  return waiter.Wait();
}
Пример #10
0
string CDataFeed::GetTicksHistoryMetaInfoFile(const string& symbol, bool includeLevel2, const uint32 timeoutInMilliseconds)
{
	Waiter<string> waiter(timeoutInMilliseconds, cExternalSynchCall, *this);
	m_sender->VSendGetTicksHistoryMetaInfoFile(waiter.Id(), symbol, includeLevel2);
	string result = waiter.WaitForResponse();
	return result;
}
Пример #11
0
s32 sceKernelWaitEventFlag(ARMv7Thread& context, s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32> pResultPat, vm::ptr<u32> pTimeout)
{
	sceLibKernel.Error("sceKernelWaitEventFlag(evfId=0x%x, bitPattern=0x%x, waitMode=0x%x, pResultPat=*0x%x, pTimeout=*0x%x)", evfId, bitPattern, waitMode, pResultPat, pTimeout);

	const u64 start_time = pTimeout ? get_system_time() : 0;
	const u32 timeout = pTimeout ? pTimeout->value() : 0;

	const auto evf = idm::get<psv_event_flag_t>(evfId);

	if (!evf)
	{
		return SCE_KERNEL_ERROR_INVALID_UID;
	}

	std::unique_lock<std::mutex> lock(evf->mutex);

	const u32 result = evf->pattern.atomic_op(event_flag_try_poll, bitPattern, waitMode);

	if (event_flag_test(result, bitPattern, waitMode))
	{
		if (pResultPat) *pResultPat = result;

		return SCE_OK;
	}

	// fixup register values for external use
	context.GPR[1] = bitPattern;
	context.GPR[2] = waitMode;

	// add waiter; attributes are ignored in current implementation
	sleep_queue_entry_t waiter(context, evf->sq);

	while (!context.unsignal())
	{
		CHECK_EMU_STATUS;

		if (pTimeout)
		{
			const u64 passed = get_system_time() - start_time;

			if (passed >= timeout)
			{
				context.GPR[0] = SCE_KERNEL_ERROR_WAIT_TIMEOUT;
				context.GPR[1] = evf->pattern;
				break;
			}

			context.cv.wait_for(lock, std::chrono::microseconds(timeout - passed));
		}
		else
		{
			context.cv.wait(lock);
		}
	}

	if (pResultPat) *pResultPat = context.GPR[1];
	if (pTimeout) *pTimeout = static_cast<u32>(std::max<s64>(0, timeout - (get_system_time() - start_time)));

	return context.GPR[0];
}
Пример #12
0
s32 _sys_lwcond_queue_wait(PPUThread& ppu, u32 lwcond_id, u32 lwmutex_id, u64 timeout)
{
	sys_lwcond.Log("_sys_lwcond_queue_wait(lwcond_id=0x%x, lwmutex_id=0x%x, timeout=0x%llx)", lwcond_id, lwmutex_id, timeout);

	const u64 start_time = get_system_time();

	LV2_LOCK;

	const auto cond = idm::get<lv2_lwcond_t>(lwcond_id);
	const auto mutex = idm::get<lv2_lwmutex_t>(lwmutex_id);

	if (!cond || !mutex)
	{
		return CELL_ESRCH;
	}

	// finalize unlocking the mutex
	mutex->unlock(lv2_lock);

	// add waiter; protocol is ignored in current implementation
	sleep_queue_entry_t waiter(ppu, cond->sq);

	// potential mutex waiter (not added immediately)
	sleep_queue_entry_t mutex_waiter(ppu, cond->sq, defer_sleep);

	while (!ppu.unsignal())
	{
		CHECK_EMU_STATUS;

		if (timeout && waiter)
		{
			const u64 passed = get_system_time() - start_time;

			if (passed >= timeout)
			{
				// try to reown the mutex if timed out
				if (mutex->signaled)
				{
					mutex->signaled--;

					return CELL_EDEADLK;
				}
				else
				{
					return CELL_ETIMEDOUT;
				}
			}

			ppu.cv.wait_for(lv2_lock, std::chrono::microseconds(timeout - passed));
		}
		else
		{
			ppu.cv.wait(lv2_lock);
		}
	}

	// return cause
	return ppu.GPR[3] ? CELL_EBUSY : CELL_OK;
}
Пример #13
0
CFxAccountInfo CDataTrade::GetAccountInfo(const uint32 timeoutInMilliseconds)
{
    Waiter<CFxAccountInfo> waiter(timeoutInMilliseconds, cExternalSynchCall, *this);
    m_sender->VSendGetAccountInfo(waiter.Id());

    CFxAccountInfo result = waiter.WaitForResponse();
    return result;
}
Пример #14
0
    QScriptValue Mail::waitForEncrypted(int waitTime)
    {
        QxtSignalWaiter waiter(&mSmtp, SIGNAL(encrypted()));
        if(!waiter.wait(waitTime))
            throwError("EncryptionError", tr("Cannot encrypt the connection"));

        return thisObject();
    }
Пример #15
0
    QScriptValue Mail::waitForConnected(int waitTime)
    {
        QxtSignalWaiter waiter(&mSmtp, SIGNAL(connected()));
        if(!waiter.wait(waitTime))
            throwError("ConnectionError", tr("Cannot establish a connection to the server"));

        return thisObject();
    }
Пример #16
0
    QScriptValue Mail::waitForDisconnected(int waitTime)
    {
        QxtSignalWaiter waiter(&mSmtp, SIGNAL(disconnected()));
        if(!waiter.wait(waitTime))
            throwError("WaitForDisconnectedError", tr("Wait for disconnected failed"));

        return thisObject();
    }
Пример #17
0
    QScriptValue Mail::waitForAuthenticated(int waitTime)
    {
        QxtSignalWaiter waiter(&mSmtp, SIGNAL(authenticated()));
        if(!waiter.wait(waitTime))
            throwError("AuthenticationError", tr("Cannot authenticate to the server"));

        return thisObject();
    }
Пример #18
0
bool CDataTrade::CloseByOrders(const string& firstOrderId, const string& secondOrderId, const size_t timeoutInMilliseconds)
{
    Waiter<CFxClosePositionsResponse> waiter(static_cast<uint32>(timeoutInMilliseconds), cExternalSynchCall, *this);
    m_sender->VSendCloseByOrders(waiter.Id(), firstOrderId, secondOrderId);
    CFxClosePositionsResponse response = waiter.WaitForResponse();
    const bool result = SUCCEEDED(response.Status);
    return result;
}
Пример #19
0
vector<CFxSymbolInfo> CDataFeed::GetSupportedSymbols(uint32 timeoutInMilliseconds)
{
	Waiter<vector<CFxSymbolInfo> > waiter(timeoutInMilliseconds, cExternalSynchCall, *this);
	m_sender->VSendGetSupportedSymbols(waiter.Id());

	vector<CFxSymbolInfo> result = waiter.WaitForResponse();
	return result;
}
Пример #20
0
string CDataFeed::GetBarsHistoryMetaInfoFile(const string& symbol, FxPriceType priceType, const string& period, const uint32 timeoutInMilliseconds)
{
	Waiter<string> waiter(timeoutInMilliseconds, cExternalSynchCall, *this);
	m_sender->VSendGetBarsHistoryMetaInfoFile(waiter.Id(), symbol, priceType, period);

	string result = waiter.WaitForResponse();
	return result;
}
Пример #21
0
void wait_generic_container(Container &c) {
    multiple_waiter_t waiter(Type, c.size());
    std::vector<multiple_wait_callback_t> waits;
    waits.reserve(c.size());
    for (auto &&item : c) {
        waits.emplace_back(item, &waiter);
    }
    waiter.wait();
}
Пример #22
0
CFxSessionInfo CClient::GetSessionInfo(const size_t timeoutInMilliseconds)
{
    Waiter<CFxSessionInfo> waiter(static_cast<uint32>(timeoutInMilliseconds), cExternalSynchCall, *this);

	m_sender->VSendGetSessionInfo(waiter.Id());

	CFxSessionInfo result = waiter.WaitForResponse();
	return result;
}
Пример #23
0
CFxFileChunk CClient::GetFileChunk(const string& fileId, uint32 chunkId, const size_t timeoutInMilliseconds)
{
    Waiter<CFxFileChunk> waiter(static_cast<uint32>(timeoutInMilliseconds), cExternalSynchCall, fileId, *this);

	m_sender->VSendGetFileChunk(waiter.Id(), fileId, chunkId);

	CFxFileChunk result = waiter.WaitForResponse();
	return result;
}
Пример #24
0
HRESULT CDataFeed::UnsubscribeQuotes(const vector<string>& symbols, uint32 timeoutInMilliseconds)
{
    Waiter<HRESULT> waiter(timeoutInMilliseconds, cExternalSynchCall, *this);
    m_sender->VSendUnsubscribeQuotes(waiter.Id(), symbols);

    HRESULT result = waiter.WaitForResponse();

    return result;
}
int ConnectionWaiter::openDialog(const QString &title, const QString &labelText, int targetDeviceCount, int timeout, QWidget *parent, Qt::WindowFlags flags)
{
    TimedDialog dlg(title, labelText, timeout / 1000, parent, flags);
    ConnectionWaiter waiter(targetDeviceCount, timeout, parent);

    connect(&dlg, SIGNAL(canceled()), &waiter, SLOT(cancel()));
    connect(&waiter, SIGNAL(timeChanged(int)), &dlg, SLOT(perform()));
    return waiter.exec();
}
Пример #26
0
s32 sys_rwlock_rlock(PPUThread& ppu, u32 rw_lock_id, u64 timeout)
{
	sys_rwlock.Log("sys_rwlock_rlock(rw_lock_id=0x%x, timeout=0x%llx)", rw_lock_id, timeout);

	const u64 start_time = get_system_time();

	LV2_LOCK;

	const auto rwlock = idm::get<lv2_rwlock_t>(rw_lock_id);

	if (!rwlock)
	{
		return CELL_ESRCH;
	}

	if (!rwlock->writer && rwlock->wsq.empty())
	{
		if (!++rwlock->readers)
		{
			throw EXCEPTION("Too many readers");
		}

		return CELL_OK;
	}

	// add waiter; protocol is ignored in current implementation
	sleep_queue_entry_t waiter(ppu, rwlock->rsq);

	while (!ppu.unsignal())
	{
		CHECK_EMU_STATUS;

		if (timeout)
		{
			const u64 passed = get_system_time() - start_time;

			if (passed >= timeout)
			{
				return CELL_ETIMEDOUT;
			}

			ppu.cv.wait_for(lv2_lock, std::chrono::microseconds(timeout - passed));
		}
		else
		{
			ppu.cv.wait(lv2_lock);
		}
	}

	if (rwlock->writer || !rwlock->readers)
	{
		throw EXCEPTION("Unexpected");
	}

	return CELL_OK;
}
Пример #27
0
NTSTATUS COMPLETION_PORT_IMPL::Remove(ULONG& key, ULONG& value, NTSTATUS& status, ULONG& info, PLARGE_INTEGER timeout)
{

	// try remove the completion entry first
	COMPLETION_PACKET *packet = queue.Head();
	if (!packet)
	{
		// queue thread here
		COMPLETION_WAITER waiter(Current);
		waiter.Stop( waiter_list, timeout );
		packet = waiter.GetPacket();
	}
	// this thread must be active... don't block ourselves
	else if (RUNLIST_ENTRY::NumActiveThreads() > num_threads )
	{
		// there's a packet ready but the system, is busy
		// a completion port isn't a FIFO - leave the packt alone
		// wait for idle, then remove the packet
		PortWaitIdle();
		COMPLETION_WAITER waiter(Current);
		waiter.Stop( waiter_list, timeout );
		//if (queue.empty() && IsLinked())
			//waiting_thread_ports.unlink( this );
		packet = waiter.GetPacket();
	}
	else
	{
		// there's enough free threads to run, and there's a packet waiting
		// we're ready to go
		queue.Unlink( packet );
	}
	if (!packet)
		return STATUS_TIMEOUT;

	key = packet->key;
	value = packet->value;
	status = packet->status;
	info = packet->info;

	delete packet;

	return STATUS_SUCCESS;
}
Пример #28
0
HRESULT CFxTradeTransactionReportIterator::RequestReports(const bool subscribe, const string& position, const uint32 timeoutInMilliseconds)
{
	Waiter<pair<int32, bool> > waiter(timeoutInMilliseconds, m_waiter, *m_dataTrade);
	ISender& sender = m_dataTrade->Sender();
	sender.VSendGetTradeTransactionReportsAndSubscribeToNotifications(waiter.Id(), m_direction, subscribe, m_from, m_to, m_preferedBufferSize, position);
	pair<int32, bool> response = waiter.WaitForResponse();

	m_reportsNumber = response.first;
	m_endOfStream = response.second;
	return S_OK;
}
Пример #29
0
HRESULT CDataFeed::SubscribeToQuotes(const vector<string>& symbols, int32 depth, uint32 timeoutInMilliseconds)
{
	Waiter<HRESULT> waiter(timeoutInMilliseconds, cExternalSynchCall, *this);
	m_sender->VSendSubscribeToQuotes(waiter.Id(), symbols, depth);
	CFxEventInfo info;
	HRESULT result = waiter.WaitForResponse(info);
	if (FAILED(result))
	{
		throw CRejectException(info.Message, result);
	}
	return result;
}
Пример #30
0
void CDataTrade::DeleteOrder(const string& /*operationId*/, const string& orderId, const string& clientId, FxTradeRecordSide side, size_t timeoutInMilliseconds)
{
    Waiter<CFxExecutionReport> waiter(static_cast<uint32>(timeoutInMilliseconds), cExternalSynchCall, *this);
    m_sender->VSendDeleteOrder(waiter.Id(), orderId, clientId, side);

    CFxEventInfo info;
    CFxExecutionReport executionReport = waiter.WaitForResponse(info);
    if (FxOrderStatus_Rejected == executionReport.OrderStatus)
    {
        throw CRejectException(executionReport.Text, executionReport.RejectReason);
    }
}