akkerman
Рейтинг
+10.10
Сила
19.33

akkerman

Ганц Аккерман

Как получить строку из функции на Си?

Почему-то эту тему совсем не осветили в документации Crystal, упомянув только то, что передавать и получать строки (при взаимодействии с кодом на Си) можно только как указатели на UInt8. Ни одного примера на эту тему не нашёл, поэтому на всякий случай «восполню пробел»:

lib LibC
  fun ctermid : UInt8*
end
puts String.new(LibC.ctermid)

Функция ctermid возвращает указатель на строку, которая *char с точки зрения языка Си, и она же UInt8* (т.е. Pointer(UInt8)) в языке Crystal. После выполнения функции ctermid в jбласть памяти, адресуемую полученным из функции указателем UInt8*, будет записана последовательность байт, заканчивающаяся байтом со значением 0, что является обычным для Си способом представления строк. И хотя без проблем можно было бы получить результирующую строку, попросту пройдясь в цикле до того самого «нулевого» байта, даже от этой необходимости нас избавил рантайм языка: ведь в Crystal можно создать строку напрямую из UInt8*, что, собственно, и показано в примере выше!

Вот такой простой пример. Для домашней же проработки оставляю вам статью, в которой описаны куда более интересные трюки, допустимые при работе с внешними функциями на языке Си.

За сим до свидания — и до встречи в русскоязычной телеграмм-группе, посвящённой языку Crystal:
telegram.me/crystal_ru

hex_dump строки

Время не стоит на месте, и в Crystal версии 0.26 уже есть прекрасный встроенный метод hexbytes для декодирования строки, содержащей шестнадцатеричный дамп, — в последовательность байт.

А как сделать прямое преобразование? То есть если у нас есть строка — и нужно получить её шестнадцатеричный дамп, какой метод можно использовать?

Ответ с одной стороны пока неутешителен: нет такого метода. С другой стороны, ответ слишком сложен, потому что на архитектуре Intel делать такое преобразование быстрее всего MMX-инструкциями, а значит — использовать встроенный asm-препроцессор (что, разумеется, не будет сделано разработчиками Crystal, поскольку они поддерживают «много разных архитектур» и стараются до последнего всё-таки обходиться собственными средствами языка).

Ну а с третьей стороны — как раз собственными средствами языка всё делается достаточно просто:

def hex_dump (s : String)
  s.to_slice.each_with_object(IO::Memory.new) {|b,s| s << b.to_s(16) }.to_s
end

Здесь мы сначала говорим: «с тем, что было строкой, далее работай как с указателем на побайтовый вектор» (s.to_slice), затем для каждого из байт, на которые указывает наш «слайс», вставляем их шестнадцатеричное представление в объект типа IO::Memory, созданный на лету в конструкции each_with_object. Само преобразование из «байта» в шестнадцатеричное строковое представление ('1' => 31) осуществляется функцией с наименее очевидной в данном случае семантикой: b.to_s(16).

Ну и в конце полученный объект типа IO::Memory преобразуется в строку (.to_s), после чего эта строка и становится выходным значением hex_dump'а

Кстати, это не самый эффективный способ преобразования: hex_dump(io) был бы и проще, и быстрее в случаях наподобие puts hex_dump(s). Но эту задачку я оставлю пытливым умам на домашнюю проработку :)

Макросы: как задать режим компиляции извне?

Положим, вы хотели бы компилировать тот или иной код в зависимости от значения переменной-триггера, задающей «режим компиляции».

В Crystal это делается элементарно:
  1. Задаём переменную окружения MODE_VAR локально для процесса-компилятора
    
    MODE_VAR=1 crystal src/mutating_code.cr
    

  2. Учитываем значение этой переменной во время компиляции:
    
    {% begin %}
      {% if env("MODE_VAR") != nil %}
        puts "Do something if MODE_VAR was triggered"
      {% else %}
        puts "Do anything else if MODE_VAR environment variable is absent "
      {% end %}
    {% end %}
    

Рецепт: Передача переменных простых типов по ссылке

Предположим, вы хотите написать функцию, модифицирующую значение переменной простого типа «на лету».

Если вы сделаете вот так:

def inc(cnt : Int32)
  cnt += 1
end
n = 0
inc(n)
puts n
# "0" will be printed

