Информация
Услуги
  • Внедрение
  • Настройка
  • Поддержка
  • Ремонт
Контакты
Новинка
Распродажа
Новости
Доставка
Оплата
Загрузки
  • Прошивки
    • WinBox
    • RouterOS
    • Мобильные приложения MikroTik
    • Архив
  • Changelogs
  • RouterOS
  • Мобильные приложения MikroTik
  • Архив
Форум
Настройка
    info@mikrotik.moscow
    +7 495 320-55-52
    Заказать звонок
    Mikrotik.moscow
    Каталог
    • Акции
      Акции
    • Маршрутизаторы
      Маршрутизаторы
    • Коммутаторы
      Коммутаторы
    • Радиомосты и уличные точки доступа
      Радиомосты и уличные точки доступа
    • Wi-Fi для дома и офиса
      Wi-Fi для дома и офиса
    • LTE/5G
      LTE/5G
    • Powerline адаптеры
      Powerline адаптеры
    • IoT устройства
      IoT устройства
    • Оборудование 60 ГГц
      Оборудование 60 ГГц
    • Материнские платы RouterBOARD
      Материнские платы RouterBOARD
    • Корпуса
      Корпуса
    • Интерфейсы
      Интерфейсы
    • SFP/QSFP трансиверы
      SFP/QSFP трансиверы
    • Аксессуары
      Аксессуары
    • Антенны
      Антенны
    • Архив
      Архив
    Войти
    0 Сравнение
    0 Избранное
    0 Корзина
    Скачать WinBox Скачать Прошивки Форум > RouterOS Форум > SwOS Форум > Железо
    Mikrotik.moscow
    Каталог
    Войти
    0 Сравнение
    0 Избранное
    0 Корзина
    Mikrotik.moscow
    Телефоны
    +7 495 320-55-52
    Заказать звонок
    0
    0
    0
    Mikrotik.moscow
    • +7 495 320-55-52
      • Назад
      • Телефоны
      • +7 495 320-55-52
      • Заказать звонок
    • info@mikrotik.moscow
    • г. Москва, ул. Бакунинская, 84
    • Пн-Пт: 09-00 до 18-00
      Сб-Вс: выходной


    • Кабинет
    • 0 Сравнение
    • 0 Избранное
    • 0 Корзина
    Главная
    Форум
    RouterOS
    Несколько неофициальных операторов, которые довольно забавные.

    Несколько неофициальных операторов, которые довольно забавные.

    Форумы: RouterOS, Аппаратное обеспечение, SwOS, Обратная связь, Объявления, Сторонние инструменты
    Поиск  Пользователи  Правила  Войти
    Страницы: 1
    RSS
    Несколько неофициальных операторов, которые довольно забавные., RouterOS
     
    GreenDog72
    Guest
    #1
    0
    13.01.2023 16:14:00
    Этот пост будет интересен только ограниченному кругу людей. Если вы не знакомы со скриптингом Mikrotik или никогда не использовали функции, то, скорее всего, это сообщение не для вас, но всё равно можете почитать.

    Я рассмотрю два оператора, которые нашёл, нажав F1, находясь в скобках. Первый оператор называется quote. Это унарный оператор ‘>’, который работает точно так же, как quote в LISP, если кто-то знаком с этим. Он возвращает то, к чему применяется, как литерал. Даже код. Это значит, что его можно использовать как альтернативный способ создания функций.

    Вот все три способа создания функции, которые я знаю, включая этот новый оператор в действии:  
    :global func1 do={:put "test1"}  
    :global func2 [parse ":put \"test2\""]
    :global func3 (>[:put "test3"])

    Интересно, что все три метода дают немного разные результаты. Вот что вы получаете, если вывести их все:  
    put $func1  
    # ;(evl (evl /putmessage=test1))  
    put $func2  
    # (evl /putmessage=test2)  
    put $func3  
    # (evl (evl /putmessage=test3))  

    func1 — это массив из 2 элементов, где второй — это объект кода. Два других — сами объекты кода. Если вы не понимаете, о чём речь, попробуйте применить typeof к ним. Практически все они обрабатываются одинаково, и не имеет значения, какой способ вы используете для создания функций. Технически parse даёт небольшое повышение производительности и занимает чуть меньше памяти, потому что нет лишних evl и массивов, но это, скорее всего, не имеет значения для большинства задач.

    Я точно ещё не полностью изучил возможности этого оператора, например, не пробовал использовать его со строкой, в которой есть вставки команд — это может быть интересно. Но я двигаюсь дальше.

    Следующий оператор, о котором я расскажу, называется «activate in environment». Я впервые наткнулся на него в июне прошлого года, когда коллега оставил о нём пост на форуме, и даже rextended был сбит с толку, так что я отложил это. Но теперь я наконец разгадал его, и мне кажется, что он довольно крутой.

    Оператор выглядит так: <%%. Он требует небольшого объяснения. Под «окружением» здесь понимается просто «набор доступных переменных». Этот оператор запускает объект кода слева с добавлением массива справа в его окружение.

    Например, допустим, вы создаёте следующую функцию:  
    :global add (>[:return ($0+$1)])
    # Теперь её можно вызвать так, чтобы вывести 3  
    :put [$add 1 2]
    # Чтобы использовать новый оператор с тем же результатом, делаем так:  
    :put ($add <%% {1;2})

    Правка: использовать скобки здесь не получится, потому что $0 — имя функции. Надо использовать $1+$2, и окружение, переданное в <%%, было бы {“add”;1;2} для эквивалентности.

    Если вы внимательно посмотрели, то заметили, что содержимое массива обращается через $0 и $1. Массив, который передаётся, становится окружением (набором переменных) для функции, так что нулевой элемент доступен через $0, первый — через $1.

    Сам по себе этот приём не очень мощный, так что давайте посмотрим на другой пример:  
    :global f (>[:put $output])
    # Мы нигде не определяли output. Его нет. И всё же:  
    ($f <%% {output="Я существую!"})  
    # Это добавит переменную output из массива в окружение, позволяя функции получить к ней доступ  
    # Сейчас это всё равно что  
    [$f output="Я существую!"]

    Это гораздо интереснее! Мы можем создавать объекты, которые инкапсулируют параметры функции, и передавать их функции. Уверен, это уже вызывает у некоторых идеи. Но если вам это понравилось, у меня есть пример, который вас точно удивит.

    Что если я скажу, что массив, который вы передаёте, передаётся по ссылке?  
    :global inc (>[:set $counter ($counter+1)])
    :global c {counter=0}  
    # Что, как вы думаете, произойдёт здесь?  
    ($inc <%% $c)  
    # Здесь уже нет эквивалента с использованием скобок  
    # Это уже НЕ эквивалент  
    [$inc $c]

    Поверьте или нет, это работает именно так, как вы думаете. Выведите значение $c после этого — увидите, что counter действительно увеличился до 1. Теперь мы можем передавать объект (массив), работать с его переменными и сохранять изменения. Это новая функциональность, уникальная для этого оператора. Это почти как объектно-ориентированное программирование, хотя и не настолько мощное.

    Я понимаю, почему Mikrotik не документирует эту возможность и не ожидаю, что так будет в будущем. Это нишевая функция, и лишь немногие пользователи смогут найти для неё полезное применение. Я даже не утверждаю, что у меня оно есть. Но это ещё один интересный инструмент для написания нестандартных скриптов, и я с нетерпением жду, какие возможности он откроет.
     
     
     
    rextended
    Guest
    #2
    0
    11.06.2024 06:57:00
    Извиняюсь за задержку, я не заметил этот пост раньше, отличная работа, спасибо.
     
     
     
    Sertik
    Guest
    #3
    0
    13.06.2024 14:33:00
    :global f1 do={:return 5}  
    :global f2 do={:return 7}  
    :global add (>[:return ([$f1]+[$f2])])
    :put ($add <%% {$f1;$f2}) 12  

    :global f1 do={:return $1}  
    :global f2 do={:return $1}  
    :global add (>[:return ([$f1 2]+[$f2 3])])
    :put ($add <%% {$f1;$f2}) 5  

    :global f1 do={:return [/system clock get time]}
    :global f2 do={:return [/system clock get date]}
    :global add (>[:return ([$f1]." ".[$f2])])
    :put ($add <%% {$f1;$f2}) 17:37:48 jun/13/2024  

    :global f1 do={:return [/system clock get time]}
    :global f2 do={:return [/system clock get date]}
    :global add1 (>[:return ([$f1]." “.[$f2])])
    :global add2 (>[:return ([$f2].” ".[$f1])])
    :put ($add1 <%% {$f1;$f2})  
    :put ($add2 <%% {$f2;$f1})  
    17:46:31 jun/13/2024  
    jun/13/2024 17:46:32  

    Очень интересно!
     
     
     
    Sertik
    Guest
    #4
    0
    13.06.2024 15:05:00
    :global inc (>[:set $counter ($counter+1)]) :global c {counter=0} :put ($inc <%% $c) :put $c counter=1 !
     
     
     
    Amm0
    Guest
    #5
    0
    13.06.2024 18:24:00
    Не могу поверить, что раньше не замечал этого, хотя сам из целевой аудитории. Отличная находка. Некоторые ребята заметили тип (> ) «op» некоторое время назад (возможно, именно здесь?). Но <%% для меня новинка. Самый простой пример из ваших двух находок (>[]) и (<%%) вероятно такой:
    :global x (>[:put "$0 $1 $2 $3 $named"])
    ($x <%% {1;2;3;4;named="blah"}) 1 2 3 4 blah  

    Или, в основном для @rextended, порядок массива не важен — либо “безымянные” элементы используют $0 $1, а «именованные» (кортежи) не имеют $, потому что у них $name:  
    ($x <%% {1;named="blah";2;3;4}) 1 2 3 4 blah  
    Тот же порядок, что и выше…  

    Если хотите углубиться, есть тема “Positional Arguments in Array Function - $0 vs $1 ?”: http://forum.mikrotik.com/t/positional-arguments-in-array-function-0-vs-1/154024/1  

    Еще одна странность — любые массивы с ключ-значение сортируются по алфавиту, не знаю почему, возможно, из-за парсинга “s-выражений” (см. ниже):  
    :put {z=1;m=13;a=1} a=1;m=13;z=1  
    В то время как обычные списки остаются упорядоченными:  
    :put ("z","m","a") z;m;a  

    Если вы знакомы с LISP, скрипты RouterOS становятся понятнее: всё — это список, включая код. S-выражения из “:put” — это, можно сказать, главный признак. CLI и скрипты парсятся в S-выражения (с :global, превращающимся в переменные окружения для поведения, похожего на shell). В /console/inspect можно увидеть формируемое разрешенное AST для парсинга.  

    На мой взгляд, <%% должен просто работать с существующим оператором точка (.), если идти по этому пути. Он уже реализован, только не разрешён с функциями — вместо этого это просто путаница, когда пытаешься использовать . для конкатенации строк с типом массива.  

    Понимаю, почему Mikrotik не документирует это и вряд ли будет. Это ниша, и только горстка пользователей найдёт практическое применение. Я даже не утверждаю, что у меня есть такое применение. Но это ещё один своеобразный инструмент для написания интересных скриптов, и меня радуют открывающиеся возможности.  

    На сегодня команда RouterOS не принимает массив в виде аргументов — для «языка конфигурации», который поддерживает богатую работу со списками и массивами, невозможность использовать массив параметров для /ip/address или чего-то подобного — немного смешно…  

    Это всегда меня раздражало. Т.е. с чисто теоретической точки зрения командe не должна требоваться [:parse], чтобы принимать массив: команды должны быть полноценными функциями для скриптинга. Я так и не понял, как избежать [:parse] в таких случаях. Используя :parse, ты вынужден возиться с экранированием и теряешь проверку синтаксиса — а это совсем не идеально.

    Я думал, возможно, какой-то приём с этим “<%%” сработает. Но не смог придумать, как сделать, в идеале, такое:  
    :global ipAddrSettings {numbers="*56;comment="blah"}  
    /ip/address/set <%% $ipAddrSettings  

    Но это не работает… Пытался и другие варианты с обёртками, порядком и так далее.  

    Отсутствие этого усложняет написание более простых скриптов дефолтных конфигураций — ведь хотелось бы просто прокинуть массив в /ip/address/set (или куда угодно) и не расписывать вручную каждый параметр для каждой команды в дефолтном конфиге.
     
     
     
    rextended
    Guest
    #6
    0
    13.06.2024 20:22:00
    Массив (см. мои предыдущие посты) всегда упорядочен так: сначала неназванные значения, упорядоченные по числу, затем именованные значения, упорядоченные по имени… поэтому {z=1;m=13;a=1} внутри упорядочены как {a=1;m=13;z=1}, но (“z”,“m”,“a”) на самом деле соответствуют ->0=“z”, ->1=“m” и ->2=“a”, так что вот почему их считают неупорядоченными. Вот почему :put {“k”;“Name2”=“blah”;“~”=“last”;7=“j”;5;“z”;“name1”=“blah”;“!”=“first”} выводится как k;5;z;!=first;7=j;Name2=blah;name1=blah;~=last — неименованные значения остаются в исходном порядке, а именованные сортируются по ASCII. Ещё если добавить 20-й элемент, все пропущенные значения с 3 по 18 будут добавлены (пустые):  
    :local xtest {“k”;“Name2”=“blah”;“~”=“last”;7=“j”;5;“z”;“name1”=“blah”;“!”=“first”}  
    :set ($xtest->19) “tw”  
    :put $xtest  
    результат: k;5;z;;;;;;;;;;;;;;;;;tw;!=first;7=j;Name2=blah;name1=blah;~=last

    С этими примерами можно делать всё более сложные и интересные вещи…  

    :global allMyFunctionsAndVariables [:toarray “”]
    :set ($allMyFunctionsAndVariables->“!!help”) do={  
    :put “$[:typeof $0] 0=>$0<”
    :put “вы вызвали allMyFunctionsAndVariables напрямую…”  
    :put “немного помощи здесь…”  
    :return [:nothing]
    }  
    :set ($allMyFunctionsAndVariables->“testfunc”) do={  
    :put “$[:typeof $0] 0=>$0<”
    :put “$[:typeof $1] 1=>$1<”
    :put “$[:typeof $2] 2=>$2<”
    :put “$[:typeof $3] 3=>$3<”
    :put “$[:typeof $4] 4=>$4<”
    :put “$[:typeof $5] 5=>$5<”
    :put “$[:typeof $6] 6=>$6<”
    :return [:nothing]
    }  
    :set ($allMyFunctionsAndVariables->“somenumber”) 77  
    :set ($allMyFunctionsAndVariables->3) “:put 999”  

    $allMyFunctionsAndVariables ($allMyFunctionsAndVariables->“testfunc”)  5 4 3  
    :put ($allMyFunctionsAndVariables->“somenumber”)  
    [:parse ($allMyFunctionsAndVariables->3)]
     
     
     
    Sertik
    Guest
    #7
    0
    14.06.2024 07:28:00
    То есть, в массив можно поместить как данные, так и исполняемый код. Это известно уже давно. На самом деле оказывается, что всё можно уместить в одну структуру.
     
     
     
    Sertik
    Guest
    #8
    0
    14.06.2024 07:37:00
    Нам нужны примеры оправданного и эффективного использования (>[]) и (<%%)
     
     
     
    rextended
    Guest
    #9
    0
    14.06.2024 07:43:00
    Лучше проще. В конце концов, мы всё же говорим о роутере, а не о языке программирования для разработки кто знает какого приложения.
     
     
     
    Sertik
    Guest
    #10
    0
    14.06.2024 11:41:00
    Меня интересуют все секреты Mikrotik!
     
     
     
    Amm0
    Guest
    #11
    0
    14.06.2024 17:00:00
    /console/inspect всегда рассказывает кое-что про скриптинг. Так, по поводу синтаксиса (> )… Mikrotik действительно использует термин LISP «quote»…  
    /console/inspect request=completion input="("  
    TYPE        COMPLETION  STYLE        OFFSET  PREFERENCE  SHOW  TEXT  
    completion  (           syntax-meta       1  75          нет    начало подвыражения  
    completion  $           syntax-meta       1  75          нет    подстановка  
    completion  [ syntax-meta 1 75 нет начало подстановки команды
    completion  {           syntax-meta       1  75          нет    начало значения массива …  
    completion  >           syntax-meta       1  75          нет    > quote >  
    completion              syntax-meta       1  75          нет    quote  
    completion       none              1  -1          нет    буквальное значение, состоящее только из цифр, букв и символов ._  

    А по оператору <%% — это термин «activate in environment»:  
    /console/inspect request=completion input="(\$fn <"  
    Колонки: TYPE, COMPLETION, STYLE, OFFSET, PREFERENCE, SHOW, TEXT  
    TYPE        COMPLETION  STYLE               OFFSET  PR  SHOW  TEXT  
    #… completion  <%%         syntax-meta              5  75  нет   > activate in environment > >  
    completion  (           syntax-meta              6  75  нет    начало подвыражения  
    completion  $           syntax-meta              6  75  нет    подстановка  
    completion  [ syntax-meta 6 75 нет начало подстановки команды
    completion  {           syntax-meta              6  75  нет    начало значения массива  
    completion  >           syntax-meta              6  75  нет    quote  
    completion              syntax-meta              6  75  нет    quote  
    completion  fn          variable-parameter       6  96  да    …  

    Например, с помощью «activate in environment» <%% можно строить цепочки вызовов функций:  
    :global add do={ ($1 + 1) }  
    :put ($add <%% $add <%% $add <%% $add <%% $add <%% {0})  
    ;5  

    И опять же, было бы в 1000 раз полезнее, если бы сами команды роутера, а не только пользовательские функции, принимали массивы как аргументы. Ведь всё тут — это список (или «массив»), включая «код». Здесь :put рассказывает ещё одну часть истории скриптинга.  

    :global fn do={:put "$1 $2"}  
    :put $fn  
       # вывод:      ;(evl (evl /putmessage=(. $1   $2)))  
    :put [:typeof $fn]
       # вывод:      array  
    :put [:len $fn]
       # вывод:      2  
    :put [:typeof ($fn->1)]
       # вывод:      code  

    А :put показывает эффект оператора (>""): это «code»-тип и печатается, потому что оператор «quote» (>) заставляет операцию объединения строк «пропускать» исполнение, в то время как добавление вызывает выполнение типа «code»:  

    :put (>"text $1")  
       # вывод:     (. text  $1)  
    :put [(>"text $1")]
       # вывод:     text  

    Для другого примера с :put, чтобы понять, что происходит… Тут есть функция, и хоть она и не используется в скрипте, <%%, похоже, является «примитивом» в типе кода:  

    :global fn do={:global fn; $fn}                      
    :put $fn                      
             # вывод:      ;(evl (evl /globalname=$fn) (<%% $fn (> $fn)))  

    :global fn do={:global fn; [$fn]}
    :put $fn                      
             # вывод:      ;(evl (<%% (evl (evl /globalname=$fn);(<%% $fn (> $fn))) ))  

    И трилогия «секретов скриптинга» кроется в:  
    /environment/print — где показываются распарсенные :global переменные. Это всё забавные фишки… но я бы не рекомендовал использовать их в тех скриптах, «которые не должны давать сбой», ведь <%% или >[ в будущем могут просто убрать из какой-то схемы, показанной в /console/inspect, которая их сейчас поддерживает.
     
     
     
    Amm0
    Guest
    #12
    0
    17.06.2024 13:18:00
    Я написал более практичный пример синтаксиса $(>), «quote» / «op» вчера, $qkeys. Это позволяет назначать нажатия клавиш для выполнения команд в виде меню-дерева. Вы можете сделать массив $qkeymap, содержащий любые команды, которые регулярно используете. Затем просто запускайте «$qkeys» в CLI, и одна клавиша будет запускать любую команду, определённую в массиве. Что-то вроде «горячей клавиши», но команды задаются в массиве, который можно менять — используя тип «quote» (также известный как «op»). Функция $qkeys принимает массив с действиями, которые надо выполнять при нажатии клавиш, определённый в ($qkeymap). Для работы требуется версия 7.15, но только потому, что используется [:convert from=byte-array] — новая команда (хотя её можно заменить на функцию из @rextended, которая конвертирует ASCII-код в строку).

    :global qkeys
    :global qkeysmap

    :set qkeysmap {
       c = {"container"; {
           l = (>[/log/print follow-only proplist=message where topics~"container"])
           p = (>[/container/print])
           e = (>[/container/env/print])
           m = (>[/container/mounts/print])
       }}
       "4" = {"ip"; {
           a = {"address"; (>[/ip/address/print])}
           r = {"route"; (>[/ip/route/print])}
           f = {"firewall"; {
               f = {"filter"; (>[/ip/firewall/filter/print])}
               n = {"nat"; (>[/ip/firewall/nat/print])}
               m = {"mangle"; (>[/ip/firewall/mangle/print])}
               c = {"connections"; (>[/ip/firewall/connection/print])}
           }}
       }}
       "6" = {"ipv6"; {
           a = {"address"; (>[/ipv6/address/print])}
           r = {"route"; (>[/ipv6/route/print])}
           "-" = {"disable"; (>[/ipv6/settings/set disable-ipv6=yes])}
           "+" = {"enable"; (>[/ipv6/settings/set disable-ipv6=no])}
       }}
       i = {"interfaces"; (>[/interface/print])}
       v = {"vlans"; (>[/interface/vlan/print])}
       b = {"bridge"; {
           "E" = {"export"; (>[/interface/bridge/export])}
           v = {"vlans"; (>[/interface/bridge/vlan/print])}
           p = {"ports"; (>[/interface/bridge/port/print])}
       }}
       r = {"board"; (>[/system/routerboard/print])}
       l = {"lte mon"; (>[/interface/lte/monitor [find]])}
       e = {"export"; {
           f = {"file"; (>[:export file=[/terminal/ask prompt=" \1B[1;33m?\1B[0m file name:"]])}
           p = {"print"; (>[:export])}
       }}
       "`" = {"edit macros"; (>[{/system/script/edit qkeys source; (>[/system/script/run qkeys])}])}
       "C" = {"clear"; (>[:put "\r\1Bc"])}
    }

    :set qkeys do={
       :global qkeys
       :global qkeysmap
       :local loop true
       :local currmap $qkeysmap
       :local currpath ""
       :local printHeader do={
           :local cmds "\1B[1;36m$currpath >\1B[0m"
           :foreach k,v in=($currmap, {q={"quit"}}, {"/"={"top"}}) do={
               :set cmds "$cmds  \1B[1;32m($[:tostr $k]) \1B[2;39m$[:tostr ($v->0)] \1B[0m"
           }
           :put $cmds
       }
       :while (loop) do={
           # нормализуем имя, чтобы у всех ключей меню было название
           :foreach k,v in=$currmap do={
               :if ([:typeof $v]="op") do={
                   :set ($currmap->$k) {"($[:pick [:tostr $v] 10 30])"; $v}
               }
           }
           $printHeader currmap=$currmap currpath=$currpath

           # получаем нажатую клавишу
           :local kcode [/terminal/inkey]
           :local key ([:convert to=raw from=byte-array {$kcode}])

           # ищем в текущем меню
           :local currval ($currmap->$key)
           :if ([:typeof $currval]!="nil") do={
               :local currname ($currval->0)
               :local currdata ($currval->1)
               :local currtype [:typeof $currdata]
               # нашли вложенный массив (следующий уровень меню)
               :if ($currtype="array") do={
                   :set currpath "$currpath \1B[1;36m> $currname\1B[0m"
                   :set currmap $currdata
               }
               # нашли функцию (op) для запуска
               :if ($currtype="op") do={
                   :put "$currpath \1B[1;31m> $currname\1B[0m"
                   :local rv [$currdata]
                   :put "\t# \1B[2;35m$[:pick [:tostr $rv] 0 64]\1B[0m"
               }
           } else={
               # клавиша не найдена в текущем меню
           }
           # если нажали «q» — выходим
           :if ($key~"(q|Q)") do={ :set loop false }
           # если нажали «/» — возвращаемся в главное меню
           :if ($kcode=47) do={ :set currmap $qkeysmap; :set currpath "" }
       }
       :return [:nothing]
    }

    Если сохранить скрипт в /system/script под именем “qkeys”, в верхнем меню можно редактировать его, нажав на ` (обратную кавычку). Тогда будет подсветка синтаксиса, что помогает быстрее заметить ошибки при правке массива. Если хотите, чтобы макросы сохранялись, добавьте расписание, вызывающее скрипт qkeys при запуске роутера. Запускается всё просто — сперва запускаете скрипт qkeys, а потом вводите $qkeys в CLI.



    Тут же есть связанная функция «TUI» — $INQUIRE и $CHOICES, которую я писал немного раньше, используя тип «op»: http://forum.mikrotik.com/t/inquire-prompt-user-for-input-using-arrays-choices-qkeys/167956/1
     
     
     
    Larsa
    Guest
    #13
    0
    17.06.2024 13:36:00
    Отлично!
     
     
     
    rextended
    Guest
    #14
    0
    17.06.2024 15:17:00
    Настаиваю… http://forum.mikrotik.com/t/mikrotik-events-script-new-abroach/176282/10
     
     
     
    Amm0
    Guest
    #15
    0
    17.06.2024 15:45:00
    Я нормально отношусь к тому, чтобы оставить RouterOS (и эти парсероподобные штуки в стиле lex/yacc для CLI/API) самим Mikrotik. Сейчас бы лучше они открыли процесс загрузки с помощью ONIE, GRUB или чего-то подобного — потому что на данный момент очень сложно заставить что-то вроде cilium, NokiaSR, OpenWRT и тому подобное работать на железе Mikrotik. Модифицировать RouterOS… честно говоря, не уверен, что это кому-то действительно нужно. А вот запускать cilium или что-то подобное на более бюджетном железе Mikrotik — это я бы понял.

    Я бы давно подписался под петицией за открытый исходный код для Dude, если бы она не была такой бессмысленной. Главное, что меня волнует в плане открытости — это схема базы данных SQLite, которую использует Dude. Сегодня существует уйма инструментов, которые могут обрабатывать SQLite из данных Dude и показывать их в стильном и современном интерфейсе с графиками и прочим, и всё это без использования самого UI Dude. Но, как обычно у Mikrotik, все поля в базе закодированы или запутаны в какие-то короткие коды. Несколько лет назад кто-то пытался вытащить данные с помощью Python, но смог получить всего несколько полей.
     
     
     
    Страницы: 1
    Читают тему
    +7 495 320-55-52
    info@mikrotik.moscow
    Электрозаводская, Бауманская
    Москва, ул. Бакунинская, 84с21
    Конфиденциальность Оферта
    © 2025 «Mikrotik.Moscow»
    Главная Каталог 0 Корзина 0 Избранные Кабинет 0 Сравнение Акции Контакты Услуги Бренды Отзывы Компания Лицензии Документы Реквизиты Поиск Блог Обзоры