void DownloadManager::on(TimerManagerListener::Second, uint64_t aTick) noexcept { typedef vector<pair<string, UserPtr> > TargetList; TargetList dropTargets; { Lock l(cs); DownloadList tickList; // Tick each ongoing download for(DownloadList::iterator i = downloads.begin(); i != downloads.end(); ++i) { if((*i)->getPos() > 0) { tickList.push_back(*i); (*i)->tick(); } } if(tickList.size() > 0) fire(DownloadManagerListener::Tick(), tickList); // Automatically remove or disconnect slow sources if((uint32_t)(aTick / 1000) % SETTING(AUTODROP_INTERVAL) == 0) { for(DownloadList::iterator i = downloads.begin(); i != downloads.end(); ++i) { Download* d = *i; uint64_t timeElapsed = aTick - d->getStart(); uint64_t timeInactive = aTick - d->getUserConnection().getLastActivity(); uint64_t bytesDownloaded = d->getPos(); bool timeElapsedOk = timeElapsed >= (uint32_t)SETTING(AUTODROP_ELAPSED) * 1000; bool timeInactiveOk = timeInactive <= (uint32_t)SETTING(AUTODROP_INACTIVITY) * 1000; bool speedTooLow = timeElapsedOk && timeInactiveOk && bytesDownloaded > 0 ? bytesDownloaded / timeElapsed * 1000 < (uint32_t)SETTING(AUTODROP_SPEED) : false; bool isUserList = d->getType() == Transfer::TYPE_FULL_LIST; bool onlineSourcesOk = isUserList ? true : QueueManager::getInstance()->countOnlineSources(d->getPath()) >= SETTING(AUTODROP_MINSOURCES); bool filesizeOk = !isUserList && d->getSize() >= ((int64_t)SETTING(AUTODROP_FILESIZE)) * 1024; bool dropIt = (isUserList && BOOLSETTING(AUTODROP_FILELISTS)) || (filesizeOk && BOOLSETTING(AUTODROP_ALL)); if(speedTooLow && onlineSourcesOk && dropIt) { if(BOOLSETTING(AUTODROP_DISCONNECT) && isUserList) { d->getUserConnection().disconnect(); } else { dropTargets.push_back(make_pair(d->getPath(), d->getUser())); } } } } } for(TargetList::iterator i = dropTargets.begin(); i != dropTargets.end(); ++i) { QueueManager::getInstance()->removeSource(i->first, i->second, QueueItem::Source::FLAG_SLOW_SOURCE); } }
void OperatorToPlanTransformer::Visit(const PhysicalProject *) { auto project_prop = requirements_->GetPropertyOfType(PropertyType::PROJECT) ->As<PropertyProjection>(); (void)project_prop; size_t project_list_size = project_prop->GetProjectionListSize(); // expressions to evaluate TargetList tl = TargetList(); // columns which can be returned directly DirectMapList dml = DirectMapList(); // schema of the projections output std::vector<catalog::Column> columns; for (size_t project_idx = 0; project_idx < project_list_size; project_idx++) { auto expr = project_prop->GetProjection(project_idx); std::string column_name; // if the root of the expression is a column value we can // just do a direct mapping if (expr->GetExpressionType() == ExpressionType::VALUE_TUPLE) { auto tup_expr = (expression::TupleValueExpression *)expr; column_name = tup_expr->GetColumnName(); dml.push_back( DirectMap(project_idx, std::make_pair(0, tup_expr->GetColumnId()))); } // otherwise we need to evaluat the expression else { column_name = "expr" + std::to_string(project_idx); tl.push_back(Target(project_idx, expr->Copy())); } columns.push_back(catalog::Column( expr->GetValueType(), type::Type::GetTypeSize(expr->GetValueType()), column_name)); } // build the projection plan node and insert aboce the scan std::unique_ptr<planner::ProjectInfo> proj_info( new planner::ProjectInfo(std::move(tl), std::move(dml))); std::shared_ptr<catalog::Schema> schema_ptr(new catalog::Schema(columns)); std::unique_ptr<planner::AbstractPlan> project_plan( new planner::ProjectionPlan(std::move(proj_info), schema_ptr)); output_plan_ = std::move(project_plan); }