— ничего у вас не выйдет, поскольку в действительности значение cnt передано не по ссылке, а по значению. Если вдаваться в технические подробности, то значение переменной cnt будет скопировано на вершину стека вызова функции-«метода», а внутри этой функции будет модифицировано именно значение в стеке, а не исходная переменная cnt.

Как же правильно передать значение по ссылке?
Многословность спасёт мир:

def inc(cnt : Pointer(Int32))
  cnt.value += 1
end
n = 0
inc(pointerof(n))
puts n
# output: "1"

(Посмотреть, как работает код...)

Собственно, не сильно отличается от вызова аналогичной функции в Си, только «буков» местами больше, но зато и читается легче.

Всего наилучшего и до новых встреч!

Макросы: Условная компиляция

Для чего нужна условная компиляция и что это вообще такое?

Условная компиляция — это механизм формирования/генерации различного кода в зависимости от внешних условий, заданных на период начала компиляции.

Для чего это нужно? Ну, например, вы сможете генерировать из одного и того же исходного кода разные программы в зависимости от дня недели или наблюдаемой частоты вспышек на Солнце. Шучу конечно, но суть в общем-то отражает верно: это нужно для того, чтобы вы могли собрать программу, адаптированную к тем или иным условиям её (многократного) запуска. Чаще всего в данном контексте вспоминают рихтовку программного кода под целевую платформу: подключаются одни библиотеки, не подключаются другие, в зависимости от разрядности целевой платформы используются одни типы данных и не используются другие (например, на моём древнем нетбуке было бы актуально использовать Int32 вместо Int64). Тем не менее есть и другие, не менее значимые области применения: например, вы можете собрать версию программы с урезанным функционалом, но потребляющую существенно меньше памяти и/или более быструю, вы можете собрать код, из которого будут выброшены за полной бесполезностью условные конструкции, обречённые проверять незыблемые вещи. Таким образом, выудив пару-тройку назойливых if'ов из цикла с большим количеством итераций, вы малой кровью добьётесь весьма ощутимого прироста производительности: ведь проверка условий и условные переходы легко сбивают с толку конвейерный механизм работы современного микропроцессора (префетчинг/предвыборку команд в конвейер) и как минимум загружают его блок предсказания ветвлений ненужной работой.

Ну и конечно условная компиляция помогает быть сухим и чистым, т.е. «не повторять себя» (см. принцип d.r.y) и писать один макрос, ветвящийся в зависимости от значений того или иного параметра — там, где в противном случае пришлось бы писать несколько однотипных макросов или, что ещё «оригинальнее», генерировать макросами другие макросы.

В языке Crystal вы можете даже, пользуясь проверкой flag?(:release), вырезать из финального кода всё, что в противном случае прямо в рантайме проверяло бы, нужно ли выводить какие-нибудь низкоуровневые отладочные сообщения или же делать это и вовсе не следует. «Классический» подход к логированию заключается в том, чтобы устанавливать для приложения уровень отладки в конфигурационном файле или же задавать его параметрами командной строки. Но что если в этом нет никакой объективной необходимости? Что если ваш заказчик не хочет видеть отладку, а вы не хотите тестировать и отлаживать приложение прямо на «живом» заказчике? И если никогда не меняющееся условие «текущий_уровень_отладки >= debug» можно проверить один раз — при компиляции, — то почему бы так и не поступить? И машинного кода в релизе будет поментше, и работать он будет быстрее… Профит? Ну вот то-то же :)

Как же выглядит разрекламированная мной возможность языка Crystal впечатывать один код и не впечатывать другой, называемая также условной компиляцией?

Памятуя об упомянутой выше адаптации под архитектуру, вот вам классический solution для классического же use case, а именно генерация типа-псевдонима для того типа целого, который наиболее актуален для целевой архитектуры:


{% begin %}
    {% long_bl=64; gen_bl=32 %}
    {% if flag?(:x86_64) %}
        {% long_bl=long_bl*2; gen_bl=gen_bl*2 %}
    {% else %}
    # do nothing here
    {% end %} 
    alias Integer = Int{{gen_bl}} | UInt{{gen_bl}}
    alias LongInt = Int{{long_bl}} | UInt{{long_bl}}
    x: Integer=11_u{{gen_bl}}
    y: LongInt=12_i{{long_bl}}
    {% for var in %w(x y) %}
        puts "run-time class of var {{var.id}} is #{{{var.id}}.class}"
    {% end %}
{% end %}


