class Something < ActiveRecord::Base
  class JsonSymbolized
    def self.load(string)
      JSON.parse(string, symbolize_names: true)
    end

    def self.dump(object)
      object.to_json
    end
  end

  serialize :field, JsonSymbolized
end

wget http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/js/bootstrap.min.js  -O app/assets/javascripts/bootstrap.min.js
wget http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap.min.css  -O app/assets/stylesheets/bootstrap.min.css

mkdir public/fonts
wget http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/fonts/glyphicons-halflings-regular.eot -O public/fonts/glyphicons-halflings-regular.eot
wget http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/fonts/glyphicons-halflings-regular.svg -O public/fonts/glyphicons-halflings-regular.svg
wget http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/fonts/glyphicons-halflings-regular.ttf -O public/fonts/glyphicons-halflings-regular.ttf
wget http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/fonts/glyphicons-halflings-regular.woff -O public/fonts/glyphicons-halflings-regular.woff

Also Font Awesome:

wget https://maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css -O app/assets/stylesheets/font-awesome.min.css
wget https://maxcdn.bootstrapcdn.com/font-awesome/4.2.0/fonts/fontawesome-webfont.eot -O public/fonts/fontawesome-webfont.eot
wget https://maxcdn.bootstrapcdn.com/font-awesome/4.2.0/fonts/fontawesome-webfont.woff -O public/fonts/fontawesome-webfont.woff
wget https://maxcdn.bootstrapcdn.com/font-awesome/4.2.0/fonts/fontawesome-webfont.ttf -O public/fonts/fontawesome-webfont.ttf
wget https://maxcdn.bootstrapcdn.com/font-awesome/4.2.0/fonts/fontawesome-webfont.svg -O public/fonts/fontawesome-webfont.svg

And bootstrap 3 Theme:

wget http://getbootstrap.com/dist/css/bootstrap-theme.min.css -O app/assets/stylesheets/z-bootstrap-theme.min.css

wget https://storage.googleapis.com/golang/go1.3.3.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.3.3.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> /etc/profile

Given that our developers told me that it’s practically impossible that two items have the same ID in the same day… because… 100 million! ….and Probability Theory! :)

It’s interesting that not many know of Birthday paradox. It says that when there are 23 people in the room, there is 50% chance that two of them have the same birthday. Not 180, just 23!

I’ve found a neat calculator online and within a minute there was a result.

When you have 3000 random selections per day from field of 100 million numbers - you have 4% chance that in any given day you will have duplicate.

In a week you have 88% chance! Think about it. 3000 random picks per day from 100 million and 88% chance!

Within 10 days you have 99% chance.

Mind-blowing, no? :)

0) Install Vagrant (via Googling)

1) Create ./srv/salt dir and ./srv/pillar dirs

2) Create Vagrantfile file:

Simple: CentOS master and minion on same machine

Vagrant.configure(2) do |config|
    config.vm.define "master" do |node|

        node.vm.box = 'chef/centos-6.5'
        node.vm.box_url = 'http://developer.nrel.gov/downloads/vagrant-boxes/CentOS-6.4-i386-v20131103.box'

        node.vm.synced_folder "srv/", "/srv", type: "nfs"
        node.vm.hostname = 'salt-master.local'

        script = '
            rpm -Uvh http://ftp.linux.ncsu.edu/pub/epel/6/i386/epel-release-6-8.noarch.rpm
            yum install -y salt-master salt-minion
            echo "192.168.50.2 salt" >> /etc/hosts
            service salt-master start
            service salt-minion start
            sleep 5
            salt-key -y -a salt-master.local
        '

        node.vm.provision "shell", inline: script

        node.vm.network "private_network", ip: "192.168.50.2"

        node.vm.provider "virtualbox" do |v|
            v.name = 'salt-master'
            v.memory = 4096
            v.cpus = 4
        end
    end


end

Or more complex - uses Ubuntu 14.04 for minon and CentOS 6.4 for master:

