Example #1
0
void
BouncerTest::tearDown() {
    _manager = 0;
    _lower = 0;
    _upper->close();
    _upper->flush();
    _upper.reset(0);
    _node.reset(0);
}
Example #2
0
 void loop() override {
   auto status = ping_connection_->flush();
   if (status.is_error()) {
     *result_ = std::move(status);
     return stop();
   }
   if (ping_connection_->was_pong()) {
     LOG(ERROR) << "GOT PONG";
     return stop();
   }
 }
Example #3
0
 void try_flush() {
   auto need_flush_since = binlog_->need_flush_since();
   auto now = Time::now_cached();
   if (now > need_flush_since + FLUSH_TIMEOUT - 1e-9) {
     binlog_->flush();
   } else {
     if (!force_sync_flag_) {
       flush_flag_ = true;
       wakeup_at(need_flush_since + FLUSH_TIMEOUT);
     }
   }
 }
Example #4
0
FakeLog::~FakeLog()
{
    if (!g_ostm || m_level < g_level)
        return;
    auto content = m_stream.m_ostm.str();
    //if (!content.empty()) {
    //    if (content[content.size() - 1] == '\n')
    //        content.pop_back();
    //}
	(*g_ostm) << LOG_SEVERITY_NAMES[m_level] << " [" << m_file << ":" << m_line << "] " << content;
    g_ostm->flush();
}
void Plugin_Flush(int t)
{
	 ::OutputDebugString(_T("Plugin_Flush\n"));

	 forwarder->Flush(t);
	 outputStream->Flush();
		 
	 w_offset = t;
	 start_t = ::GetTickCount();
	 ::InterlockedExchange(&writtenbytes, 0);

	 streamManager->flush(); //mpdClient->re_play();
}
Example #6
0
int Plugin_IsPlaying()
{
#ifdef STREAMER_PAYD_VERSION
	streamManager->flush();

	auto ip = forwarder->IsPlaying();
	auto x = streamManager->remaining_ms();

	return x > 0 ? 1 : 0;
#else
	auto ip = forwarder->IsPlaying();
	int time = _winamp_player->getTrackLenght();
	if (time < 0)
		return 0;

	auto out_time = Plugin_GetRealOutputTime();
	return out_time + 700 >= time ? 0 : 1;
#endif
}
Example #7
0
void logMessageHandler(QtMsgType type, const QMessageLogContext& ctxt, const QString& msg)
{
    // Silence qWarning spam due to bug in QTextBrowser (trying to open a file for base64 images)
    if (ctxt.function == QString("virtual bool QFSFileEngine::open(QIODevice::OpenMode)")
            && msg == QString("QFSFileEngine::open: No file name specified"))
        return;

    QString LogMsg = QString("[%1] %2:%3 : ")
                     .arg(QTime::currentTime().toString("HH:mm:ss.zzz")).arg(ctxt.file).arg(ctxt.line);
    switch (type)
    {
    case QtDebugMsg:
        LogMsg += "Debug";
        break;
    case QtWarningMsg:
        LogMsg += "Warning";
        break;
    case QtCriticalMsg:
        LogMsg += "Critical";
        break;
    case QtFatalMsg:
        LogMsg += "Fatal";
        break;
    default:
        break;
    }

    LogMsg += ": " + msg + "\n";

    QTextStream out(stderr, QIODevice::WriteOnly);
    out << LogMsg;

#ifdef LOG_TO_FILE
    if (!logFileStream)
        return;

    QMutexLocker locker(&mutex);
    *logFileStream << LogMsg;
    logFileStream->flush();
#endif
}
Example #8
0
static void start_acorn(net::Inet& inet)
{
  /** SETUP LOGGER */
  const int LOGBUFFER_LEN = 1024*16;
  static gsl::span<char> spanerino{new char[LOGBUFFER_LEN], LOGBUFFER_LEN};
  logger_ = std::make_unique<Logger>(spanerino);
  logger_->flush();
  logger_->log("LUL\n");

  OS::add_stdout(
  [] (const char* data, size_t len) {
    // append timestamp
    auto entry = "[" + isotime::now() + "]" + std::string{data, len};
    logger_->log(entry);
  });

  disk = fs::shared_memdisk();

  // init the first legit partition/filesystem
  disk->init_fs(
  [&inet] (fs::error_t err, auto& fs)
  {
      if (err) panic("Could not mount filesystem...\n");

      // only works with synchronous disks (memdisk)
      list_static_content(fs);

      /** BUCKET SETUP */

      // create squirrel bucket
      squirrels = std::make_shared<SquirrelBucket>(10);
      // set member name to be unique
      squirrels->add_index<std::string>("name",
      [](const Squirrel& s)->const auto&
      {
        return s.get_name();
      }, SquirrelBucket::UNIQUE);

      // seed squirrels
      squirrels->spawn("Alfred"s,  1000U, "Wizard"s);
      squirrels->spawn("Alf"s,     6U,    "Script Kiddie"s);
      squirrels->spawn("Andreas"s, 28U,   "Code Monkey"s);
      squirrels->spawn("AnnikaH"s, 20U,   "Fairy"s);
      squirrels->spawn("Ingve"s,   24U,   "Integration Master"s);
      squirrels->spawn("Martin"s,  16U,   "Build Master"s);
      squirrels->spawn("Rico"s,    28U,   "Mad Scientist"s);

      // setup users bucket
      users = std::make_shared<UserBucket>();
      users->spawn();
      users->spawn();

      /** ROUTES SETUP **/
      using namespace mana;
      Router router;

      // setup Squirrel routes
      router.use("/api/squirrels", routes::Squirrels{squirrels});
      // setup User routes
      router.use("/api/users", routes::Users{users});
      // setup Language routes
      router.use("/api/languages", routes::Languages{});


      /** DASHBOARD SETUP **/
      dashboard_ = std::make_unique<dashboard::Dashboard>(8192);
      // Add singleton component
      dashboard_->add(dashboard::Memmap::instance());
      dashboard_->add(dashboard::StackSampler::instance());
      dashboard_->add(dashboard::Status::instance());
      // Construct component
      dashboard_->construct<dashboard::Statman>(Statman::get());
      dashboard_->construct<dashboard::TCP>(inet.tcp());
      dashboard_->construct<dashboard::CPUsage>();
      dashboard_->construct<dashboard::Logger>(*logger_, static_cast<size_t>(50));

      // Add Dashboard routes to "/api/dashboard"
      router.use("/api/dashboard", dashboard_->router());

      // Fallback route for angular application - serve index.html if route is not found
      router.on_get("/app/.*",
      [&fs](auto, auto res) {
        #ifdef VERBOSE_WEBSERVER
        printf("[@GET:/app/*] Fallback route - try to serve index.html\n");
        #endif
        fs.cstat("/public/app/index.html", [res](auto err, const auto& entry) {
          if(err) {
            res->send_code(http::Not_Found);
          } else {
            // Serve index.html
            #ifdef VERBOSE_WEBSERVER
            printf("[@GET:/app/*] (Fallback) Responding with index.html. \n");
            #endif
            res->send_file({disk, entry});
          }
        });
      });
      INFO("Router", "Registered routes:\n%s", router.to_string().c_str());


      /** SERVER SETUP **/
      server_ = std::make_unique<Server>(inet.tcp());
      // set routes and start listening
      server_->set_routes(router).listen(80);


      /** MIDDLEWARE SETUP **/
      // custom middleware to serve static files
      auto opt = {"index.html"};
      Middleware_ptr butler = std::make_shared<middleware::Butler>(disk, "/public", opt);
      server_->use(butler);

      // custom middleware to serve a webpage for a directory
      Middleware_ptr director = std::make_shared<middleware::Director>(disk, "/public/static");
      server_->use("/static", director);

      Middleware_ptr parsley = std::make_shared<middleware::Parsley>();
      server_->use(parsley);

      Middleware_ptr cookie_parser = std::make_shared<middleware::Cookie_parser>();
      server_->use(cookie_parser);

    }); // < disk

}
Example #9
0
 /// \brief Flush this EventWriter's output stream.
 ///
 void flush() {
   if (Out)
     Out->flush();
 }