Споделянето на музика чрез споделяне на директории, било то през SSH тунел или през Samba не винаги е най-удобното, особено когато искате просто останалите компютри от мрежата да имат достъп само да вашата музика, а не до цялата ви система. За целта по-лесното решение би било да инсталирате един медиен stream сървър за вашата музикална колекция, който при малко игра с рутера можете да споделите и през интернет. В този случай можете да погледнете към firefly медийния сървър (по-рано известен като „md-daapd“ за Multi-Threded DAAP Deamon; където DAAP = Digital Audio Access Protocol), който пуска аудио поток към крайни уреди като звуковия мост Roku, съответно Pinnacle. Същевременно iTunes и други софтуерни решения като плеъра по подразбиране в GNOME – Rhythmbox, поддържат DAAP протокола. Освен това Firefly не работи само под Linux, но и под Windows, MacOS, AIX, BSD, Solaris и включително някой Embedded устройства като Linksys NSLU2, Maxtor MSS и Buffalo Linkstation. В слуачая е просто интересно да се спомене за тези възможности, тъй като тези устройства използват значително по-малко електричество, отколкото един компютър, който да служи за музикален сървър.

Характеристики на Firefly медийния сървър

Заглавна страница на firefly сървъра

Основното преимущество на Firefly е изключителната му портативност, лекотата на работа и постоянната му разработка – един от малкото медийни сървъри с отворен код, които все още се поддържат от разработчиците им. Ето един списък с някои от основните характеристики, които отличават Firefly:

• Поддръжка на различни аудио формати като Ogg-Vorbis, FLAC, Apple Lossless, WMA и MP3, които биват автоматично транскодирани при необходимост.
• Конфигурирането на Firefly става през WEB-интерфейс.
• Поддържат се списъци с песни, създадени от потребителя (m3u, pls).
• Интегрира се в Apple iTunes-библиотеката
• Пуска поток дори и от радиостанции

Firefly можете да свалите от http://www.fireflymediaserver.org/ в две версии: стабилна версия и „Nightly“ – бета версията. Но можете да избегнете свалянето на файловете от страницата, тъй като можете да намерите пакета в хранилищата на Ubuntu под името md-daapd. Версията на пакета е достатъчно актуална и няма да имате никакви проблеми с инсталацията и конфигурацията, поне от тестовете в домашни условия нямаше никакъв проблем.

Инсталация и стартиране

След като инсталирате пакета от хранилищата с командата:

sudo apt-get instlal md-daapd

Или използвате за целта Synaptic Package Manager. Това което принципно остава е да настроите директорията, в която се намира вашата музикална колекция. За целта трябва да редактирате файла /etc/md-daapd.conf и да зададете правилна стойност за променливата mp3_dir. Ако като мен имате музика в различни дялове на своя твърд диск, спокойно можете да създадете символични връзки за файловете в избрана от вас директория (/home/USERNAME/Music). След като запишете промяната остава само да рестартирате сървъра:

sudo /etc/init.d/md-daapd restart

За да влезете в администраторския интерфейс отворете в браузъра http://localhost:3689 Компютрите в моята мрежа използващи Rhythmbox автоматично разпознаха адреса на сървъра и веднага музиката от сървъра беше достъпна до всеки компютър. В случай, че това не стане автоматично или използвате друг плеър, проверете има ли поддръжка за DAAP и ако е активирана просто добавете адреса на вашия сървър и порта. За да влезете в администраторския уеб-интерфейс използвате потребителско име root и парола md-daapd, по-късно можете да я промените в менюто Configuration. На началната страница на сървъра можете да стартирате и спирате сървъра с едно натискане върху съответния бутон, както и да проведете нормално или пълно сканиране на директорията с вашата музика. Освен това получавате и информация за това колко песни могат да бъдат стартирани от сървъра, колко са просвирени, колко време е работил сървъра и т.н.

Конфигурация

Настройка на firefly сървъра

Ако конфигурацията по подразбиране не ви устройва и се нуждаете от още настройки, или предпочитате настройките да ги въвеждате директно в конфигурационния файл. Ето някои от основните настройки, които ще намерите в конфигурационния файл:

• servername : Името на вашият сървър, параметрите, които са зададени %v и %h са съответно версия и име на машината.
• logfile : Къде да бъде воден дневник с проблемите и действията на сървъра
• admin_pw : Администраторската парола за web-интерфейса
• password : Парола, която се изисква за достъп до mp3 файловете (можете да оставите и празна)
• mp3_dir : Пълният път до директорията с вашата музика
• extensions : Разширенията на файловете, които firefly да индексира
• playlist : път и име на списъка с песни ако използвате такава
• scan_type : Тип на сканирането определя как и кога да бъдат сканирани заглавията: „Normal“ - 0 сканира първият слой от mp3 файла и пресмята дължината на песента; малко по-точен е типа „Aggressive“ – 1, който проверява бит-честотата на десен слоя в една минута на песента. Както предполагам сте се досетили най-акуратния метод е 2 – „Painfully Aggressive“, при който се броят всичките слоеве на едно заглавие. Последния метод отнема най-много време, но е необходимо да се изпълни само веднъж.
• rescan_interval : Интервалът от време за автоматично сканиране на новите файлове в секунди: Препоръчвам ви след като сте сканирали всичките заглавия да зададете стойност 86400 (през 24 часа).
• always_scan : Ако параметърът е сложен на Yes (или 1 в конфигурационния файл) твърдите дискове биват сканирани във фона. Устройства, които се изключват автоматично, когато не се използват биха искали да сложите параметъра на „No“ (0 в конфигурационния файл), за да спестите малко ток. Въпреки това можете ръчно да проведете сканирането в уеб-интерфейса.

Повече информация за настройките и възможностите на сървъра можете да получите в Wiki-то на проекта на адрес: http://wiki.fireflymediaserver.org/. На същия адрес ще получите и повече информация как да настроите своя сървър така, че да бъде достъпен и през интернет.

Некриптираните писма могат да бъдат прихванати и прочетени с лекота. Редно е да се предпазвате от това. За щастие при повечето Linux дистрибуции криптирането на вашия E-Mail се настройва изключително лесно.

Против кражбата и манипулацията на данни може да ви помогне само добър софтуер за криптиране като GnuPG. Причината GnuPG да е толкова сигурен – GnuPG е свободен софтуер и е лицензиран под GPL лиценз. Изходния код на софтуера е отворен и може лесно да бъде проверяван за грешки. GnuPG съществува от 1999 година с версия 1.0 за Unix-съвместими операционни системи; програмата е предварително инсталирана с Ubuntu. GnuPG работи с така наречения метод за публичен ключ, при който потребителя създава един личен и един публичен ключ. С помощта на публичния ключ получателите могат да сравняват съобщенията директно от подателя. За целта с ключа можете да се сдобиете директно от изпращача или като го свалите от публичен сървър за подобни ключове.

GnuPG не е съвместим с познатия PGP версия 5.x, но с версия 2.x. Това се дължи на факта, че в последните версии на PGP се ползва патентован алгоритъм за криптиране, който не може да бъде ползван в приложения с отворен код.

Генериране на ключова двойка в GnuPG

За GnuPG се нуждаете от ключова двойка за криптиране, декриптиране и подписване. Такава можете да създадете в терминала. За целта отворете терминала и въведете следната команда:

gpg --gen-key

С тази команда ще създадете един обществен и един личен ключ. Първо програмата ще ви попита кой ключ искате да създадете. Изберете първата опция по подразбиране: RSA and RSA. Други двойки като RSA и Elgmal създават проблеми при работата с Evolution.

Следва да определите големината на ключа. Един RSA-ключ може да бъде между 1024 и 4096 Bit-а дълъг. Предложената по подразбиране големина от 2048 е един добър компромис. Ключът е достатъчно голям, за да не може да бъде разбит и толкова малък, така че криптирането и декриптирането да не отнема прекалено много време. Имайте обаче предвид, че веднъж избрана големината на ключа, не може да бъде променяна по-късно.

След избора на големината следва да изберете валидността на ключа. Първата опция 0 („Ключът не изтича никога“) е достатъчна в повечето случаи, и има предимството, че няма да се налага да изпращате нов ключ на своите кореспонденти. Тайни агенти (като James Bond 007) и други държащи на своята анонимност може би трябва да изберат време за изтичане на техния ключ: Ако зададете някакво число, толкова дни ще бъде валиден вашият ключ. Ако към числото добавите буквата „w“ – толкова седмици, буквата „m“ – месеци и „y“ за години. Въведеното от вас трябва да бъде потвърдено още веднъж.

Остава да добавите информация за потребителя (т.е. Вас). Тази информация GnuPG сформира от вашите имена, коментар при желание и вашият E-Mail адрес. Първо трябва да зададете вашите имена, след натискане на [Enter] вашият E-Mail и в третата стъпка коментар. Ако всичко е вярно потвърдете с „f“ и [Enter].

След това следва момента, в който трябва да изберете Passphrase, кодова фраза (наречена още Mantra). За потвърждение въведете паролата повторно. Изречението/фразата трябва да е достатъчно трудно, така че трети да не могат да се сетят или да достигнат до него. Естествено не трябва и да е някакъв роман, тъй като ще трябва да го запомните – ще ви трябва всеки път, когато искате достъп до своя ключ.

Имайте предвид, че вашата Mantra е единствената защита срещу разшифроване, ако някой получи достъп до вашия личен ключ. Не използвайте думи от речници. Използвайте не само азбуката, но и цифри и пунктуационни знаци. Малък съвет: Ако вмъкнете и няколко правописни грешки атаката чрез списък от речникови думи ще стане невъзможен.

След въвеждане на кодовата фраза, започва генерирането на пръстовия отпечатък и ключовете. За целта GnuPG се нуждае от огромно количество произволни стойности. Създаването на тези произволни стойности можете да подпомогнете и ускорите като отворите втори терминал и изпълните команда като ls -lR /, която ще върне достатъчно количество данни. След известно време ключовата двойка е готова.

GnuPG и Evolution

След като сте създали своята ключова двойка можете да я използвате директно в Evolution. За целта отворете настройките на акаунтите (Edit -> Preferences -> Mail Accounts), изберете своя акаунт и изберете бутона Edit. След като се отвори прозореца с настройки навигирайте до таб Security. В полето PGP/GPG Key ID: въведете осем символното ID на вашия публичен ключ. Можете да го намерите в изхода от терминала на реда започващ с „pub“ и е след наклонената черта. В случай, че вече сте затворили своя терминал, стартирайте го отново и въведете командата gpg --list-public-keys Така ще ви бъдат показани всичките ви публични ключове. При желание можете да включите или изключите някои от останалите опции в прозореца за настройка на вашия акаунт и накрая потвърдете с OK.