Vagrant.configure(2) do |config|

    config.vm.define "master" do |node|

        node.vm.box = 'centos-6.4'
        node.vm.box_url = 'http://developer.nrel.gov/downloads/vagrant-boxes/CentOS-6.4-i386-v20131103.box'

        node.vm.network "private_network", ip: "192.168.50.5"

        script = '
            rpm -Uvh http://ftp.linux.ncsu.edu/pub/epel/6/i386/epel-release-6-8.noarch.rpm
            yum install -y salt-master
            service salt-master start
        '

        node.vm.provision "shell", inline: script

        node.vm.provider "virtualbox" do |v|
            v.name = 'salt-master'
            v.memory = 2048
            v.cpus = 4
        end
    end

    config.vm.define "minion" do |node|

        node.vm.box = 'ubuntu-14.04'
        node.vm.box_url = 'https://cloud-images.ubuntu.com/vagrant/trusty/current/trusty-server-cloudimg-amd64-vagrant-disk1.box'

        node.vm.network "private_network", ip: "192.168.50.10"

        script = '
            apt-get update
            apt-get -y install python-software-properties
            yes | add-apt-repository ppa:saltstack/salt
            apt-get -y --force-yes install salt-minion
            echo "master: 192.168.50.5" > /etc/salt/minion
            echo "id: minion" >> /etc/salt/minion
            service salt-minion restart
        '

        node.vm.provision "shell", inline: script

        node.vm.provider "virtualbox" do |v|
            v.name = 'salt-minion'
            v.memory = 4096
            v.cpus = 4
        end
    end


end

3) Run vagrant ssh master

4) run salt-key -A

5) salt-call state.highstate

Your minion is 192.168.50.10 Your master is 192.168.50.5

Let’s imagine the taxes paying instead as a Crowd-funded State.

So, basically, State says that you have to spend 40% of your income on Govt. programs.

And then you have something like:

• Local hospital
  €10 000 000
  FULLY FUNDED
  
  
• Payment for teachers in your state
  €3 200 000 of €5 000 000 collected
  
  
  
• Payment for doctors in neighbour poor state
  €499 999 of €500 000 collected
  
  
  
• War with neighbouring country
  €0 of €100 000 000 collected
  
  
  
• Big Bank Bailout
  €0 of €700 000 000 000 collected
  
  
  

Obviously the prices are in € or in $ or any other state-issued money :) But that doesn’t mean that they can’t accept BitCoin for that.

And then you are free to distribute your funds as you see fit. Then all those programs that people don’t agree with - won’t get funding.

Now that’s some nice future that I want to live in! :)

It will probably be the first time I’d be happy to pay my taxes.

Has throttling, concurrency and some limits, but that’s about it.

An example to parse a lot of Italian websites:

require 'grucrawler'
require 'colorize'

class ItalianCrawler
  def options
    {
        visit_urls_only_once: true,
        follow_redirects: true,
        concurrency: 5,
        domain_wait: 20, # seconds between visits to the same domain
        max_page_size: 10000000
    }
  end

  def on_init(crawler)
    @crawler = crawler
  end

  def on_page_received(typhoeus_response, nokogiri_html)
    puts "GOT #{typhoeus_response.effective_url.green}"

    # typhoeus_response.body
    # typhoeus_response.request.url
    # typhoeus_response.effective_url
    # nokogiri_html.css('a').each |a| { puts a.text; }
  end

  def follow_link(target_url, typhoeus_response, nokogiri_html)
    return false if target_url.match(/\.(jpg|png|js|css|pdf|exe|dmg|zip|doc|rtf|rar|swf|bmp|swf|mp3|wav|mp4|mpg|flv|wma)$/)

    return true if target_url.include? '.it'

    false
  end

  def debug(message)
    #puts message.blue
  end

  def log_info(message)
    puts message.yellow
  end

  def log_error(typhoeus_response, exception)
    puts exception.to_s.red
  end
end

c = GruCrawler.new(ItalianCrawler.new)
# c.reset() # deletes all memory of all events - useful for restarting crawl
c.add_url('http://www.oneworlditaliano.com/english/italian/news-in-italian.htm')
c.run()

API might change in future, so

gem install grucrawler --version '0.0.5'

for the example below to work.

Here, grucrawler

Why? I’ve got tired of my attempts to get to understand all the complex stuff that goes into configuring all other crawlers. Too complex. I’ve wanted something dead simple.

Have fun!

Awesome!

Let’s encrypt initiative

We give up too easy. Especially when you are doing something new and try it for a few times and you see that it fails, you think that it’s not good and stop.

That’s the mistake. When I remember anything that I do well - it took me considerable amount of time to get good at it, considerable amount of failures went into that. But I didn’t give up and then I’ve became good at it.

Yet in many other cases I try something and I give up quite soon, when I should have continued.

We need to make habits of what we want to get good at. Only the daily routine can make you good at something.

Don’t give up too easy!

I’m learning German and the biggest problem so far is understanding what natives say (especially in movies, when they speak real fast). Yabla is awesome - it shows you the video with subtitles (nothing new here), and you can loop single phrase (that’s new!) and even slow it down.

Then there is “flashcards” feature. When you watch a video - you can click on unknown word and you see the translation, but in the background Yabla adds it to your Flashcards and you can review them later.

Probably the most useful thing I’ve tried for languages.

Actually, “Mini Habits” got me a great idea that if you can do something regularly you should cut it in half and in half and in half until the task is so small that it’s more easy to do it than to figure out why should you not do it.

