Jekyll2026-10-25T11:19:16+00:00https://bit0.ro/index.xmlbitsbitsovidiuVideo test2026-09-10T18:05:37+00:002026-09-10T18:05:37+00:00https://bit0.ro/2026/09/video-testLocal video serving check. The file lives in static/media/ (symlinked, git-ignored — 416 MB is too big for git).

Source was a QuickTime .mov (H.264 + AAC). ffmpeg remuxed it to MP4 with +faststart (moov atom first), so playback and seeking work before the whole ~400 MB file has downloaded. Audio and video streams were copied, not re-encoded — zero quality loss.

]]>ovidiutup build system and library manufacturing2019-06-22T19:35:00+00:002019-06-22T19:35:00+00:00https://bit0.ro/2019/06/tup-build-system-and-library-manufacturing
Basic idea is to have a workflow where feedback is instantanous by the build system, have warning set to maximum, eventually perform lint checks and dynamic memory allocation checks with valgrind.

These features may already exist in various commercial tools. This is not about that and instead this serves as a my go-to memo to know for future reference.

1) tup
Tup is a build system. Eeach folder can have it's own tupfile. tuplfile(s) can have  global (or specific) tuprules, macros can be defined in tuprules, its an alternative to make, not better but different.
Note:
On linux it uses FUSE to monitor changes in the filesystem Does not work with windows well on this part.
You start the monitor with tup monitor -a and every update, change it will run to the foreground (can also be demonised)
Before wiritng the files you do a tup init in your folder. There it will create a hidden directory similar to the .git directory. There it will store the database that will keep track of dependences, files,and relationships.

Layout of library project:

├── Tuprules.tup
├── include                 -here is where function prototypes  where #includes
│   ├── myhash.h        are used in the src directory (src depends on include)
│   └── mylib.h
├── lib                         -the lib directory is where the archive file is done before the linking
│   ├── Makefile         -stage the lib directory is where your library consisting of
│   ├── Tupfile             a number of obj files are stred in a single archive file
│   └── mylib.a            (lib depends on obj)
├── obj                        -the object file directory is where files are output based
│   ├── Tupfile            on the compilation phase. Files which compile should end up here to
│   ├── myhash.o        later be used for the lib folder (obj depends on src)
│   ├── prime.o
│   └── t_hash.o
├── src                         -source files excluding headers (depends on include)
│   ├── myhash.c
│   └── prime.c
├── test                       -test directory to make sure everything works as it should.
│   ├── Makefile         This should serve as a place to test all functionality of the library
│   ├── Tupfile            and it's functions. Crash  tests, should be done here.
│   ├── t_hash             (depends on lib, obj - partially)
│   ├── t_hash.c
└── testdata

Basic syntax for a tupfile
Rule set situated in the top directory

#Variables start with & - keeping directories here

&libdir  = include/
&objdir  = obj/

#CFLAGS  are appended with += 

CFLAGS += -Weverything
CFLAGS += -g
CFLAGS += -Og
CFLAGS += -ggdb3

#!macros for use in other Tupfiles - instead of typing the command to archive to compile, etc we can set up a macro

!cc = |> clang $(CFLAGS) -I&(libdir) -c %f -o &(objdir)/%o |> %B.o
!ar = |> ar crs %o %f |>