Помимо некоторых интересных особенностей весьма умного движка макросов в языке Crystal, в данном примере на всякий случай показаны и некоторые его (языка) весьма досадные «родовые пятна»: например, для для того, чтобы поместить целое число в переменную целого же типа (не совпадающего с «умолчательным», зависящим от того, под какую архитектуру собран сам Crystal) — компилятору почему-то необходима вот такая откровенно уродливая конструкция, использующая некие самопальные суффиксы, изобретённые разработчиками из Manas, главного спонсора создания Crystal, не иначе как в горячем латинском ночном бреду:

x : Int128 = 11_i128

Видите вот это отвратительное "_i128"? Так вот, скоро вы его не увидите, ну или, вполне возможно даже, что на момент прочтения вами настоящей заметки — уже и не увидите, если только не поставите себе устаревшую версию Crystal. Дело в том, что Crystal 0.24.2, которым я пользуюсь сейчас — это один из последних выпусков, в которых упомянутая выше суффиксная кривизна всё ещё присутствует. Разработчики в курсе проблемы — и находятся на пути к скорейшему её решению.

А за сим про условную компиляцию пока что всё, в следующий же раз я расскажу вам о том, какие классы переменных наиболее общеупотребительны при написании макросов и какие у этих классов и у порождённых по их «образу и подобию» объектов (англ. «инстансов») — есть интересные методы и свойства.

Не переключайтесь и до новых встреч в прямом эфире!

Макросы: оператор for

Случилось как-то раз мне заинтересоваться возможностями макросов в языке Crystal. Если честно, я даже как-то особо ни на что и не рассчитывал, да и нужны были самые базовые вещи. И какой же приятной неожиданностью стало для меня то, что макросы в Crystal оказались продуманным до мелочей простым и понятным встроенным языком с обалденным функционалом (по меркам макроязыков). При этом, пожалуй, макроязык в Crystal даже более элегантный и читабельный, чем основной, «рантаймовый».

Например, знаете ли вы что в Crystal нет оператора организации цикла for? Его нет ни в каком виде, разработчики принципиально отказались от старого доброго for в пользу итераторов «для всего».

Так вот, удивительное дело, но во встроенном языке макросов есть for (который по сути foreach), и он умеет:

# перебирать элементы списка
{% begin %}
    {% for k in ["a","b","c","d"] %}
    {% puts k.id %}
    puts {{k}}
    {% end %}
{% end %}

Первый puts «напечатает» имена элементов списка во время компиляции, а второй — станет частью сгенерированного реального кода программы и «сработает» в рантайме.

а ещё макро-for'ом можно:

# Перебирать пары ключ-значение в хешах
# ...и псевдохешах со статичными ключами (NamedTuple'ах)
{% begin %}

    {% for k,v in { "a"=>1, "b"=>2, "c"=>3, "d"=>4 } %}
    {% puts k.id + " => " + v.id.stringify %}
    puts %q({{k}} => {{v}})
    {% end %}
    
    {% for k,v in { type: "road", wheel_size: "700c", ett: "555mm", weight: 7.5 } %}
    {% puts k.id + " => " + v.stringify %}
    puts %q({{k}} => {{v}})
    {% end %}
    
{% end %}

Ну разве это не прекрасно? :)

А в следующий раз я расскажу вам немного об условной компиляции и о типе StringLiteral в макросах crystal'а

Держите руку на пульсе технологий с человечным интерфейсом и не переключайтесь!

Если пробел встал у вас на пути. Как правильно перейти в каталог (рас|место)положения скрипта?

  • BASH
Вы всё ещё делаете это так?


cd $(dirname $(readlink -e $0))


Это ленивый вариант, который работает «в большинстве случаев». Однако же он не является верным, поскольку пути (пусть это не покажется вам странным) в общем случае могут содержать пробельные символы.

Надо бы вот так:

cd "$(eval "readlink -e '$0'" | sed -r -e 's%(^|/)[^/]+$%%' -e 's%([^/])/+$%\1%')"