So for the blog posts at first the task was to “Write a blog post”, but that seems like a lot almost always, so eventually the task got to be “Write a 1-line blog post”.

Well, that’s quite easy. And it gets you started. And when you start doing something it’s harder to stop rather than continue, so you almost always exceed your original microscopic plan by far.

Also, ”Habit bull” is really a great app for Android to keep you on track with your new mini-habits.

2) If you have previously installed RAID, disable it:

mdadm -S /dev/md0
mdadm -S /dev/md1
mdadm -S /dev/md2

3) Clean up partition table:

dd if=/dev/zero of=/dev/sda bs=100M count=1

4) Install CoreOS

cd /tmp

cat >cloud-config.yaml << 'EOF'
#cloud-config

hostname: coreos1

ssh_authorized_keys:
  - ssh-rsa AAAAB3....
EOF

wget https://raw.githubusercontent.com/coreos/init/master/bin/coreos-install
chmod +x coreos-install
./coreos-install -d /dev/sda -C stable -c cloud-config.yaml

5) Reboot

6) You can now do ssh core@your-server.com

    package main

    import (
        "fmt"
        "io/ioutil"
        "net"
        "net/http"
        "time"
    )

    func handler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hi!")
    }

    func handler_proxy(w http.ResponseWriter, r *http.Request) {
        tr := &http.Transport{
            MaxIdleConnsPerHost: 250,
            Dial: func(netw, addr string) (net.Conn, error) {
                timeout := time.Duration(10000) * time.Millisecond
                c, err := net.DialTimeout(netw, addr, timeout)
                if err != nil {
                    return nil, err
                }
                // also set time limit on reading
                c.SetDeadline(time.Now().Add(timeout))
                return c, nil
            }}

        // spawn an idle conn trimmer
        go func(t *http.Transport) {
            // prunes every 5 minutes. this is just a guess at an
            // initial value. very busy workers may want to lower this...
            for {
                time.Sleep(10 * time.Second)
                t.CloseIdleConnections()
            }
        }(tr)

        // build/compile regex
        client := &http.Client{Transport: tr}

        resp, err := client.Get("http://127.0.0.1:8080/")

        if err != nil {
            fmt.Fprintf(w, "Cannot connect %v", err)
            return
        }

        defer resp.Body.Close()
        body, err := ioutil.ReadAll(resp.Body)

        w.Write(body)
    }

    func main() {
        http.HandleFunc("/", handler)
        http.HandleFunc("/proxy", handler_proxy)
        http.ListenAndServe(":8080", nil)
    }

sysctl -w net.core.rmem_max=67108864
sysctl -w net.core.wmem_max=67108864
sysctl -w net.ipv4.tcp_rmem=4096 87380 33554432
sysctl -w net.ipv4.tcp_wmem=4096 65536 33554432
sysctl -w net.core.netdev_max_backlog=30000
sysctl -w net.ipv4.tcp_congestion_control=htcp
sysctl -w net.ipv4.tcp_mtu_probing=1
sysctl -w net.netfilter.nf_conntrack_generic_timeout=120
sysctl -w net.ipv4.ip_local_port_range=1025 65535
sysctl -w net.ipv4.tcp_max_tw_buckets=1048576
sysctl -w net.ipv4.tcp_max_tw_buckets_ub=66144
sysctl -w net.nf_conntrack_max=524288
sysctl -w net.ipv4.tcp_timestamps=1
sysctl -w net.ipv4.tcp_tw_recycle=1

ulimit -n 9999999
echo 9999999 > /proc/sys/fs/nr_open
echo 9999999 > /proc/sys/fs/file-max

/sbin/ifconfig eth0 txqueuelen 100000

More to try:

• http://stackoverflow.com/questions/12234050/nginx-high-volume-traffic-load-balancing
• http://www.lognormal.com/blog/2012/09/27/linux-tcpip-tuning/

Sources:

• http://fasterdata.es.net/host-tuning/linux/
• http://shenfeng.me/how-far-epoll-can-push-concurrent-socket-connection.html

Bootstrap 3 with old theme

<link rel="stylesheet" type="text/css" href="http://rarestblog.com//maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap.min.css">
<script type="text/javascript" src="http://rarestblog.com//maxcdn.bootstrapcdn.com/bootstrap/3.3.1/js/bootstrap.min.js"></script>
<link rel="stylesheet" type="text/css" href="http://getbootstrap.com/dist/css/bootstrap-theme.min.css">

Angular 1.2

<script type="text/javascript" src="http://rarestblog.com//cdnjs.cloudflare.com/ajax/libs/angular.js/1.2.1/angular.js"></script>