a) lib/Tupfile will include the rules on line 1
include_rules
: ../obj/*.o |> !ar |> mylib.a

Format of the last line is like this: (copy paste from man page)

  : [foreach] [inputs] [ | order-only inputs] |> command |> [outputs] [ | extra outputs] [] [{bin}]
              The :-rules are the primary means of creating commands, and are denoted by the fact that the ':' character appears in the first column of the Tupfile. The syntax is  supposed to look somewhat like a pipeline, in that the input files on the left go into the command in the middle, and the output files come out on the right.
PS: Globbing does not match directories

b) second created Tupfile was in obj/Tupfile

include_rules
: foreach ../src/*.c |> !cc |>


The !cc macro specifies the output in the macro, since it is the same for all C files. However, the library can be named anything, so we specify the output in the actual :-rule that uses the !ar macro

c) third file is in tests/Tupfile

include_rules

CXFLAGS += -lc
CXFLAGS += -lm
CXFLAGS += ../lib/mylib.a

: *.c |> !cc |> ../obj/t_hash.o
:  ../obj/t_hash.o | ../lib/mylib.a  |> clang  %f  $(CXFLAGS) -o t_hash |> %B

This was more time consuming but the firs rule is to have the t_hash.o file which will become the test has program then have that and the library .a be the input to clang The pipe is "order-only inputs

                      These are also used as inputs for the command, but will not appear in any of the %-flags. They are separated from regular inputs by use of the '|' character. In effect, these can be used to specify additional inputs to a command that shouldn't appear on the command line. "

By the way flags:
%f The filename from the "inputs" section. This includes the path and extension.
%o     The name of the output file(s)
%B     Like %b, but strips the extension.

Sample output of monitor


The end strucutre looks like this:


2) lldb - more to the point and in a hurry
* breakpoints can't be set on line number as far as i can tell says it's pending
In either case use br set -n function name or br set -r regex for function name
* n for next , s for step
* br l - list breakpoints
* br del - delete them
* me read
-fX for hex uppercase -c25 25 lines I think -s8 - for bytes 8 bytes --force if it says it does not display more than 1024 bytes of memory

* bt to view stack
* frame variables to view what varaibles were assigned and their entry points

 (lldb) 
Process 27249 stopped
* thread #1, name = 't_hash', stop reason = step over
    frame #0: 0x00005555555554bc t_hash`h_search(hTable=0x0000555555559260, key="400") at myhash.c:134:30
   131 else {
   132 // looking for the key inside the next element of the linked list
   133 char* keyAtNextValue = hTable->h_items[resultHash]->h_next->h_key;
-> 134 while( nextValue->h_next != NULL)  {
   135 fprintf(stderr, "Found a collision, traversing Linked list at address %p, key is: %s",
   136 nextValue, nextValue);
   137 nextValue += 1;
(lldb) print nextValue
(HashNode *) $0 = 0x00005555555592e0
(lldb) br l 
Current breakpoints:
1: name = 'h_search', locations = 1, resolved = 1, hit count = 1
  1.1: where = t_hash`h_search + 17 at myhash.c:97:39, address = 0x0000555555555401, resolved, hit count = 1 
(lldb) print *nextValue
(HashNode) $1 = {
  h_next = 0x0000000000000000
  h_key = 0x0000555555559300 "400"
  h_value = 0x0000555555559320 "101"
}
(lldb) print *nextValue->h_next
error: Couldn't apply expression side effects : Couldn't dematerialize a result variable: couldn't read its memory
(lldb) print nextValue->h_next
(HashNode *) $3 = 0x0000000000000000
(lldb) print *nextValue->h_key
(char) $4 = '4'
(lldb) print nextValue->h_key
(char *) $5 = 0x0000555555559300 "400"
(lldb) bt
* thread #1, name = 't_hash', stop reason = step over
  * frame #0: 0x00005555555554bc t_hash`h_search(hTable=0x0000555555559260, key="400") at myhash.c:134:30
    frame #1: 0x0000555555555217 t_hash`main at t_hash.c:14:27
    frame #2: 0x00007ffff7dd7ee3 libc.so.6`__libc_start_main + 243
    frame #3: 0x00005555555550fe t_hash`_start + 46

 (lldb) me read 0x00005555555592e0 -fX -c25 -s8 --force
0x5555555592e0: 0x0000000000000000
0x5555555592e8: 0x0000555555559300 
0x5555555592f0: 0x0000555555559320
0x5555555592f8: 0x0000000000000021
0x555555559300: 0x0000000000303034
0x555555559308: 0x0000000000000000
0x555555559310: 0x0000000000000000
0x555555559318: 0x0000000000000021
0x555555559320: 0x0000000000313031
0x555555559328: 0x0000000000000000
0x555555559330: 0x0000000000000000
0x555555559338: 0x0000000000000021
0x555555559340: 0x00005555555592E0
0x555555559348: 0x0000555555559360
0x555555559350: 0x0000555555559380
0x555555559358: 0x0000000000000021
0x555555559360: 0x0000000000303034
0x555555559368: 0x0000000000000000
0x555555559370: 0x0000000000000000
0x555555559378: 0x0000000000000021
0x555555559380: 0x0000000000313031
0x555555559388: 0x0000000000000000
0x555555559390: 0x0000000000000000
0x555555559398: 0x0000000000020C71
0x5555555593a0: 0x0000000000000000
(lldb) me read 0x00005555555592e0 -c256
0x5555555592e0: 00 00 00 00 00 00 00 00 00 93 55 55 55 55 00 00  ..........UUUU..
0x5555555592f0: 20 93 55 55 55 55 00 00 21 00 00 00 00 00 00 00   .UUUU..!.......
0x555555559300: 34 30 30 00 00 00 00 00 00 00 00 00 00 00 00 00  400.............
0x555555559310: 00 00 00 00 00 00 00 00 21 00 00 00 00 00 00 00  ........!.......
0x555555559320: 31 30 31 00 00 00 00 00 00 00 00 00 00 00 00 00  101.............
0x555555559330: 00 00 00 00 00 00 00 00 21 00 00 00 00 00 00 00  ........!.......
0x555555559340: e0 92 55 55 55 55 00 00 60 93 55 55 55 55 00 00  ..UUUU..`.UUUU..
0x555555559350: 80 93 55 55 55 55 00 00 21 00 00 00 00 00 00 00  ..UUUU..!.......
0x555555559360: 34 30 30 00 00 00 00 00 00 00 00 00 00 00 00 00  400.............
0x555555559370: 00 00 00 00 00 00 00 00 21 00 00 00 00 00 00 00  ........!.......
0x555555559380: 31 30 31 00 00 00 00 00 00 00 00 00 00 00 00 00  101.............
0x555555559390: 00 00 00 00 00 00 00 00 71 0c 02 00 00 00 00 00  ........q.......
0x5555555593a0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x5555555593b0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x5555555593c0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0x5555555593d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
(lldb) 
---
lldb) frame variable
(HashTable *) hTable = 0x0000555555559260
(char *) key = 0x0000555555556004 "400"
(size_t) resultHash = 5
(HashNode *) nextValue = 0x00005555555592e0
(char *) keyStrAtIndex =

(char *) keyAtNextValue =

(lldb) fr v
(HashTable *) hTable = 0x0000555555559260
(char *) key = 0x0000555555556004 "400"
(size_t) resultHash = 5
(HashNode *) nextValue = 0x00005555555592e0
(char *) keyStrAtIndex =

(char *) keyAtNextValue =

]]>ovidiuPython Classes2015-05-25T10:18:00+00:002015-05-25T10:18:00+00:00https://bit0.ro/2015/05/python-classes
Class: a blue print for an instance
Instance: a constructed object of the class
Type: indicates the class the instance belongs to
Attribute: any object value : object.attribute
Method: a "callable attribute" defined in the class



]]>ovidiuFlask pe Raspberry cu Postgres, nginx si uwsgi2015-03-29T20:29:00+00:002015-03-29T20:29:00+00:00https://bit0.ro/2015/03/flask-pe-raspberry-cu-postgres-nginx-si-uwsgi Raspberry Arch Linux pe ARM. Install guide here

Se presupune ca sistemul e conectat la internet.

pacman -S nginx python2-virtualenv python-virtualenv uwsgi-plugin-python,uwsgi-plugin-python2 python2-setuptools python2-pip posgtresql bash-completion gcc pithon-pip vim htop atpo sudo nload minicom links tcpdump git tmux ntpd zsh

Comanda de mai sus va instala mai multe pachete decat este necesar dar pot folosi în anumite situații de troubleshooting sau compilarea de pachete.

Dupa instalarea postgres este necesara logarea cu userul postgres apoi

initdb --locale en_US.UTF-8 -E UTF8 -D '/var/lib/postgres/data'

Si crearea unui user / rol

[postgres]$ createuser --interactive

In nginx.conf din /etc/nginx putem comenta blocul care defineste serverul pentru ca vom declara serverul in alte fisiere .conf pentru un management mai bun al domeniilor virtuale.

Astfel vom crea o structura a folderelor similara cu ce a apache-ului unde pentru site-urile inacitve exista sites-available si sites-enabled care va contine numai simlink-uri din sites-available. Pentru asta trebuie, pe langa comentarea blocului de server din nginx.conf, adaugam si

http {
   include       mime.types;
   include sites-enabled/*;
   default_type  application/octet-stream;

respectiva optiune pentru ca nginx sa stie de unde va incarca fisierele de config pentru site-uri.

Tree-ul va arata in felul urmator dupa setup.

 |-- nginx.conf
|-- sites-available
|   `-- demoapp_nginx.conf
|-- sites-enabled
|   `-- demoapp_nginx.conf -> ../sites-available/demoapp_nginx.conf
|-- uwsgi_params

Definirea serverului din demoapp_nginx.conf

server {
   listen      80;
   server_name localhost;
   charset     utf-8;
   client_max_body_size 75M;
   location / { try_files $uri @yourapplication; }
   location @yourapplication {
       include uwsgi_params;
       uwsgi_pass unix:/var/www/demoapp/demoapp_uwsgi.sock;
   }
}

In mare descrie pe ce port asculta, unde sa gaseasca fisierele si socketul la care se conecteaza cu uwsgi pentru a crea interfata cu python dat fiind ca nginx este doar un webserver si nu serverste decat continut static.

Crearea unui serviciu pentru arch pentru systemd e ciudata dar nginx documentează asta pe sit-ul lor. Vezi aici. Il salvezi in /usr/lib/systemd/system/nginx.service .După asta trebuie activat cu comanda systemctl enable nginx.service. Ulterior se poate porni cu comanda systemd start nginx.

2.

Se face  in /var/www un folder demoapp
Tree-ul final va fi ceva in genul acesta

-- demoapp
   |-- demoapp_uwsgi.ini
   |-- demoapp_uwsgi.sock
   |-- hello.py
   `-- venv

Se da cd in demoapp si se incepe prin crearea containerului virtual care va contine flask, sqlalchemy, psycopg2 si alte trăznăi care fac o aplicație web. Librariile astea e bine sa le ai undeva unde nu va polua sistemul inutil. Pentru asta virtualenv s-a creat.

$virtualenv venv

sau

$virtualenv2.7 venv

diferența este data de care versiune de python vrei sa lucrezi 3.x sau 2.x

va crea un folder venv in folderul demoapp. Daca dam comanda

. venv/bin/activate

va trece din consola bash într-o noua consola virtuala care ne va permite instalarea de pachete python fara sa polueze sistemul.

Mediul este izolat. Astfel încât dacă dam comanda virtualenv2.7 și activam consola, când dam comanda python atunci va face referire la python2.7 nu la versiunea instalata pe sistem care este 3.4 atunci când se executa direct python.

Deci.pip install flask, psycopg, sqlalchemy.Se poate iesi cu comanda deactivate.

3.

Se face un fișier hello.py care va conține următorul cod: (se poate crea chiar dacă sunteți in shell-ul virtual)

 from flask import Flask
app = Flask(__name__)

 @app.route("/")
def hello():
   return "Hello World!"

 if __name__ == "__main__":
   app.run(host='0.0.0.0', port=8080)

se salvează fișierul și se pornește webserverul integrat

python hello.py sau python2.7 hello.py

apoi ne ducem la adresa pe portul 8080 si ar trebui sa raspunda.

4.

Acum ca avem nginx și aplicația web instalata trebuie sa facem sa comunice uwsgi cu cele doua.

Instalam global

pacman -S uwsgi-plugin-python
pacman -S uwsgi-plugin-python2

și definim demoapp_uwsgi.ini

[uwsgi]
#applications base folder
base = /var/www/demoapp

 #python module to import
app = hello
module = %(app)

 plugins = python2
home = %(base)/venv
pythonpath = %(base)

 #socket file location
socket = /var/www/demoapp/%n.sock

 #permission for the socket file
chmod-socket = 666
# the variable that holds a flask application inside the module imported
callable  = app

 #location of log file
logto = /var/log/uwsgi/%n.log

Se pornește cu comanda

uwsgi --plugin python2 --ini /var/www/demoapp/demoapp_uwsgi.ini

opțiunea plugin este doar daca aplicația web folosește python2.Toate bune si frumoase numai ca pornirea uwsgi asa e aiurea.

Când am instalat uwsgi in /etc/uwsgi un fisier emperor.ini. Mai trebuie sa creeam un folder vassals. Ideea este ca aplicația poate funcționa pe post de superserver care sa spawneze instante pentru cate aplicatii ai, pe langa asta putem porni la startup astfel încât sa avem comunicare cu aplicația si sa nu avem doar webserverul up.

Folderul vassals va conține un simlink catre fisierul ini care se afla in /var/www/demoapp.

systemctl start emperor.uwsgi va porni master-ul si slave-ul va porni dacă va exista un fisier de config in vassals.

 ]]>ovidiuVLAN-uri2015-03-29T09:37:00+00:002015-03-29T09:37:00+00:00https://bit0.ro/2015/03/vlan-uri Ar fi doua optiuni.

  1. SVI pe switch
  2. SVI pe linux.
Findca sw-ul nu este gbit  si raspberry la fel , ma lasa cu desktop-ul cu functia de router.
In sensul acesta trebuie sa facem in felul urmator:



  1. Activarea ip.forwarding care by default e off in arch si cel mai probabil in alte distro-uri
  2. Activarea profilelor de conectare daca nu vrem sa folosim script-uri custom
    1. avem profile exemplu in /etc/netctl/examples
    2. copiem ce ne interseaza (ethernet-static, vlan-static, si daca avem PPPoE avem si profil pentru el dar prefer sa folosesc direct ppp
    3. sintaxa e foarte stricta si orice greseala duce la neridicarea interfetei si documentatia cam lasa de dorit
      1. exemplu: dupa ridicarea interfetei vreau sa am doua rute, nu doar una, adaugate.Merge cu IPCustom dar nu cu Routes
    4. dupa ce am creat fisierele trebuie activate cu netctl enable numeprofil (profilele le-am denumit dupa numele interfetei)
    5. dupa activare la boot pot fi pornite si let's hope there's no errors reported.
  3. Actualizarea iptables cu o regula POSTROUTING in tabla NAT si asigurarea ca chain-ul de forwarding nu are politica de drop sau daca are atunci sa se adauge exceptie
Acum am 3 vlan-uri:
34 - Management 10.34.0.1/29
25 - Raspberry 10.25.0.1/29
86 - Sistem 10.86.0.1/29

Initial am creat interfete vlan pe sisteme si comunicau daca tineam porturile in trunk. Totusi sisteme care sunt in trunk sunt interesante pentru ca ar permite folosirea de vlan-uri pentru separerea serviciilor de pe acelasi sistem. Am 2 servere pe raspberry. Postgres si Nginx. Le putem da
de pe interfete tagate si am putea discrimina mai bine traficul pe switch. Ramane de incercat.

As fi vrut si un subnet separat pentru fiecare si un subnet in plus pentru Management-ul prin SSH.

Pe switch am doua host-uri conectate dar as vrea un svi penru management. Sa ridic un SVI pentru interfete care nu sunt UP nu merge. Pe loopback nu pot aplica un SVI si vlan state active nu merge ca SVI-ul tot are nevoie de o interfata pe care sa fie traffic. Nu a mers nici cu no keepalive pe o interfata fast.

Asa ca raman cu optiunea de a folosi loopback care e mereu up si pot accesa echipamentul cat timp am ruta la el.

Pana la urma am lasat interfata spre sistem trunk si am pus vlan 86 ca nativ. Am vrut  o interfata netagata spre switch.
!
interface FastEthernet0/24
switchport trunk encapsulation dot1q
switchport trunk native vlan 86
switchport trunk allowed vlan 25,34
switchport mode trunk
!

Profiul netctl pentru interfata spre swtich. Foarte important e SkipNoCarrier care nu va ridica interfata da ca nu e link si cand va fi link tot nu o va ridica.

cat /etc/netctl/enp4s2
Description='enp4s2-access 86'
Interface=enp4s2
Connection=ethernet
SkipNoCarrier=yes
IP=static
AutoWired=yes
Address=('10.86.0.2/29')
IPCustom=('route add 10.25.0.0/29 via 10.86.0.1' 'route add 10.34.0.0/29 via 10.86.0.1') 

ifconfig va arata interfata dupa netctl start
Pe interfata de pe raspberry. Traficul pleaca la fel. Untagged.

[root@pytest netctl]# cat eth0
Description='eth0'
Interface=eth0
Connection=ethernet
AutoWired=yes
SkipNoCarrier=yes
IP=static
Address=('10.25.0.2/29')
Gateway=('10.25.0.1')
DNS=('8.8.8.8 8.8.4.4')
Si pe swtich
!
interface Vlan25
description Raspberry
ip address 10.25.0.1 255.255.255.248
!
!
interface FastEthernet0/12
switchport access vlan 25
switchport mode access
!

Cu o ruta statica spre sistemul cu netul
!
interface Vlan30
description Calculator
ip address 10.86.0.1 255.255.255.248
!
ip route 0.0.0.0 0.0.0.0 10.86.0.2 ]]>ovidiuKeeping track of notes - notepad on steroids2015-02-21T14:21:00+00:002015-02-21T14:21:00+00:00https://bit0.ro/2015/02/keeping-track-of-notes-notepad-on-steroids
You may like Zimwiki .

It's a wiki based program that's bare bones, but has the basics: font format, headers, bullet lists, number lists, to do boxes.



Files are just text files stored in the hierarchy of the tree.

It can export to html. It has some LaTeX templates too.
And it has some decent plugins: spell check, math formula, etc.

You can have your tree saved to a Dropbox and just point Zim to that notebook so everything syncs. If you don't have the program on a computer, then you can just open the text file of what you want to edit and do it that way. 
 
You can also use - a git repo with bitbucket. Just do a git init on the note folder. 
Bitbucket has private repos and you get the added feature of a version control system. Neat.
 
PS - its a great program and it's one guy and a few volunteers. I donate when I can because I really rely on this program.


]]>ovidiuConnecting a switch to GNS32015-02-13T11:06:00+00:002015-02-13T11:06:00+00:00https://bit0.ro/2015/02/connecting-a-switch-to-gns3 VLANs
MAC Table overflow

Working setup:

1 x 3560 L3 Switch
Arch Linux x86_64
GNS 3 v. 1.2.3 w/c7200-adventerprisek9-mz.151-4.M4.image


You need to set the options in dynamips executable to allow normal users alterations to network interfaces

sudo setcap cap_net_raw,cap_net_admin+eip /usr/bin/dynamips

Otherwise you may receive "206-unable to create Linux raw or generic Ethernet" or something similar.
More info here

 - plug cable into the switch
- make sure you can reach the switch I have:
SW-A# sh int vlan 1
  Internet address is 192.168.4.42/24)
- on the NIC you can issue: "ip addr add 192.168.4.15/24 dev enp4s2" where enp4s2 is whatever NIC you have
- enable ssh and configure a user
mig@jenkins ~ % ssh x@192.168.4.42
Password: 

SW-A#

On R1:
- set the interface to "duplex full" otherwise you'll receive this on SW-A
: %CDP-4-DUPLEX_MISMATCH: duplex mismatch discovered on FastEthernet0/1 (not half duplex), with R1 FastEthernet0/0 (half duplex).

SW-A#sh cdp nei
Capability Codes: R - Router, T - Trans Bridge, B - Source Route Bridge
                  S - Switch, H - Host, I - IGMP, r - Repeater, P - Phone

Device ID        Local Intrfce     Holdtme    Capability  Platform  Port ID
R1               Fas 0/1           105            R       7206VXR   Fas 0/0

VLANs

Prepare interface on switch:

 interface FastEthernet0/1
 switchport trunk encapsulation dot1q
 switchport mode trunk

 DTP packets start arriving

Interface is now trunk so it does not show on this output

 SW-A#sh vlan br

VLAN Name                             Status    Ports
---- -------------------------------- --------- -------------------------------

1    default                          active    Fa0/2, Fa0/3, Fa0/4, Fa0/5

To see trunk interfaces:

SW-A#sh int trunk 

 Port        Mode             Encapsulation  Status        Native vlan
Fa0/1       on               802.1q         trunking      1

Configure a SVI

SW-A(config)#vlan 100
00:51:25: %LINK-5-CHANGED: Interface Vlan100, changed state to administratively down
00:51:26: %LINEPROTO-5-UPDOWN: Line protocol on Interface Vlan100, changed state to down
SW-A(config)#int vlan 100       
00:51:33: %LINK-3-UPDOWN: Interface Vlan100, changed state to up
00:51:34: %LINEPROTO-5-UPDOWN: Line protocol on Interface Vlan100, changed state to up
SW-A(config-if)#ip addr 10.1.1.1 255.255.255.240 


On the PC side:
- Create the VLAN device
ip link add link enp4s2 name enp4s2.100 type vlan id 100
- add an ip 
ip addr add 10.1.1.1/30 brd 10.1.1.3 dev enp4s2.100
- bring it up 
ip link set dev enp4s2.100 up

You can check the status by:

  ~ % ip -d link show enp4s2    
3: enp4s2: mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
    link/ether 00:22:15:63:cf:0d brd ff:ff:ff:ff:ff:ff promiscuity 1 

  ~ % ip -d link show enp4s2.100
5: enp4s2.100@enp4s2: mtu 1500 qdisc noqueue state LOWERLAYERDOWN mode DEFAULT group default 
    link/ether 00:22:15:63:cf:0d brd ff:ff:ff:ff:ff:ff promiscuity 0 

    vlan protocol 802.1Q id 100  

 A virtual network device called enp4s2.100 would be created, bound to VLAN ID 100 of the physical interface enp4s2
  • Inbound 802.1Q-encapsulated frames arriving on enp4s2 with a VLAN ID of 100 are detagged, then re-presented to the network stack as inbound frames arriving on enp4s2.100
  • Outbound frames sent to enp4s2.100 are tagged with a VLAN ID of 100, then passed to enp4s2 for transmission.


]]>ovidiuHaskell Introducere, Liste, uplu, functii, tipuri polimorfice, supraincarcare.2014-10-26T17:21:00+00:002014-10-26T17:21:00+00:00https://bit0.ro/2014/10/haskell-introducere-liste-uplu-functii-tipuri-polimorfice-supraincarcare Tipurile de baza:
·        Bool – valori logice
Contine valorile logice False si True.
·        Char – caractere
Contine toate caracterele disponibile de la tastatura precum ‘a’, ‘_’, ‘V’, precum si un numar de caractere de control precum ‘\n’, ‘\t’.
·        String – siruri de caractere
Acest tip contine toate secventele de caractectere, precum “abc”, “1+2=3” si sirul vid “”.
·        Int – numere intregi intre -231 si 231 -1
·        Integer – numere intregi cu precizie infinita
·        Float - single-precision floating-point numbers


Tipul lista:

·        Secventa(chiar si infinita) de elemente de acelasi tip:
§         [True, False, False] :: [Bool]
§         [‘a’,’b’,’c’,’d’] :: [Char]
§         [“unu”, “doi”, “trei”] :: String
·        [[]] este diferita de []
·        nu exista restrictii asupra tipurilor ce pot forma liste!
§         [[‘a’, ‘b’], [‘a’, ‘c’, ‘d’]] :: [[Char]]
·        3:(2:(1:[])) , lista construita cu ‘cons’.
·        datorita evaluarii tarzii listele infinite sunt posibile in Haskell.

Tipul uplu:

·        secventa finita de componente, posibil de tipuri diferite:
§         (False, True) :: (Bool, Bool)
§         (False, ‘a’, True) :: (Bool, Char, Bool)
§         (“Yes”, True, ‘a’) :: (String, Bool, Char)
·        numarul de componente dintr-un uplu se numeste aritate
·        uple de aritate 1 precum (False) nu sunt permise deoarece intra in conflict cu folosirea parantezelor pentru a forta ordinea unei evaluari. Ex. (1+2)*3
·        tipul unui uplu ii denota aritatea
§         (Bool, Bool)  ulpu de aritate 2
§         (String, Bool, Char) ulpu de aritate 3
·        nu exista restrictii asupra tipurilor ce pot forma uple:
§         (’a’, (False, ’b’)) :: (Char, (Bool , Char))
§         ([’a’, ’b’], [False, True ]) :: ([Char ], [Bool ])

Tipul functie:

·        functia este o mapare de la argumente de un tip la rezultate de alt tip.
·        T­1 -> T2 este tipul tuturor functiilor ce mapeaza argumente de tipul T1 la rezultate de tipul T2:
§         isDigit::Char->Bool
§         and::[Bool]->Bool
·        nu exista restrictia ca functiile sa fie totale (sa fie definite ptr orice argument valid). Functia de biblioteca tail nu e definita ptr lista vida.
·        In Haskell e standard ca functiile sa fie precedate de declaratia de tip, care e verificata la compilare cu cea obtinuta prin type inference.
·        functiile cu mai multe argumente se pot defini in 2 feluri:
o       “impachetand” argumentele in uple sau liste:
§         add :: (Int, Int) -> Int
add (x,y) = x + y
§         sum :: [Int] -> Int
sum x:xs = x + sum xs
o       prin functii Curry (metoda nativa Haskell):
§         sunt functii ce intorc alte functii
§         add’ :: Int->(Int->Int)
add’ x y = x + y
§         declaratia functiei ar fi identica chiar si fara paranteze, fiind asociativa la dreapta.
§         definitia functiei e asociativa la stanga:
o       ((add’ x ) y) = add’ x y
§         in afara de cazurile in care trimiterea parametrilor sub forma de uple e strict necesara, toate functiile in Haskell cu parametri multipli sunt definite ca functii curry.

Tipuri polimorfice:

·        functiile pot fi definite pentru mai multe tipuri: functia length trebuie sa poata fi aplicata pe orice tip de lista!
·        este posibil prin definirea functiei pe tipuri variabile:
§         length :: [a] -> Int
§         head :: [a] -> a
§         id :: a -> a
§         fst :: (a,b) -> a
·        variabilele de tip incep prin litere mici si se noteaza de obicei: a, b, c
·        un tip ce contine unul sau mai multe tipuri/variabile de tip se numeste polimorfic.


Tipuri supraincarcate:

·        operatorii +, -, *, ^ se aplica mai multor tipuri
·        tipul acestora contine variabile de tip supuse unor constrangeri de clasa ce se scriu sub forma:
§          C a unde C este numele clasei si a variabila de tip
§         (+) :: Num a => a-> a->a adica pentru orice tip a, instanta a clasei Num, functia (+) are tipul a->a->a
·        acestea se numesc tipuri supraincarcate

]]>ovidiuHaskell - Defining custom data types2014-10-23T08:25:00+00:002014-10-23T08:25:00+00:00https://bit0.ro/2014/10/haskell-defining-custom-data-types
  • allows us to add structure to the values in our programs
  • defining our own types also imrpoves the safety of our code
  • haskell will not allow us to accidentally mix values of two values that are structurally similar but have different names.

    • -- file: ch03/BookStore.hs
data BookInfo = Book Int String [String]
                deriving (Show)
     
    1. The BookInfo after the data keyword is the name of our new type. We call BookInfo a type constructor. 
    2. The Book that follows is the name of the value constructor (sometimes called a data constructor)
    3. After Book, the Int, String, and [String] that follow are the components of the type.
    ]]>    ovidiu    Haskell Evaluation2014-10-21T05:38:00+00:002014-10-21T05:38:00+00:00https://bit0.ro/2014/10/haskell-evaluation

    Conditional evaluation 

    -- file: ch02/myDrop.hs
myDrop n xs = if n <= 0 || null xs
              then xs
              else myDrop (n - 1) (tail xs) 
    The if keyword introduces an expression that has three components.
    • An expression of type Bool, immediately following the if. We refer to this as a predicate.
    • A then keyword, followed by another expression. This expression will be used as the value of the if expression if the predicate evaluates to True.
    • An else keyword, followed by another expression. This expression will be used as the value of the if expression if the predicate evaluates to False.
    • The null function indicates whether a list is empty, while the (||) operator performs a logical “or” of its Bool-typed arguments. 
    ghci> :type null
null :: [a] -> Bool
ghci> :type (||)
(||) :: Bool -> Bool -> Bool


    Operators are not special.Notice that we were able to find the type of (||) by wrapping it in parentheses. The (||) operator isn't “built into” the language: it's an ordinary function.

    The following are equivalent

    True || False
    (||) True False


    We'll refer to the expressions after the then  and else keywords as “branches”. The branches must have the same types; the if expression will also have this type. An expression such as if True then 1 else "foo" has different types for its branches, so it is ill typed and will be rejected by a compiler or interpreter.

    In an imperative language, it can make sense to omit the else branch from an if, because we're working with statements, not expressions. However, when we're working with expressions, an if that was missing an else wouldn't have a result or type if the predicate evaluated to False, so it would be nonsensical.

    It is an if *expression* rather than an if *statement*. This is an important distinction and worth stressing. An if expression must evaluate to a value, whereas an if statement can leave off the else clause as a shorthand for the 'do nothing' action. It still would not make sense to leave off the 'else' clause from an if-expression in a dynamically typed language.
     
    Our procedure will involve rewriting expressions over and over, substituting expressions for variables until we reach a final result.

    Lazy evaluation

    In a language that uses strict evaluation, the arguments to a function are evaluated before the function is applied. Haskell chooses another path: non-strict evaluation.

    In Haskell, the subexpression 1 + 2 is not reduced to the value 3. Instead, we create a “promise” that when the value of the expression isOdd (1 + 2) is needed, we'll be able to compute it. The record that we use to track an unevaluated expression is referred to as a thunk --  A thunk is a function which takes no arguments. -- a delayed computation -- This is all that happens: we create a thunk, and defer the actual evaluation until it's really needed. If the result of this expression is never subsequently used, we will not compute its value at all.

    Non-strict evaluation is often referred to as lazy evaluation


    • It makes sense to use substitution and rewriting to understand the evaluation of a Haskell expression.
    • Laziness leads us to defer evaluation until we need a value, and to evaluate just enough of an expression to establish its value.
    • The result of applying a function may be a thunk (a deferred expression)

    ]]>    ovidiu