void BlockchainMonitor::waitBlockchainUpdate() {
m_logger(Logging::DEBUGGING) << "Waiting for blockchain updates";
m_stopped = false;
Crypto::Hash lastBlockHash = requestLastBlockHash();
while(!m_stopped) {
m_sleepingContext.spawn([this] () {
System::Timer timer(m_dispatcher);
timer.sleep(std::chrono::seconds(m_pollingInterval));
});
m_sleepingContext.wait();
if (lastBlockHash != requestLastBlockHash()) {
m_logger(Logging::DEBUGGING) << "Blockchain has been updated";
break;
}
}
if (m_stopped) {
m_logger(Logging::DEBUGGING) << "Blockchain monitor has been stopped";
throw System::InterruptedException();
}
}
BlockMiningParameters MinerManager::requestMiningParameters(System::Dispatcher& dispatcher, const std::string& daemonHost, uint16_t daemonPort, const std::string& miningAddress) {
try {
HttpClient client(dispatcher, daemonHost, daemonPort);
COMMAND_RPC_GETBLOCKTEMPLATE::request request;
request.wallet_address = miningAddress;
request.reserve_size = 0;
COMMAND_RPC_GETBLOCKTEMPLATE::response response;
System::EventLock lk(m_httpEvent);
JsonRpc::invokeJsonRpcCommand(client, "getblocktemplate", request, response);
if (response.status != CORE_RPC_STATUS_OK) {
throw std::runtime_error("Core responded with wrong status: " + response.status);
}
BlockMiningParameters params;
params.difficulty = response.difficulty;
if(!fromBinaryArray(params.blockTemplate, Common::fromHex(response.blocktemplate_blob))) {
throw std::runtime_error("Couldn't deserialize block template");
}
m_logger(Logging::DEBUGGING) << "Requested block template with previous block hash: " << Common::podToHex(params.blockTemplate.previousBlockHash);
return params;
} catch (std::exception& e) {
m_logger(Logging::WARNING) << "Couldn't get block template: " << e.what();
throw;
}
}
Crypto::Hash BlockchainMonitor::requestLastBlockHash() {
m_logger(Logging::DEBUGGING) << "Requesting last block hash";
try {
CryptoNote::HttpClient client(m_dispatcher, m_daemonHost, m_daemonPort);
CryptoNote::COMMAND_RPC_GET_LAST_BLOCK_HEADER::request request;
CryptoNote::COMMAND_RPC_GET_LAST_BLOCK_HEADER::response response;
System::EventLock lk(m_httpEvent);
CryptoNote::JsonRpc::invokeJsonRpcCommand(client, "getlastblockheader", request, response);
if (response.status != CORE_RPC_STATUS_OK) {
throw std::runtime_error("Core responded with wrong status: " + response.status);
}
Crypto::Hash blockHash;
if (!Common::podFromHex(response.block_header.hash, blockHash)) {
throw std::runtime_error("Couldn't parse block hash: " + response.block_header.hash);
}
m_logger(Logging::DEBUGGING) << "Last block hash: " << Common::podToHex(blockHash);
return blockHash;
} catch (std::exception& e) {
m_logger(Logging::ERROR) << "Failed to request last block hash: " << e.what();
throw;
}
}
void MinerManager::start() {
m_logger(Logging::DEBUGGING) << "starting";
BlockMiningParameters params;
for (;;) {
m_logger(Logging::INFO) << "requesting mining parameters";
try {
params = requestMiningParameters(m_dispatcher, m_config.daemonHost, m_config.daemonPort, m_config.miningAddress);
} catch (ConnectException& e) {
m_logger(Logging::WARNING) << "Couldn't connect to daemon: " << e.what();
System::Timer timer(m_dispatcher);
timer.sleep(std::chrono::seconds(m_config.scanPeriod));
continue;
}
adjustBlockTemplate(params.blockTemplate);
break;
}
startBlockchainMonitoring();
startMining(params);
eventLoop();
}
void TransfersConsumer::processTransaction(const TransactionBlockInfo& blockInfo, const ITransactionReader& tx, const PreprocessInfo& info) {
std::vector<TransactionOutputInformationIn> emptyOutputs;
std::vector<ITransfersContainer*> transactionContainers;
m_logger(TRACE) << "Process transaction, block " << blockInfo.height << ", transaction index " << blockInfo.transactionIndex << ", hash " << tx.getTransactionHash();
bool someContainerUpdated = false;
for (auto& kv : m_subscriptions) {
auto it = info.outputs.find(kv.first);
auto& subscriptionOutputs = (it == info.outputs.end()) ? emptyOutputs : it->second;
bool containerContainsTx;
bool containerUpdated;
processOutputs(blockInfo, *kv.second, tx, subscriptionOutputs, info.globalIdxs, containerContainsTx, containerUpdated);
someContainerUpdated = someContainerUpdated || containerUpdated;
if (containerContainsTx) {
transactionContainers.emplace_back(&kv.second->getContainer());
}
}
if (someContainerUpdated) {
m_logger(TRACE) << "Transaction updated some containers, hash " << tx.getTransactionHash();
m_observerManager.notify(&IBlockchainConsumerObserver::onTransactionUpdated, this, tx.getTransactionHash(), transactionContainers);
} else {
m_logger(TRACE) << "Transaction doesn't updated any container, hash " << tx.getTransactionHash();
}
}
void Miner::runWorkers(BlockMiningParameters blockMiningParameters, size_t threadCount) {
assert(threadCount > 0);
m_logger(Logging::INFO) << "Starting mining for difficulty " << blockMiningParameters.difficulty;
try {
blockMiningParameters.blockTemplate.nonce = Crypto::rand<uint32_t>();
for (size_t i = 0; i < threadCount; ++i) {
m_workers.emplace_back(std::unique_ptr<System::RemoteContext<void>> (
new System::RemoteContext<void>(m_dispatcher, std::bind(&Miner::workerFunc, this, blockMiningParameters.blockTemplate, blockMiningParameters.difficulty, threadCount)))
);
blockMiningParameters.blockTemplate.nonce++;
}
m_workers.clear();
} catch (std::exception& e) {
m_logger(Logging::ERROR) << "Error occured during mining: " << e.what();
m_state = MiningState::MINING_STOPPED;
}
m_miningStopped.set();
}
void Miner::workerFunc(const Block& blockTemplate, difficulty_type difficulty, uint32_t nonceStep) {
try {
Block block = blockTemplate;
Crypto::cn_context cryptoContext;
while (m_state == MiningState::MINING_IN_PROGRESS) {
Crypto::Hash hash;
if (!get_block_longhash(cryptoContext, block, hash)) {
//error occured
m_logger(Logging::DEBUGGING) << "calculating long hash error occured";
m_state = MiningState::MINING_STOPPED;
return;
}
if (check_hash(hash, difficulty)) {
m_logger(Logging::INFO) << "Found block for difficulty " << difficulty;
if (!setStateBlockFound()) {
m_logger(Logging::DEBUGGING) << "block is already found or mining stopped";
return;
}
m_block = block;
return;
}
block.nonce += nonceStep;
}
} catch (std::exception& e) {
m_logger(Logging::ERROR) << "Miner got error: " << e.what();
m_state = MiningState::MINING_STOPPED;
}
}
void stop_audio()
{
if (m_outputProcState != kRunning)
return;
m_logger(2, "Stopping audio...");
m_outputProcState = Impl::kStopRequested;
//AudioDeviceRemoveIOProc(m_ID, Impl::OutputIOProc);
m_logger(2, "Done!");
}
void start_audio()
{
if (m_outputProcState != kOff)
return;
m_logger(2, "Starting audio...");
m_outputProcState = Impl::kStarting;
//AudioDeviceAddIOProc(m_ID, Impl::OutputIOProc, this);
AudioDeviceStart(m_ID, Impl::OutputIOProc);
m_logger(2, "Done!");
}
void TransfersConsumer::processOutputs(const TransactionBlockInfo& blockInfo, TransfersSubscription& sub, const ITransactionReader& tx,
const std::vector<TransactionOutputInformationIn>& transfers, const std::vector<uint32_t>& globalIdxs, bool& contains, bool& updated) {
TransactionInformation subscribtionTxInfo;
contains = sub.getContainer().getTransactionInformation(tx.getTransactionHash(), subscribtionTxInfo);
updated = false;
if (contains) {
if (subscribtionTxInfo.blockHeight == WALLET_UNCONFIRMED_TRANSACTION_HEIGHT && blockInfo.height != WALLET_UNCONFIRMED_TRANSACTION_HEIGHT) {
try {
// pool->blockchain
sub.markTransactionConfirmed(blockInfo, tx.getTransactionHash(), globalIdxs);
updated = true;
} catch (...) {
m_logger(ERROR, BRIGHT_RED) << "markTransactionConfirmed failed, throw MarkTransactionConfirmedException";
throw MarkTransactionConfirmedException(tx.getTransactionHash());
}
} else {
assert(subscribtionTxInfo.blockHeight == blockInfo.height);
}
} else {
updated = sub.addTransaction(blockInfo, tx, transfers);
contains = updated;
}
}
int LoggerMessage::sync()
{
m_logger(m_sCategory, m_nLogLevel, m_tmTimeStamp, m_sMessage);
m_bGotText = false;
m_sMessage = Logging::DEFAULT;
return 0;
}
void BlockchainMonitor::stop() {
m_logger(Logging::DEBUGGING) << "Sending stop signal to blockchain monitor";
m_stopped = true;
m_sleepingContext.interrupt();
m_sleepingContext.wait();
}
void MinerManager::eventLoop() {
size_t blocksMined = 0;
for (;;) {
m_logger(Logging::DEBUGGING) << "waiting for event";
MinerEvent event = waitEvent();
switch (event.type) {
case MinerEventType::BLOCK_MINED: {
m_logger(Logging::DEBUGGING) << "got BLOCK_MINED event";
stopBlockchainMonitoring();
if (submitBlock(m_minedBlock, m_config.daemonHost, m_config.daemonPort)) {
m_lastBlockTimestamp = m_minedBlock.timestamp;
if (m_config.blocksLimit != 0 && ++blocksMined == m_config.blocksLimit) {
m_logger(Logging::INFO) << "Miner mined requested " << m_config.blocksLimit << " blocks. Quitting";
return;
}
}
BlockMiningParameters params = requestMiningParameters(m_dispatcher, m_config.daemonHost, m_config.daemonPort, m_config.miningAddress);
adjustBlockTemplate(params.blockTemplate);
startBlockchainMonitoring();
startMining(params);
break;
}
case MinerEventType::BLOCKCHAIN_UPDATED: {
m_logger(Logging::DEBUGGING) << "got BLOCKCHAIN_UPDATED event";
stopMining();
stopBlockchainMonitoring();
BlockMiningParameters params = requestMiningParameters(m_dispatcher, m_config.daemonHost, m_config.daemonPort, m_config.miningAddress);
adjustBlockTemplate(params.blockTemplate);
startBlockchainMonitoring();
startMining(params);
break;
}
default:
assert(false);
return;
}
}
}
int read(unsigned char* data, int num_samples)
{
MutexHolder mh(m_mutex);
// m_logger(2, "Read request...");
if (m_outputProcState == kRunning &&
m_buffer.size() < num_samples * m_input_format.mBytesPerFrame)
{
stop_audio();
return 0;
}
const UInt32 inputDataSizeBytes = my_min(num_samples * m_input_format.mBytesPerFrame,
m_buffer.size());
std::vector<unsigned char> input_data(m_buffer.begin(),
m_buffer.begin() + inputDataSizeBytes);
m_buffer.erase(m_buffer.begin(),
m_buffer.begin() + inputDataSizeBytes);
int outputDataSizeBytes = num_samples*m_format.mBytesPerFrame;
OSStatus err;
err = m_converter->convert(&input_data[0],
input_data.size(),
data,
outputDataSizeBytes);
if (err != kAudioHardwareNoError)
{
char buf[1024] = {0};
sprintf(buf,
"Conversion failed, num_samples=%i, inputDataSize = %i\n"
"buffer_size = %i, outputDataSize = %i (err=0x%lX (= %i))",
num_samples,
inputDataSizeBytes,
m_buffer.size(),
outputDataSizeBytes,
err, err);
m_logger(0, buf);
return 0;
}
/*
char buf[512] = {0};
sprintf(buf, "Converted %i bytes to %i bytes (num_samples=%i)",
inputDataSizeBytes, outputDataSizeBytes, num_samples);
m_logger(2, buf);*/
return outputDataSizeBytes / m_format.mBytesPerFrame;
}
bool MinerManager::submitBlock(const Block& minedBlock, const std::string& daemonHost, uint16_t daemonPort) {
try {
HttpClient client(m_dispatcher, daemonHost, daemonPort);
COMMAND_RPC_SUBMITBLOCK::request request;
request.emplace_back(Common::toHex(toBinaryArray(minedBlock)));
COMMAND_RPC_SUBMITBLOCK::response response;
System::EventLock lk(m_httpEvent);
JsonRpc::invokeJsonRpcCommand(client, "submitblock", request, response);
m_logger(Logging::INFO) << "Block has been successfully submitted. Block hash: " << Common::podToHex(get_block_hash(minedBlock));
return true;
} catch (std::exception& e) {
m_logger(Logging::WARNING) << "Couldn't submit block: " << Common::podToHex(get_block_hash(minedBlock)) << ", reason: " << e.what();
return false;
}
}
void MinerManager::startMining(const CryptoNote::BlockMiningParameters& params) {
m_contextGroup.spawn([this, params] () {
try {
m_minedBlock = m_miner.mine(params, m_config.threadCount);
pushEvent(BlockMinedEvent());
} catch (System::InterruptedException&) {
} catch (std::exception& e) {
m_logger(Logging::ERROR) << "Miner context unexpectedly finished: " << e.what();
}
});
}
void MinerManager::startBlockchainMonitoring() {
m_contextGroup.spawn([this] () {
try {
m_blockchainMonitor.waitBlockchainUpdate();
pushEvent(BlockchainUpdatedEvent());
} catch (System::InterruptedException&) {
} catch (std::exception& e) {
m_logger(Logging::ERROR) << "BlockchainMonitor context unexpectedly finished: " << e.what();
}
});
}
int GPIODirection(int pin, int dir)
{
static const char s_directions_str[] = "in\0out";
#define DIRECTION_MAX 35
char path[DIRECTION_MAX];
int fd;
snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/direction", pin);
fd = open(path, O_WRONLY);
if (-1 == fd) {
m_logger("Failed to open gpio direction for writing!");
return(-1);
}
if (-1 == write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3)) {
m_logger("Failed to set direction!");
return(-1);
}
close(fd);
return(0);
}
int GPIOWrite(int pin, int value)
{
static const char s_values_str[] = "01";
#define VALUE_MAX 30
char path[VALUE_MAX];
int fd;
snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
fd = open(path, O_WRONLY);
if (-1 == fd) {
m_logger("Failed to open gpio value for writing!");
return(-1);
}
if (1 != write(fd, &s_values_str[LOW == value ? 0 : 1], 1)) {
m_logger("Failed to write value!");
return(-1);
}
close(fd);
return(0);
}
int GPIOUnexport(int pin)
{
char buffer[BUFFER_MAX];
ssize_t bytes_written;
int fd;
fd = open("/sys/class/gpio/unexport", O_WRONLY);
if (-1 == fd) {
m_logger("Failed to open unexport for writing!");
return(-1);
}
bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
write(fd, buffer, bytes_written);
close(fd);
return(0);
}
Block Miner::mine(const BlockMiningParameters& blockMiningParameters, size_t threadCount) {
if (threadCount == 0) {
throw std::runtime_error("Miner requires at least one thread");
}
if (m_state == MiningState::MINING_IN_PROGRESS) {
throw std::runtime_error("Mining is already in progress");
}
m_state = MiningState::MINING_IN_PROGRESS;
m_miningStopped.clear();
runWorkers(blockMiningParameters, threadCount);
assert(m_state != MiningState::MINING_IN_PROGRESS);
if (m_state == MiningState::MINING_STOPPED) {
m_logger(Logging::DEBUGGING) << "Mining has been stopped";
throw System::InterruptedException();
}
assert(m_state == MiningState::BLOCK_FOUND);
return m_block;
}
int main(int argc, char *argv[])
{
CosNaming::NamingContext_var naming_context;
int nargc=0;
char **nargv=0;
const char *hn=ACSPorts::getIP();
ACE_CString iorFile;
if (argc>=2 && !ACE_OS_String::strcmp(argv[1], "-?")) {
ACE_OS::printf ("USAGE: acsLogSvc [-ORBInitRef NameService=iiop://yyy:xxxx/NameService] [-ORBEndpoint iiop://ip:port] [-o iorfile] [-silent]\n");
return -1;
}
// here we have to unset ACS_LOG_CENTRAL that we prevent filtering of log messages
char *logCent=getenv("ACS_LOG_CENTRAL");
if (logCent)
{
unsetenv("ACS_LOG_CENTRAL");
printf("Unset ACS_LOG_CENTRAL which was previously set to %s\n", logCent);
}//if
// create logging proxy
LoggingProxy::ProcessName(argv[0]);
ACE_Log_Msg::instance()->local_host(hn);
LoggingProxy m_logger (0, 0, 31, 0);
LoggingProxy::init (&m_logger);
ACS_SHORT_LOG((LM_INFO, "Logging proxy successfully created !"));
ACE_CString argStr;
for(int i=1; i<argc; i++)
{
argStr += argv[i];
argStr += " ";
if (!ACE_OS_String::strcmp(argv[i], "-o") && (i+1)<argc)
{
iorFile = argv[i+1];
}//if
}//for
if (argStr.find ("-ORBEndpoint")==ACE_CString::npos)
{
argStr = argStr + "-ORBEndpoint iiop://" + hn + ":" + ACSPorts::getLogPort().c_str();
}
ACS_SHORT_LOG((LM_INFO, "New command line is: %s", argStr.c_str()));
ACE_OS::string_to_argv ((ACE_TCHAR*)argStr.c_str(), nargc, nargv);
ACE_OS::signal(SIGINT, TerminationSignalHandler); // Ctrl+C
ACE_OS::signal(SIGTERM, TerminationSignalHandler); // termination request
try
{
// Initialize the ORB
ACE_OS::printf ("Initialising ORB ... \n");
orb = CORBA::ORB_init (nargc, nargv, 0);
ACE_OS::printf ("ORB initialsed !\n");
}
catch( CORBA::Exception &ex )
{
ex._tao_print_exception("Failed to initalise ORB");
return -1;
}
if (!ACSError::init(orb.in()))
{
ACS_SHORT_LOG ((LM_ERROR, "Failed to initalise the ACS Error System"));
return -1;
}
// resolve naming service
try
{
ACS_SHORT_LOG((LM_INFO, "Trying to connect to the Naming Service ...."));
CORBA::Object_var naming_obj = orb->resolve_initial_references ("NameService");
if (!CORBA::is_nil (naming_obj.in ()))
{
naming_context = CosNaming::NamingContext::_narrow (naming_obj.in ());
ACS_SHORT_LOG((LM_INFO, "Connected to the Name Service"));
}
else
{
ACS_SHORT_LOG((LM_ERROR, "Could not connect the Name Service!"));
return -1;
}//if-else
}
catch( CORBA::Exception &_ex )
{
ACS_SHORT_LOG((LM_ERROR, "Could not connect the Name Service!"));
return -1;
}
// logging service
try
{
CORBA::Object_var log_obj;
/*
if (argStr.find ("-ORBInitRef NameService=")!=ACE_CString::npos)
{
// Initialize the ORB
ACE_OS::printf ("Initialising ORB ... \n");
orb = CORBA::ORB_init (nargc, nargv, 0);
ACE_OS::printf ("ORB initialsed !\n");
//Naming Service
ACE_OS::printf ("Resolving Naming service ... \n");
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (!CORBA::is_nil (naming_obj.in ()))
{
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
ACE_OS::printf ( "Naming Service resolved !\n");
*/
ACE_OS::printf ( "Resolving Logging Service from Naming service ...\n");
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup("Log");
log_obj = naming_context->resolve(name);
/*
}
else
{
ACS_LOG(LM_SOURCE_INFO, "main", (LM_ERROR, "Failed to initialise the Name Service!"));
}
}//if naming Service
else
{
ACE_OS::printf ("Getting Log from the Manager... \n");
CORBA::ULong status;
maci::Manager_ptr manager = maci::MACIHelper::resolveManager (orb.in(), nargc, nargv, 0, 0);
log_obj = manager->get_COB(0, "Log", true, status);
}
*/
if (!CORBA::is_nil (log_obj.in()))
{
Logging::AcsLogService_var logger = Logging::AcsLogService::_narrow(log_obj.in());
ACE_OS::printf ( "Logging Service resolved !\n");
m_logger.setCentralizedLogger(logger.in());
}
else
{
ACS_LOG(LM_SOURCE_INFO, "main", (LM_ERROR, "Failed to initialise the Logging Service!"));
return -1;
}//if-else
}
catch( CORBA::Exception &__ex )
{
__ex._tao_print_exception("Failed to get and set the centralized logger");
return -1;
}
try
{
//Get a reference to the RootPOA
ACE_OS::printf("Creating POA ... \n");
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager();
CORBA::PolicyList policy_list;
policy_list.length(5);
policy_list[0] = root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
policy_list[1] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
policy_list[2] = root_poa->create_id_assignment_policy(PortableServer::USER_ID);
policy_list[3] = root_poa->create_servant_retention_policy(PortableServer::NON_RETAIN);
policy_list[4] = root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
printf("policies are created !\n");
PortableServer::POA_var poa = root_poa->create_POA("ACSLogSvc", poa_manager.in(), policy_list);
ACE_OS::printf("POA created !\n");
for (CORBA::ULong i = 0; i < policy_list.length (); ++i) {
CORBA::Policy_ptr policy = policy_list[i];
policy->destroy ();
}
printf("Policies are destroyed !\n");
ACSLogImpl acsLogSvc (m_logger);
poa->set_servant (&acsLogSvc);
PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId ("ACSLogSvc");
obj = poa->create_reference_with_id (oid.in(), acsLogSvc._interface_repository_id());
CORBA::String_var ior = orb->object_to_string (obj.in());
// if ther is file name write ior in it
if (iorFile.length()!=0)
{
FILE *output_file = ACE_OS::fopen (iorFile.c_str(), "w");
if (output_file == 0)
{
ACS_SHORT_LOG ((LM_ERROR,
"Cannot open output files for writing IOR: ior.ior"));
return -1;
}//if
int result = ACE_OS::fprintf (output_file, "%s", ior.in());
if (result < 0)
{
ACS_SHORT_LOG ((LM_ERROR,
"ACE_OS::fprintf failed while writing %s to ior.ior", ior.in()));
return -1;
}//if
ACE_OS::fclose (output_file);
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc's IOR has been written into: %s", iorFile.c_str()));
}//if
// adding ACSLog to NamingService
if (!CORBA::is_nil (naming_context.in ()))
{
// register cdb server in Naming service
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup ("ACSLogSvc");
naming_context->rebind (name, obj.in ());
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc service registered with Naming Services"));
}//if
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACS_SHORT_LOG ((LM_ERROR, "Nil IORTable"));
}
else
{
adapter->bind ("ACSLogSvc", ior.in ());
}
poa_manager->activate ();
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc is waiting for incoming log messages ..."));
if (argStr.find ("-ORBEndpoint")!=ACE_CString::npos)
m_logger.setStdio(31);
orb->run ();
ACSError::done();
LoggingProxy::done();
}
catch( CORBA::Exception &ex )
{
ex. _tao_print_exception("EXCEPTION CAUGHT");
return -1;
}
return 0;
}
//Report the error from an exception, store it in lastError
void BeaContext::reportError(TryCatch& try_catch){
lastError = *v8::String::Utf8Value(try_catch.Exception());
if (m_logger)
m_logger(*v8::String::Utf8Value(try_catch.StackTrace()));
}
int main(int argc, char *argv[])
{
if (argc<4){
ACE_OS::printf ("usage: testClient <server_name> <depth> <isError> [iteration]\n");
return -1;
}//if
// create logging proxy
LoggingProxy m_logger (0, 0, 31, 0);
LoggingProxy::init (&m_logger);
CORBA::ORB_var orb;
ACS_TEST_INIT_CORBA;
// init ACS error system
ACSError::init (orb.ptr());
/**************************************/
acserrOldTest_var test;
int depth;
sscanf (argv[2], "%d", &depth);
bool isErr = *argv[3]-'0';
int iteration=1, i=1;
const int size = 20; // max value 1.84 x 10^19
char printBuf[size+1];
if (argc>4)
sscanf (argv[4], "%d", &iteration);
ACS_DEBUG("main", "****** Test Block *****");
try
{
ACS_DEBUG("acserrOldTestClient", "Getting object reference ... ");
char fileName[64];
sprintf(fileName, "file://%s.ior", argv[1]);
CORBA::Object_var testObj = orb->string_to_object (fileName);
ACS_DEBUG("acserrOldTestClient", "Narrowing it .... ");
test = acserrOldTest::_narrow (testObj.in());
unsigned long long numToPrint;
while( iteration >= i ){
ACS_SHORT_LOG((LM_INFO, "Performing test1 (remote call)... (%d/%d)", i, iteration));
ACSErr::ErrorTrace *c = test->test (depth, isErr);
ACSError error(c, true);
ACS_SHORT_LOG((LM_INFO, "Stack depth: %d", error.getDepth()));
error.log();
//ACSError *error = new ACSError (c, true) -> new ACS_ERROR (c, true);
while (c!=NULL){
ACS_SHORT_LOG((LM_INFO, "FileName: \"%s\"",error.getFileName()));
ACS_SHORT_LOG((LM_INFO, "LineNumber: \"%d\"",error.getLineNumber()));
ACS_SHORT_LOG((LM_INFO, "Routine: \"%s\"",error.getRoutine()));
ACS_SHORT_LOG((LM_INFO, "HostName: \"%s\"",error.getHostName()));
ACS_SHORT_LOG((LM_INFO, "Process: \"%s\"",error.getProcess()));
ACS_SHORT_LOG((LM_INFO, "Thread: \"%s\"",error.getThread()));
for (int ii = 0; ii < size; ii++) printBuf[ii] = ' ';
printBuf[size] = '\0';
numToPrint = error.getTimeStamp();
for (int ii = size - 1; ii >= 0; ii--) {
printBuf[ii] = numToPrint % 10 + '0';
numToPrint /= 10;
if (numToPrint == 0)
break;
}
ACS_SHORT_LOG((LM_INFO, "TimeStamp: \"%s\"",printBuf));
ACS_SHORT_LOG((LM_INFO, "ErrorType: \"%d\"",error.getErrorType()));
ACS_SHORT_LOG((LM_INFO, "ErrorCode: \"%d\"",error.getErrorCode()));
ACS_SHORT_LOG((LM_INFO, "Severity: \"%d\"", error.getSeverity()));
ACS_SHORT_LOG((LM_INFO, "Description: \"%s\"",error.getDescription()));
c = error.getNext();
}
i++;
}//while
}
catch( CORBA::Exception &ex)
{
ACE_PRINT_EXCEPTION (ex, "EXCEPTION CAUGHT");
return -1;
}
ACS_SHORT_LOG((LM_INFO, "Test1 performed."));
//test2
i=1;
while (i<=iteration){
try
{
ACS_SHORT_LOG((LM_INFO,
"Performing test2 (remote call - exceptions) ... (%d/%d)", i, iteration));
test->testExceptions (depth, isErr);
}
catch (ACSErr::ACSException &ex)
{
ACS_SHORT_LOG((LM_INFO, "Catch ACSException !"));
ACSError exception (ex); // put CORBA exception (ACSException) into ACSError wrapper
exception.log();
}
catch( CORBA::Exception &_ex)
{
ACE_PRINT_EXCEPTION (_ex, "EXCEPTION CAUGHT");
return -1;
}
i++;
}//while
ACS_SHORT_LOG((LM_INFO, "Test2 performed."));
// test3 (no error)
i=1;
while (i<=iteration){
try
{
ACS_SHORT_LOG((LM_INFO,
"Performing test3 (no error) ... (%d/%d)", i, iteration));
test->testNoError ();
}
catch( CORBA::Exception &_ex)
{
ACE_PRINT_EXCEPTION (_ex, "EXCEPTION CAUGHT");
return -1;
}
i++;
}//while
ACS_SHORT_LOG((LM_INFO, "Test3 performed."));
test->shutdown();
ACE_OS::sleep(5);
LoggingProxy::done();
return 0;
}
void operator()(Args...args)
{
m_logger(m_details,args...);
}
uint32_t TransfersConsumer::onNewBlocks(const CompleteBlock* blocks, uint32_t startHeight, uint32_t count) {
assert(blocks);
assert(count > 0);
struct Tx {
TransactionBlockInfo blockInfo;
const ITransactionReader* tx;
bool isLastTransactionInBlock;
};
struct PreprocessedTx : Tx, PreprocessInfo {};
std::vector<PreprocessedTx> preprocessedTransactions;
std::mutex preprocessedTransactionsMutex;
size_t workers = std::thread::hardware_concurrency();
if (workers == 0) {
workers = 2;
}
BlockingQueue<Tx> inputQueue(workers * 2);
std::atomic<bool> stopProcessing(false);
std::atomic<size_t> emptyBlockCount(0);
auto pushingThread = std::async(std::launch::async, [&] {
for( uint32_t i = 0; i < count && !stopProcessing; ++i) {
const auto& block = blocks[i].block;
if (!block.is_initialized()) {
++emptyBlockCount;
continue;
}
// filter by syncStartTimestamp
if (m_syncStart.timestamp && block->timestamp < m_syncStart.timestamp) {
++emptyBlockCount;
continue;
}
TransactionBlockInfo blockInfo;
blockInfo.height = startHeight + i;
blockInfo.timestamp = block->timestamp;
blockInfo.transactionIndex = 0; // position in block
for (const auto& tx : blocks[i].transactions) {
auto pubKey = tx->getTransactionPublicKey();
if (pubKey == NULL_PUBLIC_KEY) {
++blockInfo.transactionIndex;
continue;
}
bool isLastTransactionInBlock = blockInfo.transactionIndex + 1 == blocks[i].transactions.size();
Tx item = { blockInfo, tx.get(), isLastTransactionInBlock };
inputQueue.push(item);
++blockInfo.transactionIndex;
}
}
inputQueue.close();
});
auto processingFunction = [&] {
Tx item;
std::error_code ec;
while (!stopProcessing && inputQueue.pop(item)) {
PreprocessedTx output;
static_cast<Tx&>(output) = item;
ec = preprocessOutputs(item.blockInfo, *item.tx, output);
if (ec) {
stopProcessing = true;
break;
}
std::lock_guard<std::mutex> lk(preprocessedTransactionsMutex);
preprocessedTransactions.push_back(std::move(output));
}
return ec;
};
std::vector<std::future<std::error_code>> processingThreads;
for (size_t i = 0; i < workers; ++i) {
processingThreads.push_back(std::async(std::launch::async, processingFunction));
}
std::error_code processingError;
for (auto& f : processingThreads) {
try {
std::error_code ec = f.get();
if (!processingError && ec) {
processingError = ec;
}
} catch (const std::system_error& e) {
processingError = e.code();
} catch (const std::exception&) {
processingError = std::make_error_code(std::errc::operation_canceled);
}
}
if (processingError) {
forEachSubscription([&](TransfersSubscription& sub) {
sub.onError(processingError, startHeight);
});
return 0;
}
std::vector<Crypto::Hash> blockHashes = getBlockHashes(blocks, count);
m_observerManager.notify(&IBlockchainConsumerObserver::onBlocksAdded, this, blockHashes);
// sort by block height and transaction index in block
std::sort(preprocessedTransactions.begin(), preprocessedTransactions.end(), [](const PreprocessedTx& a, const PreprocessedTx& b) {
return std::tie(a.blockInfo.height, a.blockInfo.transactionIndex) < std::tie(b.blockInfo.height, b.blockInfo.transactionIndex);
});
uint32_t processedBlockCount = emptyBlockCount;
try {
for (const auto& tx : preprocessedTransactions) {
processTransaction(tx.blockInfo, *tx.tx, tx);
if (tx.isLastTransactionInBlock) {
++processedBlockCount;
m_logger(TRACE) << "Processed block " << processedBlockCount << " of " << count << ", last processed block index " << tx.blockInfo.height <<
", hash " << blocks[processedBlockCount - 1].blockHash;
auto newHeight = startHeight + processedBlockCount - 1;
forEachSubscription([newHeight](TransfersSubscription& sub) {
sub.advanceHeight(newHeight);
});
}
}
} catch (const MarkTransactionConfirmedException& e) {
m_logger(ERROR, BRIGHT_RED) << "Failed to process block transactions: failed to confirm transaction " << e.getTxHash() <<
", remove this transaction from all containers and transaction pool";
forEachSubscription([&e](TransfersSubscription& sub) {
sub.deleteUnconfirmedTransaction(e.getTxHash());
});
m_poolTxs.erase(e.getTxHash());
} catch (std::exception& e) {
m_logger(ERROR, BRIGHT_RED) << "Failed to process block transactions, exception: " << e.what();
} catch (...) {
m_logger(ERROR, BRIGHT_RED) << "Failed to process block transactions, unknown exception";
}
if (processedBlockCount < count) {
uint32_t detachIndex = startHeight + processedBlockCount;
m_logger(ERROR, BRIGHT_RED) << "Not all block transactions are processed, fully processed block count: " << processedBlockCount << " of " << count <<
", last processed block hash " << (processedBlockCount > 0 ? blocks[processedBlockCount - 1].blockHash : NULL_HASH) <<
", detach block index " << detachIndex << " to remove partially processed block";
forEachSubscription([detachIndex](TransfersSubscription& sub) {
sub.onBlockchainDetach(detachIndex);
});
}
return processedBlockCount;
}
void TransfersSyncronizer::load(std::istream& is) {
m_sync.load(is);
StdInputStream inputStream(is);
CryptoNote::BinaryInputStreamSerializer s(inputStream);
uint32_t version = 0;
s(version, "version");
if (version > TRANSFERS_STORAGE_ARCHIVE_VERSION) {
throw std::runtime_error("TransfersSyncronizer version mismatch");
}
struct ConsumerState {
PublicKey viewKey;
std::string state;
std::vector<std::pair<AccountPublicAddress, std::string>> subscriptionStates;
};
std::vector<ConsumerState> updatedStates;
try {
size_t subscriptionCount = 0;
s.beginArray(subscriptionCount, "consumers");
while (subscriptionCount--) {
s.beginObject("");
PublicKey viewKey;
s(viewKey, "view_key");
std::string blob;
s(blob, "state");
auto subIter = m_consumers.find(viewKey);
if (subIter != m_consumers.end()) {
auto consumerState = m_sync.getConsumerState(subIter->second.get());
assert(consumerState);
{
// store previous state
auto prevConsumerState = getObjectState(*consumerState);
// load consumer state
setObjectState(*consumerState, blob);
updatedStates.push_back(ConsumerState{ viewKey, std::move(prevConsumerState) });
}
// load subscriptions
size_t subCount = 0;
s.beginArray(subCount, "subscriptions");
while (subCount--) {
s.beginObject("");
AccountPublicAddress acc;
std::string state;
s(acc, "address");
s(state, "state");
auto sub = subIter->second->getSubscription(acc);
if (sub != nullptr) {
auto prevState = getObjectState(sub->getContainer());
setObjectState(sub->getContainer(), state);
updatedStates.back().subscriptionStates.push_back(std::make_pair(acc, prevState));
} else {
m_logger(Logging::DEBUGGING) << "Subscription not found: " << m_currency.accountAddressAsString(acc);
}
s.endObject();
}
s.endArray();
} else {
m_logger(Logging::DEBUGGING) << "Consumer not found: " << viewKey;
}
s.endObject();
}
s.endArray();
} catch (...) {
// rollback state
for (const auto& consumerState : updatedStates) {
auto consumer = m_consumers.find(consumerState.viewKey)->second.get();
setObjectState(*m_sync.getConsumerState(consumer), consumerState.state);
for (const auto& sub : consumerState.subscriptionStates) {
setObjectState(consumer->getSubscription(sub.first)->getContainer(), sub.second);
}
}
throw;
}
}
std::string
RenderingDevices::xml()
{
// We cache the results
if(m_hasRenderingInformation) {
std::cout << m_xml<<std::endl;
return m_xml;
}
std::stringstream xml;
xml << " <renderingDevices>\n";
DIR* dir = opendir( "/tmp/.X11-unix" );
if( dir == NULL ) {
if( m_logger != NULL ) {
m_logger( m_logger_data, 0, package.c_str(),
"opendir failed: %s.", strerror( errno ) );
}
xml << " <error>INTERNAL_ERROR</error>\n";
}
else {
struct dirent* entry = NULL;
while( (entry = readdir( dir )) != NULL ) {
if( entry->d_name[0] != 'X' ) {
continue;
}
std::string display_id = ":" + std::string( entry->d_name ).substr(1);
Display* display = XOpenDisplay( display_id.c_str() );
if( display == NULL ) {
xml << " <renderingDevice id=\"" << display_id << "\">\n";
xml << " <error>FAILED_TO_OPEN_DISPLAY</error>\n";
xml << " </renderingDevice>\n";
continue;
}
#ifdef TINIA_AMAZON
int screen_count = 1;
#else
int screen_count = ScreenCount ( display );
#endif
XCloseDisplay( display );
if( screen_count < 1 ) {
xml << " <renderingDevice id=\"" << display_id << "\">\n";
xml << " <error>NO_SCREENS</error>\n";
xml << " </renderingDevice>\n";
continue;
}
for(int screen=0; screen<screen_count; screen++) {
std::stringstream screen_id_ss;
screen_id_ss << display_id << '.' << screen;
std::string screen_id = screen_id_ss.str();
xml << " <renderingDevice id=\"" << screen_id << "\">\n";
OffscreenGL gl( m_logger, m_logger_data );
if( !gl.setupContext( screen_id ) || !gl.bindContext() ) {
switch ( gl.state() ) {
case OffscreenGL::STATE_INSUFFICIENT_GLX:
xml << " <error>INSUFFICIENT_GLX</error>\n";
break;
case OffscreenGL::STATE_X_ERROR:
xml << " <error>X_ERROR</error>\n";
break;
default:
xml << " <error>INTERNAL_ERROR</error>\n";
break;
}
}
else {
int glx_major = 0;
int glx_minor = 0;
glXQueryVersion( gl.display(), &glx_major, &glx_minor );
xml << " <glx major=\"" << glx_major
<< "\" minor=\"" << glx_minor
<< "\" direct=\"" << (glXIsDirect(gl.display(), gl.context())==True?'1':'0')
<< "\">\n";
xml << " <client>\n";
xml << " <vendor>" << glXGetClientString( gl.display(), GLX_VENDOR ) << "</vendor>\n";
xml << " <version>" << glXGetClientString( gl.display(), GLX_VERSION ) << "</version>\n";
xml << " </client>\n";
xml << " <server>\n";
xml << " <vendor>" << glXQueryServerString( gl.display(), screen, GLX_VENDOR ) << "</vendor>\n";
xml << " <version>" << glXQueryServerString( gl.display(), screen, GLX_VERSION ) << "</version>\n";
xml << " </server>\n";
std::list<std::string> glx_extensions = parseExtensions( glXQueryExtensionsString( gl.display(), screen ) );
for( std::list<std::string>::iterator it=glx_extensions.begin(); it!=glx_extensions.end(); ++it ) {
//xml << " <extension>" << *it << "</extension>\n";
}
xml << " </glx>\n";
GLint gl_major = 0;
glGetIntegerv( GL_MAJOR_VERSION, &gl_major );
GLint gl_minor = 0;
glGetIntegerv( GL_MINOR_VERSION, &gl_minor );
xml << " <opengl major=\"" << gl_major
<< "\" minor=\"" << gl_minor
<< "\">\n";
xml << " <vendor>" << (const char*)glGetString( GL_VENDOR ) << "</vendor>\n";
xml << " <version>" << (const char*)glGetString( GL_VERSION ) << "</version>\n";
xml << " <renderer>" << (const char*)glGetString( GL_RENDERER) << "</renderer>\n";
if( gl_major >= 2 ) {
xml << " <glsl><version>"
<< (const char*)glGetString( GL_SHADING_LANGUAGE_VERSION )
<< "</version></glsl>\n";
}
std::list<std::string> gl_extensions = parseExtensions( (const char*)glGetString( GL_EXTENSIONS ) );
for( std::list<std::string>::iterator it=gl_extensions.begin(); it!=gl_extensions.end(); ++it ) {
//xml << " <extension>" << *it << "</extension>\n";
}
xml << " </opengl>\n";
}
xml << " </renderingDevice>\n";
}
}
closedir( dir );
}
xml << " </renderingDevices>\n";
m_hasRenderingInformation = true;
m_xml = xml.str();
return xml.str();
}
void operator()(Args&&...args)
{
m_logger(m_details, std::forward<Args>(args)...);
}
int acserrTestServer (char *szCmdLn){
ACE_OS_Object_Manager ace_os_object_manager;
ACE_Object_Manager ace_object_manager;
int argc;
char *argv[100];
argc = argUnpack(szCmdLn, argv);
argv[0] = "errorServer";
#else
int acserrTestServer (int argc, char *argv[]){
#endif // defined( MAKE_VXWORKS )
if (argc<2){
ACE_OS::printf ("usage: errorServer <server_name> [destination_server_name] \n");
return -1;
}
ACE_OS::signal(SIGINT, TerminationSignalHandler); // Ctrl+C
ACE_OS::signal(SIGTERM, TerminationSignalHandler); // termination request
// create logging proxy
LoggingProxy m_logger (0, 0, 31, 0);
LoggingProxy::init (&m_logger);
// creating ORB
ACS_TEST_INIT_CORBA;
// init ACS error system (and inside also logging)
// ACSError::init (orb.ptr());
try
{
//Get a reference to the RootPOA
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager();
#ifdef MAKE_VXWORKS
ErrorTraceHelper::setProcessName (szCmdLn);
#else
char *buf;
ACE_OS::argv_to_string (argv, buf);
ACSError::setProcessName (buf); // = ErrorTraceHelper::setProcessName (buf);
delete[] buf;
#endif
ACS_DEBUG ("errorServer", "Creating test object ...");
acserrTest_var dest;
if (argc>2){
ACS_DEBUG ("errorServer", "Getting object reference ... ");
char refName[64];
sprintf(refName, "file://%s.ior", argv[2]);
CORBA::Object_var destObj = orb->string_to_object (refName);
ACS_DEBUG ("errorServer", "Narrowing it .... ");
dest = acserrTest::_narrow (destObj.in());
}//if
acserrTestImpl esTest (dest.in(), argv[1]);
acserrTest_var testObj = esTest._this ();
poa_manager->activate ();
ACS_DEBUG ("errorServer","POA Manager -> activate");
ACS_DEBUG_PARAM ("errorServer", "Writing ior to the file: %s .... ", argv[1]);
char* ior = orb->object_to_string (testObj.in());
char fileName[64];
sprintf(fileName, "%s.ior", argv[1]);
FILE *output_file = ACE_OS::fopen (fileName, "w");
if (output_file == 0) {
ACS_SHORT_LOG((LM_ERROR,
"Cannot open output files for writing IOR: ior.ior"));
return -1;
}
int result = ACE_OS::fprintf (output_file, "%s", ior);
if (result < 0) {
ACS_SHORT_LOG ((LM_ERROR,
"ACE_OS::fprintf failed while writing %s to ior.ior", ior));
return -1;
}
ACE_OS::fclose (output_file);
ACS_DEBUG ("errorServer", "Waiting for requests ...");
orb->run ();
}
catch( CORBA::Exception &ex )
{
ex._tao_print_exception("EXCEPTION CAUGHT");
return -1;
}
// orb->shutdown(true); //wait until all requests have completed
LoggingProxy::done();
std::cout << std::flush;
sleep(3);
return 0;
}//startErrorServer
#ifndef MAKE_VXWORKS
int main(int argc, char *argv[])
{
return acserrTestServer (argc, argv);
}