От този момент вие можете да изпращате подписани писма. За тази цел при създаването в прозореца с редактора изберете менюто Security и от там PGP/GPG Sign. За да криптирате писмото си с опцията „PGP/GPG Encrypt“ се нуждаете от публичния ключ на получателя. Когато изберете бутона Send, за да изпратите писмото ще бъдете попитани за Passphrase, която зададохте при създаването на ключа.

За да може получателя да прочете вашето писмо трябва да има вашият публичен ключ. Можете да му го изпратите като прикачен файл в писмо, да го качите на публичен сървър за ключове или да го насочите към вашата лична страница, където сте го публикували.

Ако използвате Thunderbird ще трябва да инсталирате добавката Enigmail. При Claws Mail опцията е включена в инсталацията по подразбиране. Под Windows можете да изтеглите пакета за GPG заедно с ClawsMail, където единственото, което трябва да направите е да генерирате ключ и всичко ще работи от само себе си

Размяна на ключове

За да може друг да ви изпраща криптирани писма, той ще се нуждае от вашият публичен ключ. По този начин писмото се криптира така, че само вие да можете да го прочетете, тъй като сте единственият притежател на личния ви ключ. Същото важи, както вече разбрахте, когато изпращате писмо до друг – трябва да разполагате с публичния ключ на получателя.

Ако искате да изпратите публичния си ключ на ваш кореспондент, трябва да извлечете връзката с ключове. За целта трябва да отворите терминал и да изпълните командата:

gpg --ouput FILENAME --export USER-ID

или

gpg --armor –ouput FILENAME --export USER_ID

В първият случай създаденият файл в бинарен формат. Във втория файлът е в ASCII формат и можете много лесно да го добавите във вашето писмо или да го публикувате на вашата web страница.

Когато сте получили връзката с ключове от друг, можете да добавите чуждия ключ към вашата връзка със следната команда:

gpg --import FILENAME

Командата:

gpg --list-keys

ще ви покаже дали ключът е бил успешно вмъкнат или не. Накрая имате възможността да проверите пръстовия отпечатък на на ключа и да го подпишете с вашият собствен ключ. Ако това се случи на сървър за ключове (Keyserver) така всеки ще знае, че сте се доверили на този ключ. Ако някой има доверие на вас, така може да има доверие и на трети ключове. Този принцип се нарича още „Web of trust“ (Мрежа на доверието) и е основополагащ в отворената криптографична система GnuPG.

Използване на сървър за ключове

