Ի՞նչ առաջարկություններ կան կայքի և ֆորումի զարգացման վերաբերյալ

Ասք BSD֊ում CARP֊ով ծանրաբեռնուածութեան հաւասարակշռող կարգաւորելու մասին

CARP֊ի մասին CARP-ը, նոյն ինքը Common Address Redundancy Protocol-ը, ցանցային արձանագրութիւն է, որը թոյլ է տալիս մի քանի հանգոյց նոյն ցանցում ունենան նոյն ԱյՓին :) CARP-ի գլխաւոր նպատակն է ֆեյլօվերների ժամանակ ապահովել կապը։ ճիշտ կարգաւորումով այն կարող է օգտագործուել որպէս ծանրաբեռնուածութեան հաւասարակշռող (Load Balancer)։ CARP-ը ստեղծուել OpenBSD-ի կողմից է որպէս Ցիսկոյի VRRP-ի ու HSRP-ի ազատ եւ անպատենտ տարբերակ :) Ինչու (Free|Open)BSD֊ի վրայ։ ահաւոր յարմար է, հեշտ, տեղակայումը տեւում է չորս րոպէ ։պ Օկ, հիմա կարգաւորենք։ Այս փորձարկման համար սարքել եմ երկու վիրտուալ մեքենայ, hosta եւ hostb, որտեղ, hosta-ն լինելու է գլխաւոր մեքենան, իսկ hostb-ն լինելու է backup-ը։ օքեյ, հիմա։ CARP-ի համար պէտք են հետեւեալ բաները՝ Մեքենաներ, ամէն մէկն ունենում է իր իրական ԱյՓին (Real IP), եւ բոլորը միասին սպասարկում են Shared IP որն ունի իր Virtual Host ID :)) օկ, նախ կարգաւորենք իրական այփիները, եւ տեսնենք որ մէկը միւսին հասանելի է։ hosta.carp: ifconfig em1 inet 192.168.69.10/24 ապա hostb.carp: ifconfig em1 inet 192.168.69.20/24 եւ իրար պինգենք (։ ահա, հիմա երկուսն էլ իրար հասանելի են։ հիմա արդէն կարգաւորենք VHID-ն եւ shared IP-ն (։ hosta.carp: ifconfig em1 inet vhid advskew 100 pass mypassword alias 192.168.69.50/24 hostb.carp: ifconfig em1 inet vhid advskew 200 pass mypassword alias 192.168.69.50/24 advskew-ն որն աւելի ցածր է, դա աւելի բարձր priority ունի։ ես չուզեցի հրաման աշխատեցնել, նախընտրում եմ սկրիպտ գրել, ահա եւ դա։ յուշում, չմոռանալ միացնել միջուկի մոդուլը՝ kldload carp ահա եւ երկու մեքենաները, ոնց տեսնում էք, մէկը master իսկ միւսը backup :) լաւ, հիմա արդէն փորձարկում անենք։ դրա համար ես կը քաշեմ երկուսի վրայ էլ վեբ սերվեր, ապա ամէն մէկի մէջ գրենք թէ ինքը ով է ։) հիմա, մաաաարդ ես, եթէ HostA-ին ինչ որ բան լինի, (էս դէպքում ես Reboot արեցի) ապա HostB-ն է արդէն պատասխանում :) լաւ, հիմա միքիչ աւելի հետաքրքիր բան։ շատ ժամանակ ուզում ենք մեր միջավայրը փոխել, ասենք Dev վերսիան release անել, բայց երբէք downtime չենք ուզում։ հիմա ունեմ HostDev, որը ունի Dev վերսիան, հիմա դա պէտք է Release անել։ նախ իհարկէ դա կարգաւորում ենք CARP-ով (իհարկէ իր իրական այփին կարգաւորելուց յետոյ)։ ifconfig em1 inet 192.168.69.32/24 ifconfig em1 inet vhid 1 advskew 99 pass mypassword alias 192.168.69.50/25 ապա իրեն դնում ենք MASTER ifconfig em1 vhid 1 state master ու ֆսյո (։ ասանկ բաներ :) աղբիւր՝ Ասք BSD֊ում CARP֊ով ծանրաբեռնուածութեան հաւասարակշռող կարգաւորելու մասին | Ազատութիւն Ամենեցուն