<script type="text/javascript">
    var app = angular.module('app', []);

    app.controller('MainCtrl', function ($scope) {
      $scope.var1 = '123';
    });
</script>

<div ng-app="app" class="ng-scope">
    <div ng-controller="MainCtrl" class="ng-scope">
        <div class="ng-binding">{{ var1 }}</div>
    </div>
</div>

JSFiddle

http://jsfiddle.net/993gt1Lc/

Create an email and send it to

tomorrow@fut.io

This e-mail will return to you tomorrow, at which point you would be able to defer it for any amount of time or be done with it.

The service is called FollowUpThen and it’s awesome!

Some things to try: tomorrow8am@fut.io, nextmonday@fut.io, every3days@fut.io, 5d@fut.io (in 5 days).

Try it! - http://www.followupthen.com/

Basically I though something like this should be possible:

Package::named("php5-cli mysql-server git imagemagick")
    ->shouldBeInstalled();

Service::named('apache2')
    ->shouldBeInstalled()
    ->shouldBeRunning()
    ->shouldBeRunningAtReboots();


File::named('/var/www/index.html')->write("Bender is great!");

Http::request('http://localhost/')
    ->onSuccess(function($request, $response) {
        Console::log('My new code is "' . $response->getBody() . '"');
    })
    ->run();

User::named('root')
    ->shouldHaveSshKey()
    ->mailPublicKeyOnce('user@super-server.com');

User::named('alex')
    ->shouldBePresent()
    ->haveSshKeyFrom('files/alex.ssh')
    ->shouldBeInGroup('sudo')
    ->shouldHaveNoPasswordSudoFor('/usr/sbin/service')
    ->shouldHaveSudoFor('/bin/vi');

I thought that since PHP has PHPStorm, which has a great auto-completion - it should be much easier to write PHP scripts than Puppet/Chef scripts. Also you have a complete language to help you refactor the code.

And that’s what I actually implemented. It’s still a work in progress, but check it out if you want to.

Git repository

Check it out

Installing

Start with CentOS 6 as root:

wget -P /etc/yum.repos.d/ http://ftp.openvz.org/openvz.repo
rpm --import http://ftp.openvz.org/RPM-GPG-Key-OpenVZ
yum install vzkernel

echo "
# On Hardware Node we generally need
# packet forwarding enabled and proxy arp disabled
net.ipv4.ip_forward = 1
net.ipv6.conf.default.forwarding = 1
net.ipv6.conf.all.forwarding = 1
net.ipv4.conf.default.proxy_arp = 0

# Enables source route verification
net.ipv4.conf.all.rp_filter = 1

# Enables the magic-sysrq key
kernel.sysrq = 1

# We do not want all our interfaces to send redirects
net.ipv4.conf.default.send_redirects = 1
net.ipv4.conf.all.send_redirects = 0
" >> /etc/sysctl.conf

echo "SELINUX=disabled" > /etc/sysconfig/selinux

yum install vzctl vzquota ploop

reboot

Download template

cd /vz/template/cache/ && wget http://download.openvz.org/template/precreated/ubuntu-12.04-x86_64.tar.gz

Creating and running container

Create container (101 is container ID, must be > 100).

vzctl create 101 --ostemplate ubuntu-12.04-x86_64
vzctl set 101 --ipadd 192.168.2.101 --save
vzctl set 101 --nameserver 8.8.8.8 --save
vzctl start 101
vzctl stop 101

Some more useful commands:

vzctl set 103 --onboot yes --save
vzctl set 103 --hostname host.example.com --save
vzctl set 103 --userpasswd root:passw0rd

For some reason it’s better to give IPs like 192.168 than 10.x (couldn’t get containers to ping)

Something useful (on hardware node):

vzctl enter 101
vzctl exec 101 "ls"
ls /vz/private/101/

Internet access from container

IP=$(/sbin/ip -o -4 addr list eth0 | awk '{print $4}' | cut -d/ -f1)
iptables -t nat -A POSTROUTING -s 192.168.2.0/24 -o eth0 -j SNAT --to $IP

Expose container port to outside

OUTER_PORT=11111
INNER_HOST=192.168.2.1
INNER_PORT=80

IP=$(/sbin/ip -o -4 addr list eth0 | awk '{print $4}' | cut -d/ -f1)
iptables -t nat -A PREROUTING -p tcp -d $IP --dport $OUTER_PORT \
         -i eth0 -j DNAT --to-destination $INNER_HOST:$INNER_PORT 

iptables save

/etc/init.d/iptables save
chkconfig --level 53 iptables on

For more help:

• http://openvz.org/Quick_installation
• http://openvz.org/Basic_operations_in_OpenVZ_environment
• http://openvz.org/Using_NAT_for_container_with_private_IPs