Есть такая замечательная софтина xrdp. И есть в ней такой замечательный код логгирования:

enum logReturns DEFAULT_CC
log_message(const enum logLevels lvl, const char *msg, ...)
{
    char buff[LOG_BUFFER_SIZE + 31]; /* 19 (datetime) 4 (space+cr+lf+\0) */
    va_list ap;
    int len = 0;
    enum logReturns rv = LOG_STARTUP_OK;
    int writereply = 0;
    time_t now_t;
    struct tm *now;

    if (g_staticLogConfig == NULL)
    {
        g_writeln("The log reference is NULL - log not initialized properly");
        return LOG_ERROR_NO_CFG;
    }

    if (0 > g_staticLogConfig->fd && g_staticLogConfig->enable_syslog == 0)
    {
        return LOG_ERROR_FILE_NOT_OPEN;
    }

    now_t = time(&now_t);
    now = localtime(&now_t);

Так вот, ИНОГДА, при неизвестных обстоятельствах, когда одновременно открывается много сессий, вызов now = localtime(&now_t); наглухо зависает. При этом bt в gdb показывает следующее:

(gdb) bt
#0  __lll_lock_wait_private () at ../nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:95
#1  0x00007f8a100bbabc in _L_lock_2480 () from /lib/x86_64-linux-gnu/libc.so.6
#2  0x00007f8a100bb8f7 in __tz_convert (timer=0x7f8a103c9ee0 <tzset_lock>, use_localtime=1, tp=0x7f8a103ccde0 <_tmbuf>) at tzset.c:627
#3  0x00007f8a10a1441b in log_message (lvl=LOG_LEVEL_INFO, msg=0x7f8a10a1b180 "An established connection closed to endpoint: %s") at log.c:556
#4  0x00007f8a10a1532d in g_tcp_close (sck=9) at os_calls.c:678
#5  0x0000000000405976 in session_start_fork (width=1024, height=768, bpp=24, username=0x7f8a08004a30 "xxx", 
    password=0x7f8a08004a60 "xxx", data=140230816451248, type=1 '\001', domain=0x0, program=0x0, directory=0x0, 
    client_ip=0x7f8a08004a80 "123.0.0.123:59517 - socket: 9") at session.c:523
#6  0x0000000000406bc0 in session_sync_start () at session.c:907
#7  0x00000000004041a5 in sesman_main_loop () at sesman.c:100
#8  0x0000000000404a84 in main (argc=1, argv=0x7fff8cb123d8) at sesman.c:393
(gdb) 

Из-за чего это может быть (сразу скажу, что код в этом месте не многопоточный, хотя форкается куча процессов)?

Система - Ubuntu 14.04. xrdp - 0.9 из git master.

UPD:

(gdb) info threads 
  Id   Target Id         Frame 
* 1    Thread 0x7f891182f740 (LWP 13555) "xrdp-sesman" __lll_lock_wait_private () at ../nptl/sysdeps/unix/sysv/linux/x86_64/lowlevellock.S:95
(gdb) 

Есть задачка настроить RAIL на xrdp. Гугление дало следующее: в 0.9 реализован некоторый несовместимый с MS вариант RemoteApp - без декораций окошек - который должен работать с клиентом NeutrinoRDP. Но документацию как это всё запускать, похоже, забыли: https://www.mail-archive.com/xrdp-devel@lists.sourceforge.net/msg01781.html https://github.com/neutrinolabs/xrdp/wiki/RAIL-support-in-xrdp Вопрос: может быть кому-нибудь удавалось это поднять? Или если у кого-то есть опыт запуска xfreerdp в режиме rail с терминальным сервером от МС, поделитесь пожалуйста.

Можно ли как-то исхитриться и настроить CUPS таким образом, чтобы у каждой пользовательской сессии был свой виртуальный принтер CUPS, печатающий, например, PDF и PS в определенный подкаталог в домашней директории?

Есть такая задача: требуется из работающего в защищенном режиме линуксового окружения запустить grub/syslinux/ntldr. Кому-нибудь это удавалось?