Попробуйте — это просто работает как надо, сколько бы ни встретилось пробелов на тернистом пути вашего скрипта.

Inline assembler в Crystal

До меня доходили слухи, о том, что якобы в Crystal нет inline ассемблера.
Однако же это не так.


def add(a, b)
    asm("
        movl ($0), %eax
        addl ($1), %eax
        movl %eax, ($0)
    " :: "r"(pointerof(a)),"r"(pointerof(b)))
    a
end

x=12_i32
y=14_i32

puts add(x,y)


Есть только одна проблема: в AT&T ассемблере символ "$" вообще-то используется в качестве отличительного_префикса/сигила для констант. А здесь, как нетрудно заметить, $N — это ни что иное, как позиционный аргумент в блоке asm. И да, не спрашивайте меня, что ещё «r»(a) и странное "::" — сам теряюсь в догадках, но очевидно, что :: отделяет аргументы от кода в блоке asm, а «r»(something) собственно отвечает за определение позиционных $N, каждый из которых будет равен своему something. Сакральное знание о том, как использовать блоки asm, почёрпнуто мной отсюда: github.com/crystal-lang/crystal/blob/e2a1389e8165fb097c785524337d7bb7b550a086/src/fiber.cr#L10

Как считать данные из объекта IO в структуру данных?

Оказалось, что в языке Crystal не так-то просто сначала создать структуру данных с полями фиксированной длины, а потом записать в эту структуру добрую унцию хорошо прожаренных байт, дабы впоследствии наслаждаться данными, распиханными по отдельным полям структуры.

Самой большой проблемой является то, что данные из IO-объектов могут удобным образом считываться только в типы данных, представленные классам, корректно реализующими некий from_io метод. Такого рода заморочки для решения элементарной и очевидной задачи мне показались некоторым перегибом, а поскольку сопутствующего головокружения от успехов у меня не наступало, я решил поискать другой способ.

Вот, например: можно считать данные из объекта IO (в моём случае — сокета) в некий инстанс типа Bytes. Изучаем API языка — и узнаём о том, что Bytes — это ни что иное как Slice(UInt8). Ну легче конечно не стало, но продолжаем бороздить космические глубины — и натыкаемся на то, что Slice — это вообще-то разновидность указателя Pointer, только с жёстко привязанной к нему логикой проверки границ. Узнав о таких перипетиях бытия, я решил было, что смогу сделать Slice, указывающий на экземпляр, он же инстанс, моей гипотетической структуры данных, а потом просто записать в него данные их сокета. Но конечно же не тут-то было: считать-то можно, но только в Slice(UInt8), если это Slice(C::SomeStruct), например, то Crystal посетует на отсутствие подходящего метода для IO — и откажется компилировать программу. Но лиха беда начало, добрался я и до «родительского» по отношению к Slice классу Pointer. А тот, как назло, тоже строго привязан к типу (при создании нужно указывать тип данных) и порождает, соответственно, Slice(T), где T — это тот же тип, что и в порождающем Pointer'е. Думал я думал — и придумал, что раз я не могу просто создать Pointer на экземпляр структуры данных, куда следует записать данные из IO, то я ведь могу создать 2 указателя: один на экземпляр структуры, а другой, вспомогательный, на UInt8. И это оказалось верным решением, потому что Pointer, к счастью огромному, при создании не требует сразу указывать нечто определённое с присущим этому определённому типом T. Оказывается, указатель даже на Crystal можно создать просто под адресу, т.е. указав некое смещение в памяти. Ну а что же в таком случае мешает получить какое угодно количество указателей, формально относящихся к произвольным типам данных и указывающих, например, на одно и то же место в памяти? Да ничто не мешает!

Осознав всё сказанное выше, я реализовал запись из сокета в структуру данных буквально вот так, просто и элегатно:


lib C
   struct ZbxSenderHdr
     z_sign : StaticArray(UInt8, 4)
     z_stop_byte : UInt8
     z_payload_l : UInt8
   end
end
zhdr=C::ZbxSenderHdr.new
sock.read(Slice.new(Pointer(UInt8).new(pointerof(zhdr).address), sizeof(C::ZbxSenderHdr)))


Т.е. я создал Slice из Pointer(Uint8), который в действительности указывает туда же, куда и pointerof(zhdr) — и записал по адресу Slice'а данные, считанные из сокета.

Не знаю уж, насколько всё это может быть наглядным, но надеюсь, что кому-то кроме меня может оказаться полезным :)