С вашият ключ можете да комуникирате по различни начини. Можете да го дадете на малко комуникационни партньори лично по E-Mail или на дискета, или го публикувате на вашата лична интернет страница, или го публикувате на сървър за ключове (на пример http://keyserver.ubuntu.com/). Последното има смисъл, когато сте член на пощенски списък, където всички подписват писмата. По този начин всеки може да се сдобие с вашият публичен ключ и не е необходимо на всеки да го изпращате лично. По този начин започва и за вас да функционира принципа Web of trust. За да изпратите своя ключ до подобен сървър е достатъчно да изпълните командата:

gpg --keyserver KEYSERVER --send-key USER_ID

Големите сървъри за ключове се синхронизират взаимно, така че ключа ви ще бъде записват в популярните сървъри и няма да има нужда да се притеснявате дали ключа ви ще бъде намерен.

Кратки афоризми в уведомителни балончета

Така в предния урок ви показах как да си направите браузър, самият урок беше трудно да бъде предаден в по-разбираем вид. Ако сте го разбрали – добре, ако не съжалявам. За онези, които не са го разбрали или е все още сложно за тях реших да добавя днешния малко хумористичен урок на тема pynotify. Като крайния резултат ще бъде информативно балонче, което ще се стартира през определен период от време (или при стартирането на компютъра) и ще изважда афоризъм за жените от sqlite база данни. От сега искам да кажа, че самият скрипт като цяло е изключително лесен, но за начинаещите в Python може да им бъде полезен, представяйки им някои полезни и доста лесни функции за работа с бази данни и хващане на грешки.

Преди да започнем с урока искам да се извиня на всички жени, които попаднат на статията – афоризмите не са измислени от мен, но просто бяха най-удобния текст, с който можех да си поиграя за настоящия скрипт.

Какво ще ни бъде необходимо

Както и в предните уроци ще посъветвам да избегнете използването на IDE (Integrated Development Environment) – причината: Ако не напишете нещо грешно, няма как да го научите. Средите за разработка ви помагат едва след като сте усвоили самият език и ви трябва нещо по-мощно за работа, но ако сте твърдо решени да ползвате такава среда – не е проблем. Предварително трява да се уверите, че имате инсталирани следните библиотеки за Python:

• python-pysqlite2
• python-notify
• sqlite3

За да бъде примера по-близък до реалността няма да добавям в урока .db файла с базата данни, а само препратка към списъка с афоризмите. Първата ни стъпка ще бъде този списък да го превърнем в база данни и след това ще я използваме в нашият скрипт.

Списъкът можете да намерите на следния адрес: http://is.gd/c839M (използвайте опцията „Виж“ и копирайте текста в нов файл, тъй като функцията за изтегляне все още не работи)

От текстов файл към база данни

Приемайки, че вече сте инсталирали всичко необходимо и имате файл thewomen, в който се съдържат афоризмите, идва моментът с прехвърлянето на тези записи в една база данни. Принципно бихме могли за този пример да използваме и самия файл, но това би било прекалено лесно, пък и какво по-хубаво от това да разберете малко за sqlite. Нека преди да напишем скрипта, който ще прехвърли всичко от текстовия файл в .db файла да структурираме стъпка по стъпка това, което трябва да се случи:

1. Тъй като това е проста информация и не се нуждаем от кой знае каква функционалност базата ни данни ще съдържа две колони: id и womenfact
2. id реално ще отговаря на реда в текстовия файл, womenfact на текста
3. За да прехвърлим информацията е необходимо да прочетем файла ред по ред и всеки ред да бъде записан под следващото ID в базата данни
4. id-то ще използваме по-късно, за да изкарваме произволен ред.

Нека пристъпим към самият скрипт. Аз ще го запиша първо целия и след това ще обясня ред по ред какво се случва:

#!/usr/bin/env python

import codecs
from pysqlite2 import dbapi2 as sqlite

def main():
    file = open('newtexts', 'r')
    try:
        conn = sqlite.connect('thewomen.db')
        c = conn.cursor()
    except:
        print "*** Problem creating the db file"
    try:
        c.execute("""CREATE TABLE women (id INTEGER PRIMARY KEY, womenfact TEXT)""")
        conn.commit()
    except:
        print "*** Problem creatint the table"
    for line in file:
        try:
            c.execute("""INSERT INTO women(womenfact) VALUES('%s')""" % (line.decode('utf-8')))
            conn.commit()
        except:
            "*** Can't write to the database"
    file.close()
    c.close()

if __name__ == '__main__':
    main()

Нека обясним сега какво сме направили.

В първите два реда вмъкваме необходимите библиотеки, които ще използва скрипта. След което дефинираме нашият главен метод main(). Започваме нашият метод с отварянето на файла thewomen в режим на четене (за това служи параметъра ‘r‘). След което опитваме да се свържем към базата данни thewomen.db. С except прихващаме възможни грешки, които евентуално биха възникнали при създаването на .db файла. После поставяме курсор „c„, и в следващият опит създаваме нашата таблица с две колони id и womenfact. Първата колона трябва да бъде Integer (т.е. число) и ще бъде наш главен ключ – това е достатъчно за sqlite да разбере, че тази стойност ще трябва сама да увеличава стойността си (за разлика от MySQL, където това трябва да опоменем изрично). Колоната womenfact ще съдържа текст (запознатите с MySQL може да потърсят VARCHAR, но в sqlite няма такъв тип данни[http://www.sqlite.org/datatype3.html]). Чрез conn.commit() казваме на sqlite да приложи нанесените от нас промени, т.е. да бъдат записани във файла. Това, което остава за нас е за всеки ред да извъшиме нов запис в базата данни, като важното в случая е да запомните, че ние ще ще декодираме информацията в utf-8, за да нямаме проблеми по-късно с родния ни език. При всеки запис ще потвърждаваме промените с conn.commit(). След като приключи цикъла, т.е. обходили сме всичките 130 реда от нашия файл, затваряме файла, който сме чели и затваряме връзката към базата данни.

Изпълнението на самият скрипт отнема около 5 секунди след което можете да прегледате съдържанието на базата данни с sqliteman.

Да се научим и да четем

В нашият случай първо се научихме да пишем, а след това да четем, но това е основният път към научаването в нашият случай. Ако незнаехме как да пишем – нямаше да има какво да четем нали така? Нека погледнем какво ще трябва да се случая в нашият четец:

1. Трябва да осъществим връзка с базата данни
2. Трябва да си генерираме произволно число между 0 и 130 (все пак не искаме всеки път да виждаме едно и също)
3. Ще поискаме ред от базата данни с номер произволното число, което сме генерирали
4. Резултата ще го разкодираме в utf-8 и ще го покажем чрез Notify балон.

Ето го и готовият скрипт:

#!/usr/bin/env python
from pysqlite2 import dbapi2 as sqlite
import codecs
import random
# това го забравих, но ще ни е необходимо ако не искаме
# всеки път да пишем директния път до базата данни
import os
try:
    import pynotify
except:
    "*** You don't have pynotify installed!"

def main():

    try:
        # Използваме os.environ['HOME'] за да вземем пътя до личната директория
        # на потребителя, все пак скрипта ни ще бъде стартиран като обикновен потребител
        # ако го стартираме като root, то ще трябва да запишем базата данни в
        # директорията на root: /root/.config/
        conn = sqlite.connect('%s/.config/thewomen.db' % os.environ['HOME'])
    except:
        print "*** Error connecting to the db file"
    c = conn.cursor()
    number = random.randint(1, 130)
    try:
        c.execute("""SELECT womenfact FROM women WHERE id = %i""" % number)
    except:
        print "*** Problem selecting a row from the db file"
    row = c.fetchone()
    pynotify.init("womenfacts")
    n = pynotify.Notification("Womenfact:", "%s" % row[0].encode('utf-8'), "dialog-information")
    n.show()
    c.close()

if __name__ == '__main__':
    main()

И така първите два реда с import са ви познати и от първия скрипт. С реда import random добавяме библиотеката за генериране на произволни числа. За библиотеката pynotify използваме опит, защото в случай, че потребителя няма инсталиран pynotify той трябва да знае за това, за да може да го инсталира. Ако предоставяте приложението си като .deb пакет примерно тази част можете и да я пропуснете, тъй като най-вероятно ще сте добавили python-pynotify в зависимостите на пакета. В main() метода свързването с базата данни е абсолютно същото, както и при създаването на базата данни – в случая нищо ново под слънцето. Променливата number използваме, за да запишем в нея произволно число използвайки метода randint (произволен integer), който приема като параметри диапазона, в който трябва да бъде числото, тъй като ние имаме 130 записа в нашата база данни, то диапазона ще бъде между 1 и 130. След което извикваме нашият курсор, като му казваме да избере womenfact от таблицата women, където id е равно на генерираното от нас число. Забележете, че при SQLITE сравненията не се правят с двойно равенство, както в Python. Нещо, което изпуснах да отбележа също е и, че при execute използваме тройни кавички – причината е, че в подобни заявки, може да ни се наложи да използваме двойни и единички кавички и е добра практика да използвате тройни, за всеки случай. Задаваме променлива row (ред), към която присвояваме първият резултат от нашата заявка. Имайте предвид, че резултата е масив – конкретно в нашият случай е с една единствена стойност, но все пак остава масив и ще трябва по-късно да го третираме като такъв. С реда pynotify.init("womenfacts") инициализираме pynotify, като му казваме, че ние сме ново приложение, което иска да използва услугата за уведомявания. Ако изпуснете този ред, най-вероятно няма да видите никакво балонче ;). Променливата n става нашето уведомление „Notification“, което приема три параметръра:

1. Заглавие – „Womenfact:“
2. Текст, който е първият елемент от масива, кодиран в utf-8
3. Име на изображение, което да бъде използвано – dialog-information

Казваме на нашето уведомление да бъде показано с метода show() и прекъсваме връзката с базата данни.

Да направим използването на системата забавно

След като вече имаме нашият скрипт, който от своята база данни извежда произволен афоризъм може да се каже, че сме почти готови. Това което остава е да свъжеме скрипта ни със системата, така че да се показва автоматично. За целта имам три възможности:

1. Да прикачим скрипта към глобална клавишна комбинация (виж Python: Актуалната песен в Clipboard)
2. Да добавим скрипта към автоматично стартиращите се приложения (можете да го направите от Startup Applications)
3. Последния и по-забавен разбира се е да накараме нашият скрипт да се стартира през определен период от време. За тази цел обаче ще трябва да използваме cron (услуга в UNIX/Linux света за автоматизиране на процеси)

Тъй като първите два варианта по обясними причини не са толкова интересни, в този урок ще обясня само последния. Преди да добавим нашият скрипт към списъка на cron е редно да направим няколко корекции.

• -Ще прекръстим скрипта си на нещо по-кратко и ще махнем разширението му – нека бъде womenfacts и ще го направим изпълнум

mv името_на_вашия_скрипт.py womenfacts && chmod +x womenfacts

• Ще преместим нашата база данни на място, от което няма да я забършем по погрешка (~/.config)

mv thewomen.db ~/.config/

• Трябва да нанесем промяната в нашият скрипт, за да нямаме проблеми с връзката към базата данни

Променяме:

conn = sqlite.connect('women.db')

на:

conn = sqlite.connect('%s/.config/women.db' % os.environ['HOME']) # Използваме os.environ['HOME'], за да вземем пътя до домашната директория на потребителя!

Наложително е да използваме абсолютния път до директорията – в случая ~/ няма да ни бъде от голяма полза.

• Копираме скрипта ни в /usr/local/bin (за да бъде глобално изпълним):

sudo cp -fp womenfacts /usr/local/bin/ # използваме и параметъра -p, за да запазим правата върху файла

Тествайте, за да се уверите, че при изпълнението на womenfacts от терминала виждате балончето.

Сега идва реда на cron. Ако до сега не сте използвали cron. Първото нещо, което трябва да направите е да стартирате crontab с параметъра -e, в което ще бъдете попитани кой редактор искате да използвате (none, pino, vi, joe и т.н.). Имайте предвид, че ако искате cron да бъде запазен за всяка сесия, а не само за настоящата ще трябва да стартирате corntab като root (с администраторски права). По подрабиране, най-вероятно cron ще бъде празен. За нашия скрипт ние ще трябва да въведем следното:

*/5 * * * * DISPLAY=:0 PYTHONPATH=::/usr/lib/python2.6/dist-packages/gtk-2.0/:$PYTHONPATH /usr/bin/python /usr/local/bin/womenfacts # JOB_ID_1

Какво означава това. Първата част */5 означава да бъде стартиран всеки пет минути. Ако е само 5 означава в петата минута на всеки час. Останалите параметри са за съответно: час, ден от месеца, месец, ден от седмицата (общо пет с първия параметър). Тъй като нашият пример е малко по-специфичен – налага се да работиме с графично приложение задаваме някои константи преди да изпълниме нашият скрипт чрез cron. Първата и най-важна е DISPLAY=:0 означва, че ще използваме първия дисплей, останалите са свързани с пътищата да Python и използваната библиотека GTK и накрая пътят до нашият скрипт. За повече информация как да боравите с cron и как да разберете видовете настройки можете да прегледате информацията в wikipedia [http://en.wikipedia.org/wiki/Cron] или прегледайте man страницата. За по-бързо разяснение:

.---------------- минута (0 - 59)
|  .------------- час (0 - 23)
|  |  .---------- ден от месеца (1 - 31)
|  |  |  .------- месец (1 - 12) ИЛИ jan,feb,mar,apr ...
|  |  |  |  .---- ден от седмицата (0 - 7) (Неделя=0 или 7)  ИЛИ sun,mon,tue,wed,thu,fri,sat
|  |  |  |  |
*  *  *  *  *  команда, която да бъде изпълнена

aria2 е конзолен (терминален) клиент за теглене на файлове. Поддържа множество протоколи, като HTTP(S), FTP, BitTorrent (DHT, PEX, MSE/PE) и Metalink.

Aria2 може да изтегля един файл от няколко източника (протоколите HTTP(S), FTP и BitTorrent) едновременно за да извлече максимална скорост от вашата връзка. Данните изтеглени през HTTP(S) и FTP биват качвани в BitTorrent рояка (swarm) използвайки контролни суми на фрагментните (chunk) на Metalink, като по този начин автоматично валидира данните от тях, докато изтегля файла от BitTorrent протокола.

Съществуват и други алтернативи като wget и curl, но aria2 се отличава с две основни характеристики:

1. aria2 може да изтегля файл от различни източници (URI)
2. Ако зададете на aria2 списък с връзки към файлове, тези файлове ще бъдат изтеглени конкурентно.

Вече няма да е нужно да чакате даден файл да бъде изтеглен, тъй като (както вече споменахме) aria2 се опитва да извлече максималната скорост от вашата връзка, за да изтегли файловете, които искате.

Съществуват и други приложения, които могат да изтеглят файлове на сегменти. Това означава, че приложението разделя файла на сегменти и тегли всеки от тези сегменти паралелно, като чакат всяка задача да приключи. С други думи, тези приложения не разделят незавършените сегменти от изтеглянето. По принцип ако всичко върви добре, тази стратегия работи много добре, но в случай че една от задачите е твърде бавна (на пример даден сегмент се изтегля от по-бавен сървър), тогава трябва да чакате този сегмент да бъде изтеглен. Aria2 може да лавира в подобни ситуации като разделя сегментите адаптивно до 1MB, така че не е необходимо да се тревожите за горния проблем. Можете да предположите, че ще има отново проблем при изключително бавни сървъри, но всъщност aria2 е изключително умно приложение и ще прекъсне тегленето от бавни сървъри и ще използва само най-бързите.

За разлика от първата версия Aria, която предоставя GTK+ интерфейс. Aria2 е изцяло конзолно базирана. Като резултат – изисква изключително малко ресурси. Използването на физическа памет е сведено от 4MB (за обикновени HTTP и FTP изтегляния) до 9MB (при теглене през BitTorrent). Използването на процесора при теглене от BitTorrent при скорост на трансфера от 2.8MB/s е около 6%.

Това, че основното приложение е конзолно-базирано, съвсем не означава, че няма и графични интерфейси. Всъщност разполагате с няколко в зависимост от вашите нужди:

GUI:

• aria2fe (http://aria2fe.sourceforge.net/)
• aria2::gui (http://www.martin-achern.de/wgetgui/aria2gui.html)
• karia2 (http://sourceforge.net/projects/karia2/)
• Eatmonkey (http://goodies.xfce.org/projects/applications/eatmonkey)

WEB:

• aria2web (https://sourceforge.net/projects/aria2web/)

Използване на aria2:

За да изтеглите файл през web:

$ aria2c http://example.org/mylinux.iso
За изтегляне на файл от два или повече източника:

$ aria2c http://url1.com/f.iso http://url2.com/f.iso

За изтегляне на фйал през BitTorrent:

$ aria2c http://example.org/mylinux.torrent

Повече за това как да използвате aria2 можете да разберете в wiki-то на проекта: http://sourceforge.net/apps/trac/aria2/wiki/UsageExample

PyBrowser - уеб-браузър само в по-малко от 100 реда код

Преглеждайки днес новостите по мрежата в любимия ми сайт TuxRadar попаднах на един нов видео урок, който за 20 минути ни показва как можем да използваме Python, Webkit и PyGTK, за да си направим просто браузър. За съжаление урока не беше пълен и всичкото ставаше от Python интерпретатора, затова реших да използвам видео урока за база и, доколкото е възможно да го разширя до нещо функциониращо. В този урок – ще ви покажа как да създадете от-до браузъра и съответно как да добавите, някои полезни функции. В края на урока ще добавя и препратки, в които можете да търсите повече информация за използването на webkit ако решите да разширите браузъра с повече възможности.

Нека започнем

Какво ще ни бъде необходимо. Първо трябва да се уверите дали имате инсталирано всичко необходимо:

• python
• python-gtk2
• python-webkit

Разбира се, за да пишете код ще ви е необходим и редактор – тук всичко остава във ваши ръце. Ще препоръчам само да не използвате среда за разработка като Eclipse или NetBeans, тъй като за начало е напълно излишно, тъй като ще бъде редактиран само един файл (функционален браузър в един файл – точно така). Разбира се можете да подготвите и три икони – една за прозореца, една за бутон Go и една за презареждане. Може и без тях, но аз не обичам да ползвам бутони с текст. В самия урок, ще добавя коментар, как можете да използвате и нормални бутони с текст или бутоните, включени в GNOME (което ще ви позволи и превод на интерфейса директно с писането на приложението).

Вмъкване на всичко необходимо и първия прозорец

Нека започнем с писането. Първоначално е редно да добавим библиотеките, които ще използваме и да създадем скелета на приложението (класовете и методите). Започваме от вмъкването на необходимите библиотеки със следните 4 реда:

import gtk
# Следващите два реда са необходими, за да не получавате грешка от Glibc при стартирането на приложението
import gobject
gobject.threads_init()
# И разбира се добавяме webkit
import webkit

class PyBrowser:
    def __init__(self):
        pass

    def main(self):
        # тук стартираме основния метод на gtk
        gtk.main()

    def delete_event(self, widget, data=None):
        # тук ще дефинираме изхода от приложението, за което отново използваме метод от gtk
        gtk.main_quit()

    def enter_pressed(self, entry):
        # оставяме място за действие при натискате на клавиша Enter в полето за писане

    def go_clicked(self, btn):
        # оставяме място да дефинираме действието на бутона Go!

    def refresh_browser(self, btn):
        # място за действието на бутона за презареждане на страницата

    def title_changed(self, webview, frame, title):
        # добре ще е разбира се да обновяваме заглавието на прозореца със заглавието на настоящата
        # страница

if __name__ == "__main__":
    # След като използваме класове трябва да ги прехвърлим към обект
    browse = PyBrowser()
    # и с този обект да извикаме основния метод main()
    browse.main()

Както виждате основната част на приложението е изключително интуитивна. Редно е да се поясни, че конструктора __init__ ще ни служи за да построим самия прозорец на приложението и в него ще опишем всички действия, бутони, полета и самия браузър. Ако до момента не сте срещали подобен конструктор прегледайте http://www.penzilla.net/tutorials/python/classes/ – изключително добре описано с примери .Също така self обяснява, че това са лични методи към класът PyBrowser и за да ги извикваме ще трябва да пишем self пред името на всеки метод.

Да създадем прозореца с джаджите

В gtk всяко нещо е widget, включително бутоните, полетата за текст и т.н. И те трябва да бъдат добавяни в съдържатели – било то фиксирани, вертикални кутии, хоризонтални кутии, таблици и т.н. В този урок ние ще използваме вертикални и хоризонтални кутии. Но преди това нека първо създадем нашия прозорец. Това става изключително лесно добавяме следното в __init__:

        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.connect("delete_event", self.delete_event)
        self.window.set_title("PyBrowser v.0.1")
        self.window.set_icon_from_file("icons/pybrowser_small.png")
        self.window.resize(600, 480)

Да поясним какво сме направили – с първия ред създаваме нов прозорец, който да бъде първи в йерархията (в случай, че по-късно използваме още прозорци към приложението). Свързваме „delete_event“ – с методът, който предварително сме дефинирали. Това е важно, за да кажем на нашето приложение, че при натискане на бутона X в заглавната лента на прозореца искаме приложението да спира да работи. След което с set_title, set_icon_from_file и resize определяме какво да бъде заглавието на нашето приложение, къде се намира иконата на прозореца (директорията icons/ трябва да се намира при файла pybrowser.py) и определяме големината на прозореца по подразбиране 600×480 пиксела.

Време е да дефинираме и нашите съдържатели – ще използваме три: HBox, VBox и ScrolledWindow. Последният ще съдържа нашият браузър, за да можем при отварянето на страници, по-големи от нашият прозорец да използваме плъзгачи за скрол. С други думи добавяме следното:

        # контейнерът за webkit
        self.scroller = gtk.ScrolledWindow()
        # hbox и vbox сътоветно за хоризонтална и вертикална подредба
        self.vbox = gtk.VBox()
        self.hbox = gtk.HBox()

Няма никакво значение как ще ги подредите, тъй като самото им използване ще се случи малко по-надолу в кода. HBox ще използваме за текстовото поле, в което ще въвеждаме URL, бутонът за старт на зареждането и бутонът за презареждане. Остава да ги дефинираме и да ги добавим към съдържателя:
Първо да създадем нашето текстово поле:

        # Дефинираме нашето поле с името urltext
        self.urltext = gtk.Entry()
        # Задаваме на полето текст по подразбиране - не е задължително
        # но пък от друга страна е по-добре от празна кутия
        self.urltext.set_text("http://")
        # задаваме размер по подразбиране - първата стойност ще бъде пропусната по подразбиране
        # докато втората, ще се използва за задаване на височината, тъй като бутоните, които аз
        # използвам са с рамери 32x32. В случай, че използвате други размери, можете спокойно
        # да изтриете този ред
        self.urltext.set_size_request(600,38)
        # Свързваме действие, когато потребителя въведе адрес и натисне клавиша Enter
        # нещо, което повечето хора правят дори несъзнателно
        self.urltext.connect("activate", self.enter_pressed)

След като имаме полето за текст остава да създадем и двата бутона:

        # Създаваме нов бутон с името gobutton
        # В случай, че решите да не използвате изображение, можете да изтриете
        # следните 3 реда и да промените този на:
        #self.gobutton = gtk.Button("Go!")
        self.gobutton = gtk.Button()
        # Дефинираме обект за изображение goimage, в който ще запишем
        # изображението, което ще използваме за този бутон
        self.goimage = gtk.Image()
        # задаваме пътят към изображението
        self.goimage.set_from_file("icons/go.png")
        # прикачаме изображението към бутона
        self.gobutton.set_image(self.goimage)
        # Ако сте решили да не използвате изображения, тук трябва да спрете с триенето
        # Задаваме действие не бутона, когато той бъде натиснат искаме да се изпълни
        # методът go_clicked
        self.gobutton.connect("clicked", self.go_clicked) # the Go! button

        # Правим същото за бутонът за презареждане
        self.refresh = gtk.Button()
        self.refreshimage = gtk.Image()
        self.refreshimage.set_from_file("icons/reload.png")
        self.refresh.set_image(self.refreshimage)
        self.refresh.connect("clicked", self.refresh_browser) # The reload button

        # След като сме създали текстовото поле и бутоните трябва
        # да ги добавим към хоризонталния съдържател HBox
        self.hbox.pack_start(self.urltext)
        # Забележете вторият параметър False, той казва на Gtk
        # Че тези бутони трябва да използват минималното място,
        # от което се нуждаят за да бъдат показани
        self.hbox.pack_start(self.gobutton, False)
        self.hbox.pack_start(self.refresh, False)

Нека създадем и нашият браузър:

        # Дефинираме браузъра си като WebView - рамка за визуализиране
        # на HTML страници
        self.browser = webkit.WebView()
        # Просто защото е забавно задаваме още тук браузърът да отвори google
        # По този начин си имаме първоначална страница за зареждане
        # Ако искате да използвате файл, можете да добавите следното, като
        # предварително добавите import os при вмъкването на библиотеките:
        # self.browser.open("file://%s/file.html" % (os.getcwd()))
        self.browser.open("http://www.google.com/webhp?hl=en")
        # Използваме слушател, който да стартира метода title_changed, щом
        # заглавието на страницата бъде променено
        self.browser.connect("title-changed", self.title_changed)
        # Създаваме сигнал, който ще контролира нашата лента за зареждане
        # по този начин "слушаме" за промени
        self.browser.connect("load-progress-changed", self.load_progress_changed)
        # дефинираме какво трябва да се случи при започване на зареждане
        self.browser.connect("load-started", self.load_started)
        # дефинираме и какво трябва да се случи, когато страницата е заредена
        # тези методи ще създадем след малко
        self.browser.connect("load-finished", self.load_finished)
        # Добавяме, както споменахме по-рано браузърът в ScrolledWindow съдържател
        # така можем да използваме плъзгачи, в случай, че страницата е по-голяма
        # от нашия прозорец
        self.scroller.add(self.browser)

В следващата част от нашият код, ще извършим няколко неща наведнъж, а именно:
1. Ще създадем нашата лента за прогрес

        self.progress = gtk.ProgressBar()

2. Ще добавиме всичките до сега дефинирани джаджи във вертикалния съдържател, като не трябва да забравяте, че този тип съдържатели, могат да съдържат и други съдържатели:

        # Първо добавяме нашата хоризонтална кутия, с текстовото поле
        # и бутоните. Помните вторият параметър (Flase), оказва съответната
        # джаджа да не се разпростира много, а да използва от прозореца
        # само толкова, колкото й трябва
        self.vbox.pack_start(self.hbox, False)
        # Под бутоните и текстовото поле бихме искали директно да виждаме
        # нашият браузър
        self.vbox.pack_start(self.scroller)
        # И накрая добавяме лентата за прогрес, която по-късно ще скрием
        self.vbox.pack_start(self.progress, False)

3. Последното, което остана при дефинирането на нашия прозорец е той да съдържа дефинираните до сега съдържатели и да бъде показан. Това правим по следния начин:

        # Vbox вече съдържа всичките джаджи, които сме дефинирали
        self.window.add(self.vbox)
        # Казваме на нашият прозорец да покаже всичко, което сме му добавили,
        # включително и себе си
        self.window.show_all() # Just show everything

Малко действия

До тук това, което постигнахме е просто един прозорец, който в идеалния случай ще се зареди, но няма да бъде функционален, тъй като бутоните, и самите действия все още не са дефинирани. Прегледайте отново скелета на приложението. Ще разгледаме методите един по един. Като накрая ще добавим методите, който ще контролират нашата лента за прогрес (не мога да измисля по-точен превод на български, така че моля уважаемият читател да ме извини).

Натискането на клавишът [Enter]:

def enter_pressed(self, entry):
        self.browser.open(self.urltext.get_text())

Методът приема два параметъра – първо, че е част от класа, второто, че сигналът му е пратен от Entry – текстово поле. Това което казваме да се случи: нека браузърът (self.browser) отвори (open) съдържанието на текстовото поле. self.urltext – е нашето текстово поле и то има метод get_text(), който взима неговото съдържание. В Този метод можете да добавите и проверка, дали въведения адрес е валиден или пък ако искате при невалиден адрес, да отворите google търсачката. За целта нека ви покажа как можете да го направите по по-елементарния начин (без регулярни изрази):

def enter_pressed(self, entry):
    # съдържанието на текстово поле го записваме в променлива
    theurl = self.urltext.get_text()
    # и започваме да проверяваме:
    if "http://" in theurl or "www." in theurl:
        self.browser.open(theurl)
    else:
        # Ако няма http или www в адреса, допускаме, че това е
        # просто някакъв текст, за да го превърнем в текст, който
        # да добавим към адреса на google за търсене заменяме празните
        # полета със знака +
        searchterm = theurl.replace(" ", "+")
        # предаваме нов адрес, в който е и нашето понятие за търсене
        self.browser.open("http://www.google.com/search?sourceid=chrome&ie=UTF-8&q=%s" % searchterm)

Идентичен е и метода при натискането на бутона Go!. Разликата е в това, че сигналът се изпраща от бутон:

def go_clicked(self, btn):
    self.browser.open(self.urltext.get_text())

По същия начин описан по-горе, можете да си добавите и проверка. Би било добре тази проверка да я направите с регулярен израз, защото ще е по-смислено и по-практично.

Методът за нашият бутон за презареждане ще изглежда по следния начин:

def refresh_browser(self, btn):
    # За наше успокоение WebView от WebKit има тази функция вградена
    # и това, което трябва да направим е просто да я извикаме
    self.browser.reload()

Разбрахме се още в началото, че нашият браузър ще показва заглавието на настоящата страница – затова и добавихме сигнал при дефинирането на нашият браузър, това, което остава за нас е да кажем какво трябва да се случи.

def title_changed(self, webview, frame, title):
     # Тук това вече е част от нашият Gtk прозорец, затова и не извикваме
     # webkit на помощ, от него просто взимаме заглавието
    self.window.set_title(title)

Малкото, което остана е да дефинираме и три метода за нашата прогресна лента. Единият от тях трябва да разделя зареждането на стъпки. Другите два служат просто за прихващане на сигналите – „започване на зареждането“ и „приключване на зареждането“. WebKit ни улеснява изключително много и в трите метода. Като ни предлага всичко готово. Това, което се изисква от нас е да определим как ще бъдат разделени стъпките, за да ги разбере GTK и какво трявбад а се случва при започване на зареждане и когато страницата бъде заредена.

    def load_progress_changed(self, webview, amount):
        # Тук ще обясня какво е amount - това е цялото количество данни, които
        # ще бъдат изтеглени - това ни се подава от WebKit. За да работи
        # Нашата прогресна лента - трябва големината на данните, да разделим на 100.0
        # Нарочно не използваме integer - остава да подадем резултата на метода
        # set_fraction, който е част от gtk.ProgressBar
        self.progress.set_fraction(amount / 100.0)

    def load_started(self, webview, frame):
        # За да бъде по-интерактивен браузъра показваме
        # лентата за зарежда само, когато има зареждане
        self.progress.show()

    def load_finished(self, webview, frame):
        # Щом зареждането приключи взимаме адреса на заредената
        # страница и го записваме в текстовото поле за адрес
        # след което скриваме лентата за зареждане, за да не ни пречи
        self.urltext.set_text(frame.get_uri())
        self.progress.hide()

Край

Надявам се с този урок да сте разбрали колко е лесно да направите собствен браузър с Python и WebKit. Това, което можете да приемете като домашно е да разгледате другите методи, и действия, които ви предлага Webkit и просто да ги добавите във вашето приложение. Тъй като за момента не успях да намеря публично API, с python-webkit аз използвах това, което е за C – не се различават по нищо, тъй като ако не знаете, Python почти без проблем използва WebKitWebView С-библиотеките като собствени.

Разбира се можете да изтеглите и крайният резултат в случай, че имате проблем с разбирането на целия текст.
PyBrowse (13.08 KB) 34 изтегляния

Съществуват много причини за архивиране: събрани и архивирани файлове спестяват място на твърдия диск и трафик при изпращането им през интернет. Под Linux има както графични приложения (както File Roller под GNOME или Ark под KDE), така и такива работещи в терминала, които поддържат архивирането и разархивирането на различните типове формати. Тази статия ще ви представи конзолните приложения и как да работите с тях (команди, параметри), за да „опаковате“ и „разопаковате“ различни архиви.

Добре gzip-нат

Програмата Gzip (GNU Zip) и стандартния „опаковчик“ под Linux. Gzip архивира обикновени файлове; инструмента не може да архивира цели директории. Най-обикновеното извикване на инструмента е:
gzip файл1
По този начин от файл1 създава файла файл1.gz. Gzip заменя оригиналния файл с едно неговия компресиран вариант с окончания .gz. Особеностите на файла като права, дата на създаване и редакция остават запазени в пакета. Ако не ви харесва окончанието на файла, можете да го промените с параметъра -S (Suffix). Ето и как ще изглежда командата:

gzip -S .z снимка.bmp

Резултата ще бъде снимка.bmp.z
Големината на създадените архиви зависи най-вече от разпределението на информацията в оригиналните файлове. В случай, че във файла има много повтарящи се части, то тогава този файл ще бъде доста добре архивиран. Архивирането на вече компресирани файлове като MP3 или JPG, няма да доведе до особен резултат. За пример ще покажа разликата между два файла .bmp и .jpg:

>$ ls -l
total 1320
-rw-r--r-- 1 vladi vladi 1254214 2010-04-20 14:58 zhbackground.bmp
-rw------- 1 vladi vladi   82261 2010-04-20 14:59 zhbackground.jpg
$ ls -l
total 1000
-rw-r--r-- 1 vladi vladi 928469 2010-04-20 14:58 zhbackground.bmp.gz
-rw------- 1 vladi vladi  82151 2010-04-20 14:59 zhbackground.jpg.gz

Освен това можете да повлиаете големината на файла с фактора на компресиране от 1 до 9, където gzip -1 компресира файла сравнително по-бързо в сравнение с gzip -9, но скоростта е за сметка на качеството. Стандартната стойност за gzip е -6. Ако желаете да промените стойността по подразбиране ще трябва да добавите следния ред във файла ~/.bashrc – export GZIP="9".
За да разархивирате вече архивиран файл можете да използвате инструмента gunzip или gzip -d. В случай, че в директорията съществува файл със същото име, приложението ще ви попита дали искате да презапишете съществуващия файл:

$ gunzip zhbackground.jpg.gz
gzip: zhbackground.jpg already exists; do you wish to overwrite (y or n)?

Ако в този момент отговорите с [N], Gzip ще прекъсне процеса и файла няма да бъде разархивиран. Ако намирате въпроса за сигурност ненужен, можете да включите параметъра -f (от английски „force“ = „наложително/насилствено“). Този параметър има и друг ефект: Gzip по подразбиране отказва да архивира(компресира) символични връзки (Symlink) на файла. Ако използвате параметъра -f върху символична връзка ще бъде архивиран файла, към който сочи връзката и ще зададе като име на архива името на символичната връзка. При „разопаковането“, обаче, ще получите като резултат нормален файл, а не връзка.
Не се налага разархивирането на архивирани файлове, на пример HOWTO файловете от /usr/share/doc/, за да ги чете с приложения като less или more. Става по-бързо когато към gzip добавите параметъра -c (пиши в stdout) и свържете изхода на командата с четящото приложение, за да е по-ясно командата изглежда така:

gzip -dc /usr/share/doc/iptables/README.Debian.gz | less

Горния пример можете да бъде съкратен изключително много ако използвате zless файл.gz. Зад тази команда стои един малък скрипт, който реално прави почти същото, както горната по-дълга команда. Аналогично на zless съществуват и други модификации на Linux инструменти като zcat и zgrep.

По-бърз и по-добър: bzip2

Програмата Bzip2 използва друг алгоритъм за компресиране и по този начин архивира обикновените файлове значително по-добре, както можете да видите от примера:

$ ls -l
total 3032
-rw-r--r-- 1 vladi vladi 1254214 2010-04-20 15:22 zhbackground.bmp
-rw-r--r-- 1 vladi vladi  812743 2010-04-20 15:23 zhbackground.bmp.bz2
-rw-r--r-- 1 vladi vladi  928469 2010-04-20 15:22 zhbackground.bmp.gz

Освен това bzip2 разполага с така наречения Rcovery-режим: при компресиране, инструмента разлага файла на отделни блокове. Ако даден файл е повреден, имате възможността все още да възстановите съдържанието му от здравите блокове – за целта разполагате с инструмента bzip2recover, с който можете да разархивирате неповредените данни от файла.
Ако оставим на страна някои малки различия, използването на bzip2 са почти същите, както при Gzip. И тук за най-обикновено компресиране е достатъчно да извикате командата bzip2 file. Компресирания файл получава окончанието .bz2 и както при Gzip компресираният файл получава същите свойства, както и изходния файл. За разлика от Gzip, инструмента Bzip2 приема и параметъра -k (от английски „keep“ = „запази“), с който създава резервно копие на файла след като същия бъде компресиран (архивиран).
Същото можете да постигнете с Gzip, но този път трябва да насочите изхода на командата да бъде записан в друг файл използвайки символа „>“, който посочва къде да бъде записан изхода от предната команда:

gzip -c файл > файл.gz

За съжаление по този начин компресирания файл не приема свойствата на изходния (напомням става дума за права върху файла, дата на създаване и промяна).
Както и при Gzip разполагате с параметрите -1 до -9 (стандартно) и в Bzip2, с които да окажете фактора на компресиране. Ако искате да промените стойността по подразбиране – става по същия начин, както и с Gzip – във файла ~/.bashrc добавяте реда export BZIP2="-6".
За разархивиране с Bzip2 добавяте параметъра -d или използвате специалната команда bunzip2, както и при Gzip има предпазване от презаписване на файлове, с тази разлика, че приложението не ви пита какво да направи:

$ bunzip2 zhbackground.bmp.bz2

bunzip2: Output file zhbackground.bmp already exists.

За да преодолеете защитата можете да използвате параметъра -f.

Още по-добре

Въпреки, че gzip и bzip2 са стандарти в Linux, съществуват и доста наследници като lzma, p7zip и xz, които от части са по-бързи или използват по-добри алгоритми за компресиране. Някои дистрибуции (като Slax) използват lzma за компресирането на софтуерни пакети, за да позволят добавянето на повече приложения в живия диск или да намалят времето за изтегляне от интернет.

И сега в архива

За да съберете повече файлове в даден архив използвате командата Tar. Името на програмата (от английски "tape archiver"), дава информация за произхода на приложението: tar се е използвал за контрола на лентови архиви. Tar дава малко повече от това просто да събира файлове в един архив. С добавянето на определени параметри можете да комбинирате работата му с приложенията gzip или bzip2 и по този начин получавате файлове с разширения tar.gz или tar.bz2.
За да съберте няколко файла в един архив като използвате командата:

tar -cvf архив.tar файл1 файл2

Трите параметъра -c, -v, -f, които използваме в горния пример се грижат за това - tar да създаде (-c = create), покаже какво се случва (-v = verbose) и да приеме като първи аргумент (-f = file) името на архива, който ще създаде.
Ако по-късно установите, че сте забравили някой файл, не е необходимо да създавате нов архив, а просто да добавите забравения файл:

tar -rf архив.tar файл3

Също толква лесно е и разопаковането с параметъра -x:

tar -xvf архив.tar

За да сме сигурни, че при разархивирането Tar няма да презапише вече съществуващи файлове със същото име, можем да разархивираме архива във временна поддиректория или да накараме tar да работи в сух режим (да симулира разархивирането), като за последното заменяме параметъра -x с -t.
За да архивирате директории с техните поддиректории и файлове е нужно да зададем само името на директорията вместо отделните файлове:

>$ tar -cvf архив.tar test/
test/
test/test2/
test/test2/zhbackground.jpg
test/test2/testfile3.txt
test/testfile.txt
test/testfile2.txt

Ако искате да използвате Tar за създаването на backup, може да бъде доста полезно ако не желаете да добавяте определени директории. За целта помага параметъра --exclude. Освен това полезно би било при създаването на подобни копия да използваме и параметъра --rsh-command, като по този начин казваме на Tar че искате нашето копие да бъде копирано чрез SSH на друг компютър. Един доста пълен пример би изглеждал така:

tar -cvf user@host:/backup/tmp/backup_$(date '+%Y_%m_%d').tar --rsh-command=/usr/bin/ssh --exclude=/proc /

Разшифрована сравнително дългата команда означава следното: Създай чрез SSH на компютъра host в директорията /backup/tmp едно копие (backup) с името backup_, актуалната дата (date '+%Y_%m_%d') и разширение на файла .tar (за днешна дата файла би бил: backup_2010_04_20.tar). Като това копие трябва да съдържа всичко от / (root) директорията без директорията /proc, която от своя страна не съдържа истински файлове.

И сега всички!

Както вече споменахме, Tar разполага с няколко параметъра, които позволяват комбинирането му с Gzip и Bzip2. За създаването на компресиран архив с помощта на Gzip командата би изглеждала така:

tar -czvf архив.tar.gz файл(ове)

Ако искате вместо това да използвате Bzip2 трябва да промените параметъра -z с параметъра -j:

tar -cjvf архив.tar.bz2 файл(ове)

Съответно използвате същите параметри за обратната операция (разархивиране). Като използвайки tar по този начин си спестявате една цяла стъпка, в която вместо да използвате приложенията отделно:

bunzip2 архив.tar.bz2
tar -xvf архив.tar

използвате простия вариант: tar -xjvf архив.tar.bz2

Надявам се с тази статия да сте получили основните познания за архивирането под Linux и ако имате желание можете да прегледате останалите възможности, които крият споменатите инструменти.

Песента от клипа е Test Drive на Zapac лицензирана под Attribution (3.0).

Съвсем скоро в BulTux…

Gnome 2.30 е вече факт и ще може да краси вашия десктоп с новите версии на популярните дистрибуции като Ubuntu, Fedora, openSuSe в следващите им версии. Като цяло подобренията сравнени с версия 2.29 са насочени повече към основната работа на десктоп средата и новостите в интерфейса са сравнително малко. Доста от добавените неща са просто подобрения, но както винаги има и с какво да бъде изненадан уважаемия потрбеител. За да не се впускам в пълен преглед на новостите ще се съсредоточа върху промените, важни за потребителите и в края на статията ще добавя списък с новостите за разработчици.

Накратко това, което ще прегледаме в статията:

• Подобренията в Nautilus
• Синхронизиране на бележките от Tomboy
• Управление на потребителите
• Контрол над PDF файловете
• Подобрения по Epiphany
• Други дребни промени, които си струва да бъдат отбелязани

Подобренията в Nautilus

Nautilus с разделен прозорец

За тези, които незнаят Nautilus е файловият мениджър в GNOME и с новата версия на популярната десктоп среда, в него са включени някои доста приятени и нови функции. Една от тези, които определено може да се каже, че бяха чакани от доста време е разделеният прозорец. С предната версия потребителите получиха табове, но определено използването на табове, когато работите с две или повече директории е доста неудобна функция (все пак трябва да сменяте от един таб в друг), с новата версия на файловия мениджър, ще можете да разделите прозореца на Nautilus и да преглеждате едновременно две директории, като с метода drag’n'drop ще можете да прехвърляте файлове и директории от едното поле в другото. Потербителят няма да бъде ограничен в подредбата на файловете в двете полета, което означава, че в едното поле можете да подредите файловете като списък, в другото като икони, според това как на потребителя ще му бъде удобно. Друга интересна промяна е режима на работа по подразбиране на Nautilus, за повечето потребители на Ubuntu вероятно не е известно, че по подразбиране Nautilus работи в „spatial“ режим (всяка директория се отваря в нов прозорец) – сега това е променено в режима, който повечето сте свикнали – Brose – това е настройката, с която Ubuntu слага за потребителите по подразбиране (за разлика от Fedora примерно).

Лесно синхронизиране на вашите бележки

Приложението Tomboy, което служи за бележки на вашия десктоп (sticky notes) ще може да се синхронизира бележките ви автоматично за разлика от досегашния начин на работа, където това беше задача на потребителя. Разбира се с новата функция ще можете да определяте и колко често Tomboy да синхронизира вашите бележки. Друга важна подробност е подобрената функция за копиране и вмъкване на съдържание като в момента без проблем можете да вмъквате форматиран текст от други приложения (html страници, openoffice документи и т.н.). Работено е и върху скоростта на зареждане – нещо, което лично немога да потвърдя, тъй като не ползвам приложението.

Управление на потребителите

Инструмента Gnome System Tools също е претърпял доста промени, като е променен метода за автентикация на потребителите, използвайки PolicyKit вече бутона Unlock е излишен и ако потребителят, с който сте влязъл в системата има необходимите права няма да имате проблем с контрола върху потребителите. Диалогът за създаване на потребител също е претърпял промени като е опростен до съвсем елементарно въвеждане на потребителско име с предложения за такова и е добавена възможност за автоматично създаване на криптирана лична директория още при създаването на потребителя. Освен това контролът върху потребителите също е направен изключително лесен, предлагайки ви да избирате определени роли за потребителите, вместо избиране на позволени действия от един сравнително голям списък, което от своя страна предлага по-лесно добавяне на права на даден потребител.

Контрол върху PDF документите

Изключително лекото приложения за преглед на PDF документи е претърпяло голяма промяна. Освен подобрения диалог за разпечатване с вмъкнати настройки за страниците и начина на разпечатване, промените по функционалността доста са се приближили до едноименния Reader на Adobe®. Някой от новите функции са:

• Режим за обръщане на цветовете
• Подобрен режим за презентации
• Възможност за бележки към прикачени файлове в PDF документите
• Поддръжка на файлове извън PDF документа

Подобрения по Epiphany

Epiphany все още назад с материала

Браузърът на GNOME макар и изключително непопулярен сред големите (Firefox, Chrome, Opera) също се старае да достигне функционалносттите на отвърдените браузъри базирайки се изцяло на GTK инструментите. Някои от промените включват добавени възможности за настройки като включване и изключване на добавките към браузъра; съобщения при преглеждане на страници със счупени SSL сертификати и др. По-интересните промени в интерфейса са:

• Функцията за преглед преди разпечатка е добавена отново
• Десен бутон върху обект, за да го запишете (Save Target As – познатото от Firefox)
• Възстановена поддръжка за favicon-и.
• Вмъкване на съдържание от clipboard-а със средния бутон на мишката (онази яка функция, която не всеки знае)
• Завръщане на контекстните менюта
• Премахната е страничната лента от браузъра

Неизбежно при развитието на web и все по-бързото навлизане на html5 е да се появи и поддръжката за html5, макар и под формата на разширение, потребителите ползващи Epiphany ще могат с едно такова приложения да гледат youtube клиповете в html5 вариант ако нямат flash плайър.

Други по-малки промени

• Приложението за работа с компресирани архиви FileRoller ще инсталира автоматично липсващи приложения за поддържани типове архиви използвайки права в PolicyKit
• Инсталирането на шрифтове ще става с двойно кликване върху файла с шрифта в Nautilus
• При използване на различни клавиатурни подредби аплета за клавиатурните подредби ще се зарежда автоматично в лентата за уведомяване, съответно аплета за клавиатурни подредби е премахнат и няма да можете да го добавяте ако нямате различни клавиатурни подредби.
• и други коригирани бъгове и дребни промени

Заключение

Gnome 2.30 се явява последното част от пътя към GNOME 3.0, където потребителите ще могат да се радват на много по-разширена функционалност с Gnome Shell и Gnome Activity Journal. Първото ще трябва да улесни работата с компютъра при елементарни задачи с десктоп средата – писане на документи, преглеждане на страници и подобни, като целта е да се предложи по-бърз и лесен вариант за работа. Ако имате желание да го опитате и ползвате Ubuntu 9.10 то е достатъчно просто да го инсталирате от пакетния мениджър:

sudo aptitude install gnome-shell

и за да го стартирате:

gnome-shell --replace

Activity Journal пък от своя страна ще ви позволи да имате пълен контрол върху документите си и ще улекоти търсенето на такива. Всъщност това ще е просто графичният интерфейс за Zeitgeist.

Колко сигурна е пароалта ви?

Рядко човек се замисля дали паролата, която използва е сигурна. Всъщност масово хората използват пароли, които са лесни за запомняне. От гледна точка на сигурността това винаги е грешно, но е в самото мислене на човека. Доста често срещам хора, които ползват една и съща парола навсякъде, в най-добрия случай използват няколко пароли навсякъде и то с идеята, че са лесни за запомняне и няма да ги забравят. Но колко сигурни са тези пароли? Изобщо би ли се досетил някой за тях. Хората, работещи по това да разбират чужди пароли за добро или лошо са измислили различни методи за разбиването им. Някои от тези методи са свързани с логика, друга част се базират на най-често използваните пароли или на списъци с такива. С тази статия ще се опитам да ви покажа какво трябва да имате предвид при избора на своята парола и какво трябва да избягвате.

Най-честите грешки в избора на парола

Едно от основното правило при избора на парола, което не всички хора следват е използването само на малки букви или пък само на цифри. Много хора мислят, че използвайки за парола рождената си дата са се защитили. Донякъде е така, но в момента почти всеки е регистриран във Facebook – съответно всеки може да провери кога е вашият рожден ден – от там не е трудно да почне да тества пощата ви с различни комбинации. Имена, думи и подобни пароли също не са особено трудни, тъй като се изисква малко мислене и налучкване или сдобиването с wordlist (обикновено текстов файл с огромен брой различни думи и имена), който се използва в комбинация с програма, която да върши тестването автоматично т.нар. BruteForce – програмата праща заявки към формата за име и парола със зададените потенциални пароли от списъка с думи, докато не уцели. В крайна сметка използването на цифри или обикновени за парола е изключително несигурно. Също толкова несигурно, колкото и използването на имена на домашни любимци и подобни.

Тук бих искал да вмъкна и информацията за един инструмент наречен CUPP (Common User Passwords Profiler), който представлява един Python скрипт, който на база информация за даден потребител – рождена дата, две/три имена, прякор, данни за близки и домашни любимци генерира списък с възможни пароли. Всеки използващ този инструмент и поровил се достатъчно в интернет, за да събере информация за вас би могъл да генерира списък, в който е възможно да присъства вашата парола. Всъщност самия инструмент е много полезен и за обикновените потребители, тъй като по този начин могат сами да тестват колко е сигурна паролата им. Но тук винаги трябва да имате предвид, че програмата може да направи грешка, тъй като не е перфектна.

Друга грешка при използването на различни пароли е тяхното записване в каквато и да е форма с цел запомняне. Самото записване на пароли в тефтерчето, което „никой не вижда“, в телефона „който никой няма да прегледа“ и т.н. е грешно. Замислете се над това, колко е сигурен вашият телефон? Много хора го смятат за изключително сигурен и неподлежащ на атака, но всъщност е толкова лесно, колкото не можете да си представите. Напълно е възможно някой да се свърже към телефона ви през Bluetooth и да извлече цялата информация от него. Повече информация по въпроса можете да прочетете в следния pdf документ: Bluetooth_Hacking.pdf. Тефтерчето ви винаги може да попадне в чужди ръце дори, когато не подозирате. Опитвайте се да запомните паролите си. Или ако ги записвате – никога не ги записвайте на важен документ и никога не посочвайте, че това е парола – нека бъде просто някакъв текст някъде си, а ако използвате примерите за създаване на по-сигурна парола, не я записвайте със специалните знаци и цифрите – нека не личи, че това е парола.

Как да изберем сигурна парола?

За да изберете сигурна парола имате в общи линии два избора:

• Избор на парола, която по-лесно да запомните
• Генериране на парола, която ще трябва да опитате да запомните

В първия случай трябва да изберете дума или фраза, която да преобразувате в парола. Това е може би най-лесния начин да си изберете сравнително сигурна и лесна за запомняне парола. Как обаче да го направите? Намислете си фраза, която често използвате или която харесвате. И я пренапишете, заменяйки буквите с цифри, големи букви и знаци. За примера ще използваме bultuxpassword – на пръв поглед изключително елементарна и лесна за досещане парола. Но как да преобразуваме тази толкова елементарна парола в нещо по-сложно? Следвайки принципа – големи/малки букви, цифри и символи ние започваме да заменяме, така че за краен резултат получаваме:

Bu!TUx_p4sSW0rD

Е тази парола няма да намерите в списъците с пароли и ще е достатъчно сигурна. Разбира се не е най-сигурната парола, но със сигурност ще е по-добре от различни други комбинации. Ще ви дам още няколко примера:

godspower = g0d5_!p0w3r
Marlboro = m4r!b0rO_
и т.н.

Разбира се по-добрия и най-сигурен вариант за момента е използването на генерирана парола. Парола, която няма да е свързана с вас по никакъв начин и няма да има никакво значение. За целта можете да използвате различни приложения за генерирането на такива. Не съм се интересувал особено какви видео генератори на пароли има, но за тези от вас, които харесват езика за програмиране Python могат лесно и бързо сами да си спретнат един малък скрипт или пък да използват друг език за програмиране за да си направят малка програмка за целта. Принципа е следния според това каква парола искате да имате. Дали тя да бъде само от букви+цифри, дали да бъде букви+цифри+специални знаци, или пък да използвате шестнадесетичната бройна система. от там остава просто да създадете стринг и да използвате функцията за random във вашия език за програмиране, с който да изберете няколко символа от този стринг. Казах малко по-рано, че използвам Python за моя генератор, защото функцията string ми позволява да използвам и боравя с тези методи по-лесно. Следващото е само за тези, които се интересуват от това как става:
1. Създаваме метод, който да разбурка даден стринг и да върне паролата с определена дължина:

def generate_sample(choices, length):
    return random.sample(choices * length, length)

2. Създаваме и след което можем да използваме този метод в нашия скрипт, като му подадем стринг от символи и дължината на паролата, която трябва да генерираме. Аз лично съм създал няколко метода в зависимост от това каква парола искам. За парола само от букви+цифри метода би изглеждал така:

def alphanum(length):
    sample = generate_sample(string.letters + string.digits, length)
    return ''.join(sample)

За да използвате тези методи предварително ще трябва да се добавили във вашия скрипт следните библиотеки: random и string.

Ако все пак ви потрябва приложението можете да го изтеглите от BulTux. За целта ще е нужно да имате инсталиран Python:
pyspgen (64.36 KB) 28 изтегляния

За почитателите на bash можете да погледнете и друго решение:

#!/bin/bash

charspool=('a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p'
'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y' 'z' '0' '1' '2' '3' '4' '5' '6' '7'
'8' '9' '0' 'A' 'B' 'C' 'D' 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O'
'P' 'Q' 'R' 'S' 'T' 'U' 'V' 'W' 'X' 'Y' 'Z' '!' '£' '$' '%' '&' '=' '.' ',' ';' ':' '-' '_');

len=${#charspool[*]}

if [ $# -lt 1 ]; then
        num=6;
else
        num=$1;
fi

echo -n "password: "
for c in $(seq $num); do
        echo -n ${charspool[$((RANDOM % len))]}
done
echo

Скриптът е взет от: My. Debian

Надявам се статията да ви е била полезна. Ако имате забележки или предложения за приложения, които да бъдат описания не се притеснявайте да ги запишете в коментарите.

]]> http://www.bultux.org/tutorials/kolko-sigurni-sa-parolite-koito-polzwame/feed 2 http://www.bultux.org/applications/moc-%d0%ba%d0%be%d0%bd%d0%b7%d0%be%d0%bb%d0%b5%d0%bd-%d0%b0%d1%83%d0%b4%d0%b8%d0%be-%d0%bf%d0%bb%d0%b5%d1%8a%d1%80-%d0%b7%d0%b0-linuxunix http://www.bultux.org/applications/moc-%d0%ba%d0%be%d0%bd%d0%b7%d0%be%d0%bb%d0%b5%d0%bd-%d0%b0%d1%83%d0%b4%d0%b8%d0%be-%d0%bf%d0%bb%d0%b5%d1%8a%d1%80-%d0%b7%d0%b0-linuxunix#comments Sat, 13 Mar 2010 01:25:21 +0000 Станислав Христов http://www.bultux.org/?p=357
MOC – Music On Console , е конзолен аудио плеър за Linux/UNIX ,създаден ,за да бъде мощен и в същото време лесен за употреба. Интерфейсът му наподобява много на Midnight Commander.Възпроизвежда много формати,като се почне от mp3,Ogg Vorbis,FLAC и се стигне до Musepack,Speex,WAVE, AIFF, AU и редица други по-малко известни.Последната стабилна версия е 2.4.4.Официална страница [...]]]>

MOC – Music On Console , е конзолен аудио плеър за Linux/UNIX ,създаден ,за да бъде мощен и в същото време лесен за употреба. Интерфейсът му наподобява много на Midnight Commander.Възпроизвежда много формати,като се почне от mp3,Ogg Vorbis,FLAC и се стигне до Musepack,Speex,WAVE, AIFF, AU и редица други по-малко известни.Последната стабилна версия е 2.4.4.Официална страница на проекта – http://moc.daper.net.

.При новите версии на Дебиан базираните дистрибуции MOC е наличен в пакетният мениджър.Ако пакетът отсъства по някаква причина ,то той може да бъде добавен през хранилищата на Debian Sid ,като в /etc/apt/sources.list се добавят следните редове:

deb http://www.lxtec.de/debarchiv unstable main
deb-src http://www.lxtec.de/debarchiv unstable main

След това инсталацията протича по обичайния ред:

# apt-get update && apt-get install moc

Инсталацията също може да се извърши и от сорс ,като се свали желаната версия от секция Download на официалния сайт.
След като инсталацията приключи,плеърът се стратира от конзола с команда $ mocp.
Изгледът на програмата с настройки по дефолт е нещо приблизително такова:

Навигирането се осъществява чрез стрелките на клавиетурата.

Основни клавишни комбинации при работа с MOC

Тук се спирам само на най-основните клавишни комбинации,необходими при работата с плеъра

• Tab – прехвърля фокуса от лявия панел (директориите) в деснията панел (плейпистът)
• Enter – когато фокусът е в левия панел – влиза в маркирана директория
• Enter – когато фокусът е в десния панел – възпроизвежда маркирания аудио файл
• Q – спира възпрозвеждането и прекратява работата на плеъра(Изключва го)
• q – извежда конзола без да прекратява възпроизвеждането на плейлиста
• s – спира изпълнението на плейлиста ,без да извежда конзола
• < / > – усилва  / намаля звука ( с по 1%)
• Space – Пауза
• а – добавя маркираната в ляво папка като плейлист в дясно
• C – изчиства плейлиста ( без да прекратява възпроизвеждането на започнат вече файл)

Пълният списък с клавишните комбинации и команди на плеъра може да видите с H

Настройки

Настройките на MOC се осъществяват и са съхранени в конфигурационен файл config ,който се намира в директория .moc ,която от своя страна се намира в домашната директория , т.е  ~/.moc/config.Един примерен,но доста подробен и функционален файл за MOC изглежда така:

# This is a configuration file for the MOC player. It should be named 'config'
# and placed in directory ~/.moc/
# Comments begins with '#'.
# You can use quotes and escape ('\') in parameters

# Show file titles (title, author, album) instead of file names.
ReadTags        = yes

# Directory in which you store music files, if you specify it, you will be able
# to quickly go to this directory with the '-m' parameter or the 'm' command.
# This can also point to a playlist.
MusicDir        = "/home/niels/Musik"

# How to sort? FileName is the only option for now.
Sort            = FileName

# Show errors in the streams, for example CRC errors or broken frames in mp3
# files
ShowStreamErrors    = no

# Ignore CRC errors in MP3 files. Most players do that, so the default value is
# set to yes.
Mp3IgnoreCRCErrors    = yes

# Turn on repeat.
Repeat            = yes

# Turn on shuffle.
Shuffle            = no

# Turn on AutoNext
AutoNext        = yes

# Default FormatString
# %n - Track number
# %a - Artist
# %A - Album
# %t - Title
# %(X:TRUE:FALSE) - ternary expression - if X exists, do TRUE, otherwaise
#                   FALSE. '\' - escape character (must be double, because of
#                   config interpreter). man zshmisc for more info.
FormatString        = "%(n:%n :)%(a:%a - :)%(t:%t:)%(A: \(%A\):)"

# Output buffer size in kilobytes. Minimum value is 128KB. */
#OutputBuffer        = 2048

# Input buffer size in kilobytes. Minimum value is 32KB. */
#InputBuffer        = 512

# How much to fill the input buffer before playing (in kilobytes)?
# This can't be more than InputBuffer value.
# Remember that for network streams beside the positive effect this also causes
# delay between what you can hear and what is broadcasted.
#Prebuffering        = 64

# Use this HTTP proxy server for internet streams. If not set, the
# environmential variables http_proxy and ALL_PROXY will be used if present.
#HTTPProxy        = my_proxy:port

# Sound driver - OSS, ALSA, JACK, or null (only for debugging)
# You can enter more than one driver separated by a coma. The first working
# driver will be used.
SoundDriver        = ALSA

# Jack output settings
#JackOutLeft        = "alsa_pcm:playback_1"
#JackOutRight        = "alsa_pcm:playback_2"

# OSS output device
#OSSDevice        = /dev/dsp

# OSS Mixer device
#OSSMixerDevice        = /dev/mixer

# OSS Mixer channel: pcm or master
#OSSMixerChannel        = pcm

# Second OSS Mixer channel: pcm or master
#OSSMixerChannel2    = master

# ALSA mixer device
AlsaMixer         = PCM

# Second ALSA mixer device
AlsaMixer2        = Master

# ALSA output device
#AlsaDevice        = default

# Show files with dot at the beginning?
ShowHiddenFiles        = no

# Start in the music directory if no arguments are given. If set to no, start
# in the current directory.
StartInMusicDir        = yes

# Hide file name extensions
HideFileExtension    = no

# Show file format in menu.
ShowFormat        = yes

# Show file time in menu. Possible options: yes, no, IfAvailable - show the
# time only when it was read before (often works faster)
ShowTime        = IfAvailable

# Theme file. This can be absolute path or relative to
# /usr/share/moc/themes/ (depends on installation prefix) or ~/.moc/themes/
Theme            = /usr/share/moc/themes/linali_theme

# The theme used when running on xterm
#XTermTheme        = green_theme
XTermTheme        = linali_theme

# MOC directory - where pid file, socket, and state files are stored.
# You can use ~ at the begining
MOCDir        = ~/.moc

# Use mmap() to read files. mmap() is much slower on NFS.
UseMmap            = no

# Perform character set conversion using iconv() to tags and file names
# read from playlist files. This option has format: FROM:TO.
# To get list of supported sets use the iconv -l command.

# Assume this encoding for ID3 version 1/1.1 tags (mp3 files). Unlike ID3v2
# UTF-8 is not used here and MOC can't guess how tags are encoded. Another
# solution is using librcc (see the next option). This option is ignored
# if UseRCC is set to yes.
ID3v1TagsEncoding        = WINDOWS-1251

# Use librcc to fix ID3 version 1/1.1 tags encoding.
#UseRCC                = yes

# Remember the playlist after exit?
SavePlaylist        = yes

# When using more than one client (interface) at a time, do the share the
# playlist?
SyncPlaylist        = yes

# Choose a keymap file (relative to ~/.moc/ or absolute path)
# Example keymap with description is included (keymap.example).
#Keymap            = my_keymap

# Use ASCII characters instead of graphic for drawing lines. This helps on
# some terminals.
ASCIILines        = no

# FastDirs, these allow you jump directly to a directory, the key bindings are
# in the keymap file.
#Fastdir1 = /mp3/rock
#Fastdir2 = /mp3/electronic
#Fastdir3 = /mp3/rap
#Fastdir4 = /mp3/etc
#Fastdir5 =
#Fastdir6 =
#Fastdir7 =
#Fastdir8 =
#Fastdir9 =
#Fastdir10 =

# How fast to seek? Number of seconds per key stroke.
#SeekTime        = 1

# How fast to seek (when using silent seeking)? Number of seconds per key
# stroke.
#SilentSeekTime        = 5

# Resample method to use. There are few methods of resampling sound supported
# by libresamplerate. The default is the fastest (linear). Better description
# is here: http://www.mega-nerd.com/libsamplerate/api_misc.html#Converters
#
# High quality (based on bandlimited interpolation), but slow methods:
#
# SincBestQuality - really slow (I know you probably have an xx GHz processor,
#            but it's not enough to not see this in the top output :)
#            The worst case Signal-to-Noise Ratio is 97dB.
# SincMediumQuality - much faster
# SincFastest - the fastest bandlimited interpolation
#
# Poor quality, but much faster methods:
#
# ZeroOrderHold - really poor quality, but it's really fast
# Linear - a bit better and a bit slower
#
#ResampleMethod        = Linear

# Always use this sample rate when opening the audio device (and resample the
# sound is necessary). When set to 0 the device is opened with the file's rate.
#ForceSampleRate    = 48000

# By default even if the sound card reports that it can output 24bit samples
# MOC converts 24bit PCM to 16bit. This option set to yes allows MOC to use
# 24bit output (for example MP3 decoder uses this format). This is disabled
# in the default configuration because there were reports that it prevents
# from playing MP3 files on some soundcards.
#Allow24bitOutput    = no

# Use realtime priority for output buffer thread. This will prevent gaps while
# playing even with heavy load. The user which runs MOC must have permissions
# to set such a priority. This could be dangerous, because it is possible that
# a bug in MOC will freeze your computer.
#UseRealtimePriority    = no

# Size of the in-memory cache for file tags in KB.
TagsCacheSize        = 256

# Number items in the playlist.
#PlaylistNumbering    = yes

# Main window layoutis can be configured. You can change the position and the
# size of the menus (directory and playlist). You have 3 layouts ant switch
# between then using the 'l' key (standard mapping). By default only 2 layouts
# are configured.
#
# The format is as folows:
# Each menu is described in format NAME:POSITION_X,POSITION_Y,WIDTH,HEIGHT
# NAME is directory or playlist
# Other parameters define position and size of the menu. They can be absolute
# numbers (like 10) or a percent value of the screen size (like 45%).
# WIDTH and HEIGHT can have value of FILL which means fill the screen from
# the menu's position to the border.
# Separate menu descriptions using a space.
# Menus may overlap.
# You must describe at least one menu (default is to fill the whole window).
# There must be at least one layout (Layout1) defined. Other can be empty ("").
#
# Examples:
#
# Just one layout, the directory will occupy the whole screen, the playlist
# will have 1/4 of the screen size and be positioned at lower right corner.
# Layout1 = "playlist:50%,50%,50%,50%"
# Layout2 = ""
# Layout3 = ""
#
# The scrren is split into two parts: playlist at the top and the directory
# menu at the bottom. Playlist will occupy 10 lines and the directory menu
# the rest.
# Layout1 = "playlist:0,0,100%,10 directory:0,10,100%,FILL"
#
# Default configuration:
# Layout1        = "directory:0,0,50%,100% playlist:50%,0,50%,100%"
# Layout2        = "directory:0,0,100%,100% playlist:0,0,100%,100%"
# Layout3        = ""

# When the song changes, should the menu be scrolled so that the currently
# played file is visible?
FollowPlayedFile    = yes

# What to do if the interface was started and something from the playlist is
# playing? If CanStartInPlaylist is set to "yes", the interface will switch to
# the playlist. When set to "no" it will start from the last directory.
CanStartInPlaylist    = yes

# Executing external commands (1 - 10) invoked with key commands (F1 - F10 by
# default).
# Some arguments are substituted befor executing:
# %f - file path
# %i - title made from tags
#
# Data from tags:
# %t - title
# %a - album
# %r - artist
# %n - track
# %m - time of the file (in seconds)
#
# Parameters above applys to the currently selected file. If you change them to
# capital letters, they are taken from the currently played file.
#
# Programms are run using execv(), not a shell, so you can't do things like
# redirecting the output to a file. The command string is split using blank
# characters as separators, the first element is the command to be executed
# and the rest are parameters, so if you use "echo Playing: %i" we run program
# echo (from $PATH) with 2 parameters: 'Playing:' string and the title. Even
# if the title contains spaces it's still one parameter and it's safe if it
# contains `rm -rf /`.
#
# Examples:
# ExecCommand1        = "cp %f /mnt/usb_drive"
ExecCommand3 = "/home/frankie/now_playing %i"
ExecCommand2 = "/home/frankie/lyrics --artist %r --title %t"

# Display the cursor in the line with the selected file. This can be usefu with
# a braille display.
# UseCursorSelection    = yes

# Set the terminal title when running under xterm.
SetXtermTitle        = yes

# Display full paths instead of just file names in the playlist.
PlaylistFullPaths    = no

# Poniższych opcji nie tłumaczyłem ze względu, że nie chcę tego robić dosłownie nie mając
# pojęcia jak działa dana funkcja. Jeśli czujesz się na siłąch, możesz dostarczyć mi tłumaczenie
# które na pewno wkleje zamiast poniższych angielskich zdań.

# Number of channles (1 or 2)
#ModPlug_Channels = 2
# Bits per sample (8,16,32). 32 Bits seems ot be buggy…
#ModPlug_Bits = 16
# Sampling rate (11025, 22050, 44100, 48000)
#ModPlug_Frequency = 44100
# Reverb level 0(quiet)-100(loud)
#ModPlug_ReverbDepth = 0
# Reverb delay in ms, usually 40-200ms
#ModPlug_ReverbDelay = 0
# Bass level 0(quiet)-100(loud)
#ModPlug_BassAmount = 0
# Bass cutoff in Hz (10-100)
#ModPlug_BassRange = 10
# Surround level 0(quiet)-100(heavy)
#ModPlug_SurroundDepth = 0
# Surround delay in ms, usually 5-40ms
#ModPlug_SurroundDelay = 0
# Number of times to loop. Zero prevents looping. -1 loops forever.
#ModPlug_LoopCount = 0

Файлът може спокойно да бъде използван от всеки,като само му се направят необходимите корекции относно пътищата за директорията по подразбиране и настройките за канала,който да се управлява и през който върви аудиото.Разгледайте файла,всичко е описано подробно,с коментари кое за какво е.

Инсталация на теми

Инсталацията на теми в MOC е елементарна и се състои в набавянето на теми от интернет,и поставянето им в работната директория на програмата , в папка с име themes - ~/.moc/themes.За да може избраната тема да се зарежда по дефолт при всяко стартиране на прохрамата ,темата се описва в config файла,чрез името й.Само ще спомена ,че непосредствено след инсталацията на програмата на разположение на потребителя има налични няколко теми,които могат да се видят и пробват чрез T.С една „custom“ тема визията на MOC изглежда например така:

Интересни неща като скриптове , пачове и теми за програмата може да се намери на този адрес .
Естествено за допълнителна информация и помощ ,приложението си има и Форум .