Есть такая задачка: создать загрузочный образ Linux с busybox и kexec, желательно универсальный - для CD и USB/Flash. Что-то вроде LFS. Может кто-нибудь расписать по шагам процесс или кинуть линк на грамотный HOWTO? Да, и ещё нужно как-то добиться поддержки UEFI с Secure Boot.

Прямо сейчас в прямом эфире НПО РусБИТех, Астралинукс и всё-всё-всё. Спешите троллить задавать вопросы в эфир: http://echo.msk.ru/programs/arsenal/1663340-echo/

UPD: Всё, LIVE кончилось. Смотрите/слушайте запись, читайте расшифровку (когда появится). Лулзы имеются.

Допустим, я хочу реализовать сопрограмму, в логике которой имеется ожидание, которое эквивалентно http://en.cppreference.com/w/cpp/thread/sleep_until Имеется ли готовый шаблон для такого решения? Если тупо получать текущее время в сопрограмме и делать yield(), если нужный момент не наступил, то получится аналог spinlock - управление будет передаваться по кругу до тех пор, пока для одной из сопрограмм не наступит нужное время. Этого хотелось бы избежать, то есть возвращать управление сопрограмме в нужный момент времени, а неиспользованное время отдавать ОС с помощью того же sleep_until. Высокого разрешения по времени и какой-то большой точности при этом не требуется - сотых долей секунды хватит с головой.

P.S. Подразумевается Boost.Coroutine, но можно и что-то другое, только не экзотическое.

Возник насущный вопрос: как разные http- и ftp-серверы решают проблему эффективного одновременного, последовательного для каждого отдельного файла, чтения большого числа файлов? Ведь скорость последовательного чтения у HDD может превосходить скорость произвольного доступа на 2 порядка и более, и если много клиентов одновременно запрашивают много файлов, то узким местом становится дисковая подсистема, а не сеть или CPU. Вместо сотен мегабайт в секунду получаются сотни килобайт. Мне интересно существует ли проверенное кросплатформенное решение для c++, которое бы организовывало эффективное кэширование и сериализацию чтения для такого случая? Идеи для собственного велосипеда имеются, но зачем его изобретать, если вдруг он уже есть? Стандартный ifstream как-то не очень справляется, особенно на оффтопике. Даже установка буфера в несколько мегабайт не помогает.

Имеется задача в которой приходится работать с потенциально очень большими (порядка сотен миллионов элементов) множествами целых чисел. При этом сами эти числа лежат в диапазоне от 0 до, собственно, ~100 000 000. Ещё одна особенность в том, что большинство элементов лежат в непрерывных интервалах [x; x + L] (то есть само множество - это множество таких вот непересекающихся интервалов). Основные операции: добавить элемент в множество, удалить элемент из множества, итерация. std::vector<bool> плохо подходит во-первых потому что итерация медленная, во-вторых, как кажется, с памятью тоже можно было бы работать гораздо эффективнее. Есть ли готовые реализации таких множеств, которыми можно было бы воспользоваться?