Засим позвольте откланяться — и до новых встреч!

Событийно-ориентированное программирование: простой пример

Даже очень простой и очень неполный: хотим мы, например, получить пользовательский ввод, как-то его обработать в callback'е и получить после того, как всё-таки пользователь соизволит что-то ввести — некий результат на базе введённых данных.

Хотя в примере это не показано (но будет показано в дальнейших примерах, это уж будьте спокойны на сей счёт), но в то самое время, пока пользователь что-то неспеша тупит и вводит — мы можем преспокойно выполнять ещё тысячи зелёных потоков, которые сделают что-нибудь разумное, доброе и вечное. Например, разогреют мышку пользователя до 150 градусов по Цельсию или нервно помигают светодиодами игровой клавиатуры Why not? :)

Итак, вот вам piece-of-code:
class AnyEvent
    def initialize
    end
    def input(&block : String -> Int32)
        promise=Channel(Int32).new
        spawn do
            s=""
            while s.empty?
                print "Press any keys, then hit Enter -> "
                s=gets || ""
            end
            promise.send(block.call(s))
        end
        promise
    end
end

wait_event=AnyEvent.new
input_result=wait_event.input do |keys_was_pressed|
    puts "String is #{keys_was_pressed}"
    keys_was_pressed.size
end
puts "I've received #{input_result.receive} characters as an answer. Thank you SO much! :)"


Обдумывайте.

И счастливых выходных!

Идеальный PS4

  • BASH
Нашёл я как-то на просторах интернет интереснейший вариант наполнения префикса PS4 полезным содержимым. Считаю необходимым сделать эту информацию достоянием широкой общественности, а посему спешу поделиться ею со своими читателями, дабы и они тоже смогли проникнуться всей силой и мощью set -x:


export PS4='+(${BASH_SOURCE}: #${LINENO}): ${FUNCNAME[0]:-main}(): '


Напомню: PS4 — это префиксный кусок текста, добавляемый в каждую интерполированную строку, которую BASH выводит в режиме отладки/трассировки, включаемый по команде set -x и отключаемый по команде set +x соответственно.

Быстрой вам отладки и доброго продакшна!

Рецепт: как подождать завершения всех порождённых потоков исполнения

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

Собственно код:

begin
	ch=Channel(Int32).new
	fibCount=0
	i : Int32
	10.times{|i|
		fibCount+=1
		spawn do
			r=Random.new
			nsec=Random.rand*5.0
			puts "№#{i} launched, will sleep #{nsec}"
			sleep nsec
			puts "№#{i} sleeped #{nsec}, will send its ID to channel"
			ch.send(i)
			puts "№#{i} sended its name to channel, now finishing..."
		end
	}
	
	fibCount.times{
		i=ch.receive
		puts "main: received message from fiber №#{i}"
	}
	
	puts "main: sleeping 1 second"
	sleep 1
	puts "main: Congratulations! Thats DONE!"
rescue ex
	puts "EXCEPTION: #{ex.message}"
end

Аз, Буки, Веди! Читаем конфиги

Все мы рано или поздно читаем конфиги. Даже если начинаем с прописанных где-то в начале тела программы статических переменных, содержащих что-нибудь неизменное наподобие логина и пароля и даже если потом в силу давления обстоятельств, требующих от нас максимальной гибкости, начинаем использовать ключи командной строки (если это вообще возможно) — вот ну точно вам говорю, рано или поздно от чтения конфига всё равно никуда не деться.