Ասք Բաշով Սոքեթ Ծրագրաւորման Մասին

Արդէն քանի ամիս է Սերթում եմ աշխատում, իրականում կէս տարի է արդէն, երեւի աւելի, ինչեւէ։ չնայած, ինչքանով որ հասկացայ, Հայաստանում ադմինների մեծ մասը պատրաստի թուլեր են օգտագործում, շատ քչերն են ձեռով սկրիպտներ գրում, անգամ ծրագրեր, բայց դէ նորմալ ա, ինչ որ լուրջ պահանջ էլ չկայ, բացի եթէ մեծ ընկերութեան մէջ ես աշխատում։ բայց մեծ ընկերութիւններում էլ եթէ ծրագիր գրել պէտք լինի ադմինի համար, հաւանաբար ծրագրաւորող կը լինի։ Սերթում տենց չի, չգիտեմ լաւ է թէ չէ, բայց միայն ես եմ տեխնիկական գործեր անում (իրար վրայ երկու հոգի ենք թիմում), ու ամէն ինչ պէտք է ես անեմ։ չգիտեմ ոնց եղաւ, բայց ինձ պէտք էր, որ socket ծրագրաւորում անեմ, ինչ որ ռաութերների հետ շփուելու, ու հասկանալու թէ ոնց ա վիճակը Հայաստանում (վերջում պարզուեց որ վատ ա)։ Ադմիններին հենց ասում ես սոքեթ ծրագրաւորում, առաջին բանը որ ասում ենք դա netcat-ն է, որն ի դէպ շատ լաւն է։ մարդիկ էլ ովքեր ծրագրաւորում գիտեն, նախընտրում են իհարկէ արագի մէջ փայթնի սոքեթով անել։ շատ քիչ մարդիկ սիրում են նաեւ էկզոտիկ լեզուներով անել (օրինակ ոնց կ'անէինք ես ու նորայրը)։ Ինչեւէ, netcat-ը ինձ հերիքում էր, Պասկալն էլ չասեմ։ բայց ես մի քանի սարք ունեմ, որոնց վրայ չկայ netcat, իսկ ես ուզում էի ծրագիրս ամէն տեղ աշխատի, բա ի՞նչ անեմ։ (* չնայած ամէն տեղ voc ունեմ, բայց աւաղ, այդքան լաւ չեմ կարողանում դեռ ծրագրաւորել Օբերոնով, որ մի անգամից պէտք եղածն անեմ *) օրերն անցան, խնդիրը մնաց։ Մի օր աւտօբուսում նստած կպել էի սերւերիս ու մանուալներ էի կարդում, ինչ որ բաշ սկրիպտ էի գրում, որ խնդիր կար, մէկ էլ սենց հաւէս բան տեսայ՝ առաջին պահին ուրախացայ, երկրորդ պահին, ըստ սովորութեան, որոշեցի սորսերը կարդալ ։Ճ ահա եւ գտայ՝ redir.c հաւէ՜ս, ես ամէն տեղ բաշ ունեմ, նոյնիսկ այնտեղ որ չպէտք է լինի, քանի որ ash-ով է գալիս ։Ճ լաւ, հիմա փորձենք, պայմանս շատ պարզ էր, մի տեղից պէտք է լսեմ, միւս տեղից պէտք է բաշով ուղարկեմ եւ ստանամ (։ ահա եւ վիդեոն՝ ու տենց (։ աղբիւրը՝ աստեղէն

FreeNAS – Բաց կոդով ցանցային պահոց (տեղադրում)

FreeNAS-ը հանդիսանում է բաց կոդով ինձ հանդիպած ցանցային պահոցներից ամենաստաբիլը։ FreeNAS-ը կարելի է տեղադրել կոշտ սկավառակի, կամ այլ հիշողության սարքերի վրա, նույնիսկ խորհուրդ է տրվում տեղադրել USB ֆլեշի վրա, ընդ որում FreeNAS-ը զբաղեցնելու է տվյալ կրիչի ամբողջ ծավալը, կարևոր չի կտեղադրեք 4GB USB ֆլեշ թե 500GB կոշտ սկավառակ։ Այնպես որ ֆինանսապես նպատակահարմար է օգտագործել USB ֆլեշ։ Գրառմանս ընթացքում կնկարագրեմ FreeNAS-ի տեղադրման գործընթացը։ Գրառումս անելու պահին վերջին տարբերակը հանդիսացել է 9.3-ը։Եւ այսպես առաջին իսկ քայլով մտնում են բեռնումների էջը և քաշում ենք վերջին ստաբիլ տարբերակը և քաշած *.iso ֆայլը գրում ենք CD-ի վրա։Բեռնվելով CD-ից կբացվի հետևյալ գործողությունների ցանկը՝ Որից հետո կտեսնենք՝ Ընտրելով առաջին տարբերակը կհաստատենք FreeNAS-ի տեղադրումը մեր համակարգի վրա։ Այնուհետև ընտրում ենք կրիչը որի վրա պետք է տեղադրվի FreeNAS-ը Պատասխանում ենք [Yes] որով համաձայնվում ենք մաքրել տվյալները տվյալ կրիչի վրայից։ ..և շնորհավորում եմ, սկզբնական տեղադրումը ավարտված է Սեղմելով [OK] համակարգիչը (սերվերը) կվերսկսի (ռեստարտ)։ Սկզնբաղբյուր

JavaScript լեզու, զանգվածներ ֊ մաս #2

https://www.youtube.com/watch?v=9dc22nu9reE JavaScript լեզվի զանգվածները և դրանց հետ աշխատանքը։ .map .filter .reduce .push .unshift Դասերը շարունակական են լինելու, այնպես որ կարող եք բաժանորդագրվել YouTube֊ի ալիքին և ծանուցում կստանաք նոր տեսանյութերի մասին։

JavaScript լեզու, Ֆունկցիաներ ֊ մաս #1

https://www.youtube.com/watch?v=1TvAs58RWgQ JavaScript լեզվի դասընթաց, փոփոխականներ, կոնստանտներ, ֆունկցիաներ, callback ֆունկցիա, ռեկուրսիա: Դասերը շարունակական են լինելու, այնպես որ կարող եք բաժանորդագրվել YouTube֊ի ալիքին և ծանուցում կստանաք նոր տեսանյութերի մասին։

Երեք պատահական խնդիր

Արտահայտության հապավում

Խնդիրը։ Տրված է ինչ-որ արտահայտություն, օրինակ, «Միացյալ ազգերի կազմակերպություն» և պահանջվում է սրանից ստանալ «ՄԱԿ» հապավումը։ Դպրոցականը կամ ուսանողը, հավանաբար, առաջին լուծումը կտանի այսպես. տողը դարձնել ցուցակ, հետո անցնել տողի վրայով ու հավաքել բոլոր այն տառերը, որոնց նախորդում են տառ չհանդիսացող այլ սիմվոլներ։ Հետո՝ հավաքած տառերը դարձնել մեծատառ ու միավորել մեկ տողի մեջ։ Տողից նիշերի ցուցակ ստացվում է coerce ֆունկցիայով.

(coerce "abcd" 'list)    ; => (#\a #\b #\c #\d)

Նույն coerce ֆունկցիայով նիշերի ցուցակից ստացվում է տող.

(coerce '(#\a #\b #\c #\d) 'string)    ; => "abcd"

Նիշերի ցուցակից բառերի առաջին տառերն ընտրող ֆունկցիան կարելի է գրել ռեկուրսիվ եղանակով։

(defun select-first-letters (sl)
    (if (endp sl)
        '()
        (if (and (not (alpha-char-p (car sl))) (alpha-char-p (cadr sl)))
            (cons (cadr sl) (select-first-letters (cddr sl)))
            (select-first-letters (cdr sl)))))

Դե իսկ հապավում կառուցող ֆունկցիան արդեն կարելի է կառուցել այսպես․

(defun acronym-of (s)
    (string-upcase (coerce (select-first-letters (coerce s 'list)) 'string)))

Բայց այս ֆունկցիան ճիշտ չի աշխատելու, որովհետև տողի առաջին տառը, որը պետք է լինի հապավման առաջին տառը, չի բավարարում select-first-letters ֆունկցիայի 4֊րդ տողում գրված պայմանին։ Այդ թերությունը շտկելու համար պետք է պարզապես տողը նիշերի ցուցակ դարձնելուց հետո դրա սկզբից կցել մի որևէ նիշ։ Այսինքն acronym-of ֆունկցիան սահմանել հետևյալ կերպ․

(defun acronym-of (s)
    (string-upcase (coerce (select-first-letters (cons #\Space (coerce s 'list)) 'string))))

Սրա հետևանքով select-first-letters ֆունկցիայի երկրերդ տողում գրված պայմանը կձևափոխվի․

(defun select-first-letters (sl)
    (if (or (endp sl) (endp (cdr sl)))
        '()
        (if (and (not (alpha-char-p (car sl))) (alpha-char-p (cadr sl)))
            (cons (cadr sl) (select-first-letters (cddr sl)))
            (select-first-letters (cdr sl)))))

* * *

Փորձառու ծրագրավորողն այսպիսի բան, իհարկե, չի գրի։ Նա միանգամից կնկատի, որ արտահայտության հապավումը կառուցելու համար բավական է մեծատառ դարձնել բառերի միայն առաջին տառերը, իսկ մնացածները թողնել փոքրատառ։ Հետո դեն գցել ամեն ինչ՝ բացի մեծատառերից։

(defun acronym (text)
    (remove-if-not #'upper-case-p (string-capitalize text)))

Սա Արդեն ֆունկցիոնալ լուծում է։ string-capitalize ֆունկցիան վերադարձնում է տողը՝ որում բառերի միայն առաջին տառերն են մեծատառ։ remove-if-not ֆունկցիան ֆիլտրող ֆունկցիա է. այն իր երկրորդ արգումենտում տրված հաջորդականությունից դեն է գցում իր առաջին արգումենտում տրված պրեդիկատին չբավարարող տարրերը։

* * *

Տիպիկ C-ական լուծումն էլ այսպիսին կլինի.

void acronym(const char *text, char *acr)
{
    *acr++ = toupper(*text++);
    while( *text != '\0' ) {
        if( isalpha(*text) && !isalpha(*(text-1)) )
            *acr++ = toupper(*text);
        ++text;
    }
    *acr = '\0';
}

 

Բառերի հեմինգյան հեռավորություն

Խնդիրը։ Երկու նույն երկորությունն ունեցող բառերի հեմինգյան հեռավորություն է կոչվում դրանց նույն դիրքերում տարբերվող տառերի քանակը։ Օրինակ, abc և abc բառերի հեմինգյան հեռավորությունը զրո է, իսկ abc և aec բառերի հեմինգյան հեռավորությունը մեկ է, և այլն։ Իտերատիվ լուծումը կարող է լինել loop մակրոսի օգտագործմամբ։ Երկու զուգահեռ հաշվիչներ անցնում են տողերի վրայով և համեմատում են նույն դիրքում գտնվող տառերը։ Եթե դրանք տարբեր են, ապա հաշվարկման արդյունքին գումարվում է մեկ։

(defun hamming-distance (so si)
    (loop for x across so
          for y across si
          when (char-not-equal x y)
          sum 1))

Ֆունկցիոնալ լուծման առաջին մոտարկումը կարող է լինել այսպես. map ֆունկցիայով տրված բառերից կառուցվում է մի ցուցակ, որի i-րդ դիրքում գրված է 0` եթե բառերի i-րդ դիրքերի տառերը հավասար են, և 1՝ հակառակ դեպքում։ Այնուհետև apply ֆունկցիայով + գործողությունը կիրառվում է այդ ցուցակի նկատմամբ՝ վերադարձնելով տարբերվող տառերի քանակը։

(defun hamming-distance (so si)
    (apply #'+ (map 'list #'(lambda (x y) (if (char-equal x y) 0 1))
           so si)))

Վերջնական ֆունկցիոնալ լուծումն ավելի լավն է. նույն map ֆունկցիայով ստեղծվում է char-not-equal ֆունկցիայի արդյունքների ցուցակ՝ կազմված t-երից և nil-երից։ Իսկ հետո count ֆունցիայով հաշվվում է t-երի քանակը, որն էլ հենց տրված բառերի հեմինգյան հեռավորությունն է։

(defun hamming-distance (so si)
    (count t (map 'list #'char-not-equal so si)))

* * *

C-ական իրականացումը պարզապես հաշվում է բառերի նույն դիրքում տարբերվող տառերի քանակը.

unsigned int hamming_distance(const char *so, const char *si)
{
    unsigned int dist = 0;
    while( *so != '\0' && *si != '\0' )
        if( *so++ != *si++ )
            ++dist;
            
    return dist;
}

 

Ենթացուցակի ստուգում

Խնդիրը։ Ստուգել, թե արդյոք s₀ ցուցակը s₁ ցուցակի ենթացուցակն է։ Օրինակ, [3, 4, 5] ցուցակը [1, 2, 3, 4, 5, 6] ցուցակի ենթացուցակ է։ Միանգամից «ֆունկցիոնալ» լուծումը. s₀-ն s₁-ի ենթացուցակ է, եթե կա՛մ s₀-ն համընկնում է s₁-ի սկիզբի հետ՝ նրա պրեֆիքսն է, կա՛մ s₀-ն s₁-ի պոչի ենթացուցակն է։ Common Lisp լեզվով գրառումը.

(defun is-sublist (so si)
    (or (is-prefix so si)
        (is-sublist so (cdr si))))

is-prefix ֆունկցիայի իրականացումն էլ շատ հետաքրքիր է.

(defun is-prefix (so si)
    (not (member nil (mapcar #'eq so si))))

mapcar ֆունկցիայով կառուցվում է երկու ցուցակների համապատասխան տարրերի՝ իրար հավասար լինելու (կամ չլինելու) ցուցակը։ member ֆունկցիայով այդ ցուցակում որոնվում է որևէ nil արժեք, իսկ not ֆունկցիայով էլ պահանջվում է, որ nil չլինի։ C լեզվով պրեֆիքսի և ենթացուցակի ստուգման ֆունկցիաները կունենան հետևյալ ոչ պակաս հետաքրքիր տեսքը. Եթե, օրինակ, ցուցակի հանգույցը սահմանված է այսպես.

struct node {
    char data;
    struct node *next; 
};

ապա s ցուցակի՝ l ցուցակի պրեֆիքս լինելը կաստուգվի այսպես.

bool is_prefix(const struct node *s, const struct node *l)
{
    while( NULL != s && NULL != l && s->data == l->data ) {
        s = s->next;
        l = l->next;
    }
    
    return NULL == s;
}

իսկ s ցուցակի՝ l ցուցակի ենթացուցակ լինելն էլ այսպես.

bool is_sublist(const struct node *s, const struct node *l)
{
    if( NULL == s )
        return true;

    if( NULL == l )
        return false;

    return is_prefix(s, l) || is_sublist(s, l->next);
}