Кому-нибудь удавалось заставить сабж работать на оффтопике (или даже на онтопике)? Уперся в проблему, что на гигабитном эзернете оно ни в какую не хочет отдавать данные быстрее 9-10 мегабит в секунду. Шлю сообщения размером 1 мегабайт, ZMQ_RATE выставляю в ту скорость, с которой приложение, собственно, генерирует данные. Если эта скорость меньше 10 мегабит, то всё худо-бедно работает (правда, тоже откуда-то берутся NAK'и в больших количествах). Если выставить, скажем, 50 мегабит в секунду, то сообщения тупо становятся в очередь и выдаются с вышеупомянутой скоростью 9-10 мегабит в секунду. Кроме этого есть и другие чудеса. Например, если в контексте сделать штук 20 потоков ввода-вывода, то сообщения вообще перестают отправляться (при этом в очередь они становятся). Если ZMQ_RATE сделать 100 килобит в секунду, то сообщения уходят со скоростью 300 килобит в секунду. При этом в логе openpgm видно, что скорость сокету выставляется правильно. Версия zeromq 4.1.0 самосборная с libopenpgm последней стабильной версии с офсайта. Тесты проходят, по tcp работает нормально (за исключением случаев когда работа происходит вместе с epgm).

Тестовый код: https://github.com/briskycat/ZMQLoadTest

Как в basic_sink_backend в реализации функции

    void consume(const boost::log::record_view& rec)
    {
    }

вытащить значение severity level для rec? Само сообщение как-то примерно так через задницу достается:

*rec[boost::log::expressions::smessage]

Есть такая вот рабочая штука:

#include <memory>

class A {
public:
};

template <template <typename, typename> class Ptr>
void foo(Ptr<A, std::default_delete<A> >& ptr)
{
}
 
int main() {
    std::unique_ptr<A> ptr(new A);
    
    foo(ptr);
}

Хочется избавиться от явного указания std::default_delete<A>. Вопрос - как? Смысл шаблона foo в том, что аргумент foo должен быть автоматическим указателем (unique_ptr, shared_ptr и т.п.) именно на объект типа A.

Вопрос отсюда. Есть такой вот код, который работает:

class Base {
protected:
    template <class T, class... Args>
    std::function<void(Args...)> bind_this_(void (T::*f)(Args...))
    {
        return [this, f](Args&&... args) { (static_cast<T&>(*this).*f)(std::forward<Args>(args)...); };
    }
};

class A : public Base {
    void foo(int arg1, int& arg2, std::string& str) {}
public:
    std::function<void (int, int&, std::string&)> get_foo_functor() { return bind_this_(&A::foo); }
};

A::get_foo_functor() привязывает к A::foo() указатель на экземпляр A (который неявный this) и возвращает обертку, которую можно использовать как функциональный объект с аргументами, такими же как у A::foo().

Вопрос 1: можно ли как-то обойтись без лямбды? Вопрос 2: как сделать шаблонный класс X с оператором operator()(), который, будучи инстанцироваьным с нужными параметрами, возвращал бы такой же функтор. Типа вот такого:

A a;
X< ... > foo_functor_producer(/* например */ &a, &A::foo);
auto ff = foo_functor_producer(); //< возвращает std::function<void (int, int&, std::string&)> 

По следам темы eao197 слепил свою модель Ad-hoc легковесных недоакторов с помощью boost::asio::io_service и boost::signals2. Вот что получилось:

#include <iostream>
#include <mutex>
#include <thread>
#include <atomic>
#include <boost/asio/io_service.hpp>
#include <boost/signals2.hpp>
#define BOOST_TEST_MODULE Miscellaneous
#include <boost/test/unit_test.hpp>

namespace tests {

std::ostream&
print_one(std::ostream& os)
{
    return os;
}

template <class A0, class... Args>
std::ostream&
print_one(std::ostream& os, const A0& a0, const Args&... args)
{
    os << a0;
    return print_one(os, args...);
}

template <class... Args>
std::ostream&
print(std::ostream& os, const Args&... args)
{
    std::ostream& result = print_one(os, args...);
    os.flush();
    return result;
}

template <class... Args>
std::ostream&
print(const Args&... args)
{
    static std::mutex m;
    std::lock_guard<std::mutex> lg(m);
    return print(std::cout, args...);
}

class BaseActor {
public:
    BaseActor()
        : thread_()
    {
    }
    virtual ~BaseActor()
    {
        stop();
    }

    void start()
    {
        stop();
        io_service.reset();
        work_.reset(new boost::asio::io_service::work(io_service));
        std::thread(std::bind(&BaseActor::threadFunc_, this)).swap(thread_);
    }

    void stop()
    {
        work_.reset();
        io_service.stop();
        if (thread_.joinable())
            thread_.join();
    }

public:
    boost::asio::io_service io_service;

protected:
    virtual void threadFunc_() { io_service.run(); };

protected:
    std::thread thread_;
    std::unique_ptr<boost::asio::io_service::work> work_;
};

class ActorA : public BaseActor {
public:
    std::function<void(const int&)> getDoJobAInvoker()
    {
        return io_service.wrap(std::bind(&ActorA::doJobA_, this, std::placeholders::_1));
    }

    ~ActorA() { stop(); };

public:
    boost::signals2::signal<void(const std::string&)> helloSig;
    std::atomic_int aNumber{ 0 };

protected:
    virtual void threadFunc_()
    {
        print("ActorA has started", "\n");
        io_service.run();
        print("ActorA has finished", "\n");
    };

private:
    void doJobA_(const int& num)
    {
        print("ActorA::doJobA_() from thread ", thread_.get_id(), "\n");
        print("num = ", num, "\n");
        std::ostringstream oss;
        oss << "Hello, World " << num << "!";
        helloSig(oss.str());
        aNumber.store(num);
    }
};

class ActorB : public BaseActor {
public:
    std::function<void(const std::string&)> getDoJobBInvoker()
    {
        return io_service.wrap(std::bind(&ActorB::doJobB_, this, std::placeholders::_1));
    }

    ~ActorB() { stop(); };

public:
    boost::signals2::signal<void(const int&)> intSig;

protected:
    virtual void threadFunc_()
    {
        print("ActorB has started", "\n");
        io_service.run();
        print("ActorB has finished", "\n");
    };

private:
    void doJobB_(const std::string& str)
    {
        print("ActorB::doJobB_() from thread ", thread_.get_id(), "\n");
        print("str = ", str, "\n");
        intSig(++cout);
        aString_ = str;
    }

    int cout = 0;
    std::string aString_;
};

BOOST_AUTO_TEST_CASE(BoostIOServiceTest)
{
    print("Main thread id is ", std::this_thread::get_id(), "\n");

    ActorA actorA;
    ActorB actorB;
    actorA.helloSig.connect(actorB.getDoJobBInvoker());
    actorB.intSig.connect(actorA.getDoJobAInvoker());
    actorA.start();
    actorB.start();
    actorB.intSig(0);
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

} // namespace tests

Этот код, разумеется, работает, и работает как положено, но есть у него недостаток: необходимо в деструкторах дочерних классов явно вызывать метод stop() базового класса, иначе велика вероятность, что при разрушении вызовется уже уничтоженный к этому времени сигнал, определенный в дочернем классе, а только потом остановится поток, который этот сигнал вызывает. Отсюда вопрос: как можно избавиться от необходимости явно вызывать BaseActor::stop() из деструкторов ActorA и ActorB?

Есть задача реализовать почти аналог http://uftp-multicast.sourceforge.net/, только без шифрования и список раздачи должен формироваться клиентами по определенным правилам. Клиент должен быть в виде библиотеки для C# (либо нативная библиотека с возможностью использования через p/invoke в дотнете). Переделать UFTP не подходит лицензией - библиотека должна линковаться с проприетарщиной. Рассматривается как вариант реализация C++ сервера и клиентской библиотеки с помощью http://www.nrl.navy.mil/itd/ncs/products/norm - это годный вариант по мнению ЛОРа? Или вот это заюзать: https://github.com/Eyescale/Collage (вроде как более правильный C++)? Что думает ЛОР?

Изучаю скалу. Поскольку язык весьма декларативный, то логично ожидать от него автоматической векторизации всего что только можно и исполнения его на многочисленных ядрах современных процов. Такая фича действительно есть и как её можно увидеть?

Для примера взял такой код:

object ImpossiblePuzzle extends App {
  val range = 1000
  type XY = (Int, Int)
  val step0 = for {
    x <- 1 to range
    y <- 1 to range
    if 1 < x && x < y && x + y < range
  } yield (x, y)
 
  def sum(xy: XY) = xy._1 + xy._2
  def prod(xy: XY) = xy._1 * xy._2
  def sumEq(xy: XY) = step0 filter { sum(_) == sum(xy) }
  def prodEq(xy: XY) = step0 filter { prod(_) == prod(xy) }
 
  val step2 = step0 filter { sumEq(_) forall { prodEq(_).size != 1 }}
  val step3 = step2 filter { prodEq(_).intersect(step2).size == 1 }
  val step4 = step3 filter { sumEq(_).intersect(step3).size == 1 }
  println(step4)
}

Отсюда: http://en.wikipedia.org/wiki/Sum_and_Product_Puzzle#Scala_code Но параллельного исполнения (в REPL) как-то не заметно. Как его получить?

Собирал до сих пор Qt по известному мануалу, всё, вроде было нормально, за исключением одного момента: подмодули. Как правильно управлять их списком? Если вытягивать все, то система сборки пытается собрать каждый из них, а там куча таких, которые в принципе поломаны.

Вторая проблема - решил сегодня обновиться как обычно, но не тут то было:

$ git pull
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

На gitorious.org при этом висит какое-то странное объявление, что их покупают и нужно куда-то переезжать:

System notice: Gitorious is being acquired by GitLab and gitorious.org will shut down end of May. Please import your repositories to GitLab.com - Read about it

Поменял протокол и адрес репозитория на https://gitorious.org/qt/qt5.git - постоянно получаю теперь примерно такую хрень на случайных подмодулях:

remote: Counting objects: 2259, done.
remote: Compressing objects: 100% (1586/1586), done.
remote: Total 1826 (delta 1416), reused 262 (delta 212)
Receiving objects: 100% (1826/1826), 450.24 KiB | 277.00 KiB/s, done.
Resolving deltas: 100% (1416/1416), completed with 219 local objects.
From https://gitorious.org/qt/qtwebengine
   ee7af79..c9fad2c  5.4        -> origin/5.4
   9beac6f..72ff0b7  5.4.1      -> origin/5.4.1
 * [new branch]      5.5        -> origin/5.5
   4557ccd..f4c03d6  dev        -> origin/dev
 * [new tag]         v5.4.1     -> v5.4.1
Submodule path 'qtwebengine': checked out '4eceed9ac0b646238e76d77569a619d4dc515ba5'
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.
Unable to fetch in submodule path 'qtwebengine/src/3rdparty'
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.
Unable to fetch in submodule path 'qtwebkit'

В общем, как нынче правильно готовить Qt из сырцов?

Интернет-функции, конечно, не работают. Уже который день UE46ES7507 пишет, что не видит этих ваших инторнетов. Из-за этого нельзя воспользоваться ни одним приложением, работающим с инетом. Даже по скайпу не поговорить. Нашел вот новость: http://www.myce.com/news/smart-tv-mayhem-sony-samsung-users-central-servers-g...

И вот возникает резонный вопрос: какой урод так придумал?

ЗЫ интересно, что самсунговский же UE22F5410 при этом такими проблемами не страдает и интернет-приложения в нем работают.

Из статьи [вброс]Почему объектно-ориентированное программирование провалилось?

Ричард Гэбриел неожиданно сравнивает нынешнюю ситуацию с ООП с провалом эфиродинамики в физике начала 20 века, когда, в сущности, произошла “тихая революция”. Молодые сторонники теории относительности, массово пришедшие в номенклатуру университетов, тогда постепенно захватили власть в области преподавания физики, навязав свою, столь любимую интеллектуалами того времени, теорию относительности широким массам физиков. На самом деле, в то время имелись как положительные эксперименты и опыты, подтверждавшие существование эфира, так и отрицательные. Первые были полностью проигнорированы и исключены административными мерами из всех учебников физики, после чего эфир был незаслуженно “закрыт” и отправлен в отставку, и вот уже нынешнее поколение студентов-физиков даже и не знает о тех весьма успешных опытах по обнаружению эфирного ветра. “Ну и где мы теперь, с этой вашей красивой теорией относительности, кто-нибудь может мне назвать хоть какие-то реально-практические результаты её применения в вашей обыденной жизни после целого века её ковыряния и массового насаждения?” – как всегда язвительно вопрошает Гэбриел.

Значит, чел откровенно не в теме, но, вместо занятий ликбезом, объясняет все противоречия собственной картины мира и реальности... заговором! Вот что интересно: все функциональщики так мыслят или есть среди них люди, способные критически относиться и к ФП тоже?

Новость в продолжение дискуссии, начатой в «Геномы прокариот - Linux, эукариот - Windows»

Ъ:

In the current study, Johan Jakobsson and his colleagues show that retroviruses seem to play a central role in the basic functions of the brain, more specifically in the regulation of which genes are to be expressed, and when. The findings indicate that, over the course of evolution, the viruses took an increasingly firm hold on the steering wheel in our cellular machinery. The reason the viruses are activated specifically in the brain is probably due to the fact that tumours cannot form in nerve cells, unlike in other tissues.

Из чего следует, что DNA_Seq был неправ не ответил на вопрос. А кто ответил - был неправ.