1. Куча / Говнокод #27765

    +1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    waiting_for_data(info, {Driver,Socket,Data},
                     #state{socket=Socket, driver=Driver, driver_mod=DriverMod, peer=Peer, control=Control, list=List} = State) ->
        %% The meat of the whole project: process a function call and return
        %% the data
        try erlang:binary_to_term(Data) of
            {{CallType,M,F,A}, Caller} when CallType =:= call; CallType =:= async_call ->
                {ModVsnAllowed, RealM} = check_module_version_compat(M),
                case check_if_module_allowed(RealM, Control, List) of
                    true ->
                        case ModVsnAllowed of
                            true ->
                                WorkerPid = erlang:spawn(?MODULE, call_worker, [CallType, RealM, F, A, Caller, Socket, Driver, DriverMod]),
                                ?log(debug, "event=call_received driver=~s socket=\"~s\" peer=\"~s\" caller=\"~p\" worker_pid=\"~p\"",
                                     [Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), Caller, WorkerPid]),
                                {keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
                            false ->
                                ?log(debug, "event=incompatible_module_version driver=~s socket=\"~s\" method=~s module=~s",
                                     [Driver, gen_rpc_helper:socket_to_string(Socket), CallType, RealM]),
                                waiting_for_data(info, {CallType, Caller, {badrpc,incompatible}}, State)
                        end;
                    false ->
                        ?log(debug, "event=request_not_allowed driver=~s socket=\"~s\" control=~s method=~s module=~s",
                             [Driver, gen_rpc_helper:socket_to_string(Socket), Control, CallType, RealM]),
                        waiting_for_data(info, {CallType, Caller, {badrpc,unauthorized}}, State)
                end;
            {cast, _M, _F, _A} = Cast ->
                handle_cast(Cast, State),
                {keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
            BatchCast when is_list(BatchCast) ->
                [handle_cast(Cast, State) || Cast <- BatchCast],
                {keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
            {abcast, Name, Msg} ->
                _Result = case check_if_module_allowed(erlang, Control, List) of
                    true ->
                        ?log(debug, "event=abcast_received driver=~s socket=\"~s\" peer=\"~s\" process=~s message=\"~p\"",
                             [Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), Name, Msg]),
                        Msg = erlang:send(Name, Msg);
                    false ->
                        ?log(debug, "event=request_not_allowed driver=~s socket=\"~s\" control=~s method=~s",
                             [Driver, gen_rpc_helper:socket_to_string(Socket), Control, abcast])
                    end,
                {keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
            {sbcast, Name, Msg, Caller} ->
                Reply = case check_if_module_allowed(erlang, Control, List) of
                    true ->
                        ?log(debug, "event=sbcast_received driver=~s socket=\"~s\" peer=\"~s\" process=~s message=\"~p\"",
                             [Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), Name, Msg]),
                        case erlang:whereis(Name) of
                            undefined -> error;
                            Pid -> Msg = erlang:send(Pid, Msg), success
                        end;
                    false ->
                        ?log(debug, "event=request_not_allowed driver=~s socket=\"~s\" control=~s method=~s",
                             [Driver, gen_rpc_helper:socket_to_string(Socket), Control, sbcast]),
                         error
                end,
                waiting_for_data(info, {sbcast, Caller, Reply}, State);
            ping ->
                ?log(debug, "event=ping_received driver=~s socket=\"~s\" peer=\"~s\" action=ignore",
                     [Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer)]),
                {keep_state_and_data, gen_rpc_helper:get_inactivity_timeout(?MODULE)};
            OtherData ->
                ?log(debug, "event=erroneous_data_received driver=~s socket=\"~s\" peer=\"~s\" data=\"~p\"",
                     [Driver, gen_rpc_helper:socket_to_string(Socket), gen_rpc_helper:peer_to_string(Peer), OtherData]),
                {stop, {badrpc,erroneous_data}, State}
        catch
            error:badarg ->
                {stop, {badtcp,corrupt_data}, State}
        end;
    
    %% Handle the inactivity timeout gracefully
    waiting_for_data(timeout, _Undefined, #state{socket=Socket, driver=Driver} = State) ->
        ?log(info, "message=timeout event=server_inactivity_timeout driver=~s socket=\"~s\" action=stopping",
             [Driver, gen_rpc_helper:socket_to_string(Socket)]),
        {stop, normal, State};
    
    waiting_for_data(info, {DriverClosed, Socket} = Msg, #state{socket=Socket, driver_closed=DriverClosed} = State) ->
        handle_event(info, Msg, waiting_for_data, State);
    
    waiting_for_data(info, {DriverError, Socket, _Reason} = Msg, #state{socket=Socket, driver_error=DriverError} = State) ->
        handle_event(info, Msg, waiting_for_data, State).

    Срочно требуется учитель литературы, чтобы объяснить, что хотел сказать автор.

    Запостил: CHayT, 22 Октября 2021

    Комментарии (37) RSS

    • Срочно требуется перевод на PHP.
      Ответить
    • Переведи на Coq.
      Ответить
    • > process a function call and return the data

      Тут скорее учителя философии надо...
      Ответить
    • Оттуда же. Царский анролл:
      %% Extract the node name from a gen_rpc client process name
      %% The naming scheme of gen_rpc.client. is exactly 15 characters
      %% that we extract/ignore as head of the list
      extract_node_name([_,_,_,_,_,_,_,_,_,_,_,_,_,_,_|Name]) ->
          Node = case string:tokens(Name, "/") of
              [TNode, _Key] -> TNode;
              [TNode] -> TNode
          end,
          erlang:list_to_atom(Node).
      Ответить
      • > to_atom

        И тут атомы жрут? Хотя... в прошлой функции это и клеили, т.е. этот атом уже существовал?
        Ответить
        • Ага, сначала склеили, а теперь парсят. Но если в эту функцию насрать неправильными данными, то из неё тоже атомы утекут.
          P.S. Есть `list_to_existing_atom()`, которую можно было здесь заюзать.
          Ответить
          • > сначала склеили а потом парсят

            А там нельзя как-то туплой это прокинуть? Обязательно через строку?
            Ответить
            • Клеить атомы — это большое no-no, и хорошая индикация полного пиздеца в рахитектуре.
              Тут чел этим занимается, т.к. регистрировать процессы по имени VM позволяет только если имя — атом. Однако, стандартная либа это ограничение снимает, и через прокси-модуль можно и тупл зарегистрировать. Главное чтобы маппинг имён в пиды где-то хранился, например в ets.
              Ответить
              • > пиздеца в архитектуре

                Так то да, нафиг регать именованные процессы, если это не какие-то well-known сервисы...
                Ответить
                • Ну да. Именованные процессы нужны для уникальных вещей каких-то, а для динамических процессов делаются пулы и прочие simple_one_for_one супервизоры, а пиды процессов прокидываются между ними при инициализации сессии.
                  Ответить
        • Очередная бездарность... Которая желает подняться на грязном пиаре, оскорбляя чувства ветеранов и сочувствующим им... Как цинично.
          Ответить
    • >
      [_,_,_,_,_,_,_,_,_,_,_,_,_,_,_|Name]


      Паттерн «поезд»?

      Если ты не голубой, нарисуй вагон-другой.
      Ответить
      • Кто-то просто не знает про такой

        extract_node_name("gen_rpc.client" ++ Name) ->


        Паттерн-нятчинг. Конечно, это градус леденящего пиздеца не сильно уменьшает.
        Ответить
        • P.S. Чел, написавший это, перекатился на тупескрипт, что характерно, где мы от всей души пожелаем ему оставаться.
          Ответить
      • [_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_|Name]
        Ответить
    • %% Simply launch a connection to a node through the appropriate
      %% supervisor. This is a serialization interface so that
      handle_call({start_client, NodeOrTuple}, _Caller, undefined) ->
        ...

      Знаете этот троп, когда персонаж хочет сообщить что-то важное, но в середине предложения его убивают?
      Ответить
    • _WorkerPid = erlang:spawn(fun() -> find_worker(Key) ! Payload end)
          ...

      Да пошла она няхуй, сериализация няканная.
      Ответить
      • ...Автор либы теперь вместе с ASD_77 пилит опердени на тайпскрипте. И это прекрасно.
        Ответить
      • Весь код переписался в одну строчку?
        Ответить
        • Это просто упрощённая модель того, что там делалось. Сообщения зачем-то слались из отдельного временного процесса, естественно вся сериализация этих сообщений шла по пизде.
          Ответить
          • > сериализация

            А, под сериализацией тут имелась в виду не упаковка аргументов в блоб, а порядок пакетов...
            Ответить
    • Извращенцы.
      Ответить
      • Странно, никто не откликнулся на твой призыв. А давайте позовём их громче: ИЗ-ВРА-ЩЕН-ЦЫ!
        Ответить
    • Кто-нибудь догадается без контекста, что означает переменная SendTO ?
      Ответить
      • Таймаут отправки?
        Ответить
        • Ты Панагиотис Парадомитсос?
          Ответить
          • Paamayim Nekudotayim
            Ответить
          • У меня теперь все длинные имена ассоциируются с Прокуратором Самоваром.
            Ответить
          • К слову, правильнее писать «Панайотис».

            У греков сочетание «гамма-иота» читается как «й».

            У шведов вроде тоже «g» перед некоторыми гласными превращается в «й».
            Ответить
          • Я просто читала много сишного кода.
            Ответить
      • техосмотр же отменили
        Ответить

    Добавить комментарий