Как-то и мне понадобилось нечто подобное… а потом ещё миллион раз :) И приступая к изучению нового для себя языка программирования, каковым для меня пока является и Crystal, я неизменно возвращаюсь к одному и тому же вводному вопросу: а как бы здесь прочитать конфиг в моём любимом простейшем BASH-совместимом формате (том, который легко подключается source'м из BASH-скрииптов): переменная=«зна 'че' ние» или переменная='зна «че» ние' или даже переменная=значение?

Для Crystal я тоже написал подобный пример. Вот он:


begin
        raise "Hey! You must specify file name as a first parameter" if ARGV.size==0
        rows=File.read_lines(ARGV[0])
        rows.reject! { |line| line =~ /^\s*(?:#.*)?$/ }
        conf=rows.map{ |line|
                if
                 line.match(/^([^#=\s]+)\s*=\s*(?:(?<Q>["'`])((?:(?!\k<Q>|\\).|\\.)*)\k<Q>)(?:\s+(?:#.*)?)?$/)
                        [$1,$3]
                elsif line.match(/^([^#=\s]+)\s*=\s*([^#\s"']+)(?:\s+(?:#.*)?)?/)
                        [$1,$2]
                else
                        raise "invalid-formatted config line: #{line}"
                end
        }.to_h

        p conf
rescue ex
        puts ex.message
        exit(1)
end


Поясню:

в секции rescuе обрабатываются любые возникающие исключения, в числе которых и ошибка открытия файла

ARGV[0] содержит первую опцию командной строки

Метод reject! изменяет список, являющийся экземпляром класса Array, так, чтобы в нём не осталось пустых строк и комментариев.

Метод map на том же самом rows возвращает «список списков», т.е. список, состоящий из элементов, каждый из которых представляет собой этакий крохотулечный «списочек» всего из 2-х элементов. В первый из элементов каждого такого «списочка» благодаря «усилиям» оператора match и скобкам в регулярном выражении — попадает переменная из конфига, а во второй элемент (благодаря всё тем же действующим лицам) — значение для переменной.

to_h преобразует наш список списков… во что бы вы думали? Да, точно, в Hash-массив, в котором каждый «списочек» магическим образом превращается в пару ключ-значение.

«p conf» — это на самом деле такой отладочный «хак» языка Crystal: инструкция p попросту выводит «дамп» любого переданного ей объекта. В данном случае — дамп Hash'а.

В реальной программе вы бы конечно использовали conf неким полезным образом. Ну а конфиг с паролями у вас конечно же защищён правами доступа «rw-------», оно же 600? Вот и молодцы!

Сохраняйте код в файл, запускайте «crystal your_funny_code.cr имя_файла» (обратите внимание на собственное расширение для языка Crystal) — и, как говорят, enjoy!

А получить удовольствие есть от чего: ведь вы написали настоящий компилируемый код — и обошлись без груды закорючек, спецификаций типов и возни с выделением/освобождением памяти :)

Потоки исполнения как инструмент опытного "повара"

Ещё раз прочитайте внимательно вопрос в заголовке. Прочитали? А теперь без всякого промедления правильный ответ:

Потоки или нити — куски кода, использующие одни и те же данные в памяти, исполняемые процессором компьютера попеременно, либо одновременно, либо и так, и так.

Читать дальше →

Как собрать в архив все файлы rpm-пакета?

  • BASH
В продолжение аналогичного поста о dpkg предлагаю использовать следующий «наивный» вариант скрипта, собирающего те файлы, которые были скопированы в систему при установке rpm-пакета. Файлы, созданные автоматически INSTALL-скриптом пакета при этом «подобраны» не будут.

Для запуска скрипта нужно иметь возможность выполнять sudo под суперпользователем: это связано с тем, что немалая часть пакетов устанавливает файлы с эксклюзивным доступом к ним root'а: в таких случаях попытка создать tar-архив провалиться с треском.

Собственно код:

#!/bin/bash
[[ $1 == '-x' ]] && { shift; export TRACE=1; set -x; }
[[ $1 ]] || { echo 'You must specify package name or path to some file installed from the package' >&2; exit 1; }

if [[ ${1:0:1} == '/' ]]; then
        FILE=$1
        if ! PACKAGE=$(rpm -qf $(readlink -e $FILE)) 2>/dev/null || ! [[ $PACKAGE ]]; then
                echo 'Cant determine package name by file name' >&2
                exit 2
        fi
else
        PACKAGE=$1
        if ! PACKAGE=$(rpm -q $PACKAGE); then
                echo "This package seems to be not installed" >&2
                exit 3
        fi
fi

sudo bash <<EOSCRIPT
        tar -cjf "/tmp/${PACKAGE}.tbz2" -T <(
          while read f; do
                  [[ -d \$f ]] || echo "\$f"
          done < <(rpm -ql '${PACKAGE}')
        )
        chown "$(whoami)":"$(id -gn)" "/tmp/${PACKAGE}.tbz2"
        echo "/tmp/${PACKAGE}.tbz2 created" >&2 
EOSCRIPT


UPD: Поправил код скрипта, избавив его от 2-х вызовов sudo и пофиксив ошибки отсутствия присвавивания FILE=$1, а также ошибку сохранения короткого имени пакета, если было передано именно таковое.

Однострочник: получить дамп заголовков HTTP-трафика на первом ethernet-интерфейсе

Некоторые однострочники просто поражают своей лаконичностью, но могут быть не вполне функциональны.
Некоторые — написаны откровенно неэстетично и содержимое их вызывает блевотный рефлекс, но когда читать man'ы лениво — бегло сканируешь незамыленным глазом чей-то шедевр — и копируешь как есть, потому что… ну да, они «просто делают свою работу» (прямо как офисный планктон в Москве: просто делает что-то… как-то).
А есть однострочники, которые вроде и полезны весьма условно, но представляют интерес чисто академический: хочется разобрать их на винтики и понять, как же хиромантия сия устроена, что за магия заставляет вращаться чудесные шестерёнки Unix-way.
В качестве наглядного примера представляю на суд моих благодарных читателей (кстати, в последнее время я был безмерно счастлив отвечать на письма зело многочисленных поклонников моего скромного творчества) — вот этот многострочник, составленный из двух частей: одну легко найти на StackOverflow, а вторую приписал Ваш Покорный Слуга (здесь и далее — ВПС).

Вот:

sudo tcpdump -i $(ifconfig | sed -nr '/^[^[:space:]]/{ s%^([^[:space:]:]+).*$%\1%; h; b X}; /^\s*ether/{ g; p; q }; :X') -A -s 10240 'tcp port 3128 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)' | egrep --line-buffered "^........(GET |HTTP\/|POST |HEAD )|^[A-Za-z0-9-]+: " | sed -r 's/^........(GET |HTTP\/|POST |HEAD )/\n\1/g'


Те истинные герои Совнгарда, которые первыми осознают и прочувствуют Суть работы механизмов радости в контексте представленного выше примера — да не сочтут они за труд отписаться в комментариях к посту, дабы подвиг их не канул в Лету.

Аминь!

P.S. Если вы низвергаетесь в грешный мир этих наших интернетов не через SQUID на дефолтном порту 3128, то замените циферки 3128 на что-то более другое. Спасибо!

Do You Know That? Как раскрывается "${array[@]}" и "${array[*]}"

  • BASH
Оказывается, в зависимости от режима интерполяции, внутри двойных кавычек массивы раскрываются принципиально по разному:

  • В случае с "${array[*]}" — массив интерполируется в один аргумент (одну строку), представляющий собой результат простой конкатенации всех элементов массива через пробел
  • В случае "${array[@]}" — каждый элемент массива становится отдельным аргументом так, словно каждый элемент взял себе внешние двойные кавычки, что уберегло его от дробления по пробельному символу (точнее, по IFS)

Тестовый пример:

Читать дальше →

Вдогонку к Tips&Tricks'у #10h

  • BASH
Конечно же, для функции join2 должна быть и комплементарная split.

Учитывая то, что просто split — это «split a file into pieces», а также принимая во внимание тот факт, что split-функция всё-таки будет писать в переменную-массив, а не просто на STDOUT, я добавил к привычному имени циферку 2, дабы получилось у нас «SplitTo (the) arrayName».

Ну а теперь код:

split2 () {
        local arrName=$1
        [[ $arrName =~ ^[0-9_A-Za-z]+$ ]] || return 1
        local delim=$2
        shift 2
        local args
        while (( $# )); do
         args+=${args:+$delim}$1
         shift
        done  
        readarray -t $arrName < <(echo -n "${args//$delim/$'\x0a'}")
        return $?
}


Пример использования:

split2 dir '/' '/usr/share/doc/LaTeX' 'a/b' 'c/d/e f g/h'
declare -p dir
# OUTPUT:
# declare -a dir='([0]="" [1]="usr" [2]="share" [3]="doc" [4]="LaTeX" [5]="a" [6]="b" [7]="c" [8]="d" [9]="e f g" [10]="h")'


Enjoy! :)