Jose Santiago Jr.

the findings and grumblings of Jose Santiago, a web and mobile app developer in Northern New Jersey.

[josesantiagojr]

How to update the firmware on a Dell 11th gen server (RX10)

As some of us have found out the hard way, 11th gen FTP repos are no longer available from the Dell support site when using the lifecycle controller. Traditionally, this has been an easy way to get things done.

Using the below steps, you can use a Dell provided Linux bootable ISO to get the firmware up to date.

find and download the relevant ISO based on the server you wish to patch https://www.dell.com/support/article/ca/en/cabsdt1/sln296511/updating-dell-poweredge-servers-via-bootable-media-iso?lang=en

Access the iDRAC virtual console and mount the ISO to your host using Virtual Media (or plug in physically after making a bootable USB from the ISO with rufus)

Reboot the server and enter BIOS Boot Manager (F11) menu

Select your mounted ISO,

As soon as you see the Tool Boot Options, select option 1 to start the firmware updates.

The firmware will begin to update. CAUTION: this can take up to 1 hour to complete, and DO NOT (under any circumstance) reboot before it’s completed.

Please note: It is normal for error messages to appear when the media tries to update components which are not installed in your system. This behavior is expected since the tool attempts to update all components that might be installed in the specific server model without checking if they’re actually present first. The update will continue regardless.

After all firmware upgrades are completed you will see a message indicating a warm reboot is required, so press any key to reboot

Enjoy your freshly upgraded server!

[josesantiagojr]

Hi, do you have a guide on how to install ffmpeg on 14.10 Ubuntu Server? Thanks !

There are two unofficial PPAs available to install FFmpeg in Ubuntu 14.10/14.04. A PPA by Kyrill offers packages for 14.10 Utopic and 14.04 Trusty/Linux Mint 17.1/17

To install FFmpeg in Ubuntu/Linux Mint, do the following:sudo add-apt-repository ppa:kirillshkrogalev/ffmpeg-nextsudo apt-get updatesudo apt-get install ffmpeg

This is no longer an issue in Ubuntu 15.04, as ffmpeg has been added back to the Ubunto repos, so it does not require a ppa.

[josesantiagojr]

Limit SFTP Access to Certain Folders on Ubuntu 14.04

As the system administrator, you may want to give your users the ability to securely upload files to your server. The most common way to do this is to allow file transfers via SFTP, which uses SSH to provide encryption. This means you need to give your users SSH logins. But, by default, SSH users are able to view your server’s entire filesystem, which may not be desirable.

This guide will help you configure OpenSSH to restrict users to their home directories, and to SFTP access only. Please note that these instructions are not intended to support shell logins; any user accounts modified in accordance with this guide will have the ability to transfer files, but not the ability to log into a remote shell session.

These instructions will work for Ubuntu 9.04, Debian 5, and later. Unfortunately, the version of SSH packaged with Ubuntu 8.04 is too old to support this configuration.

Configure OpenSSH

First, you need to configure OpenSSH.

Edit your /etc/ssh/sshd_config file with your favorite text editor:

vim /etc/ssh/sshd_config

Add or modify the Subsystem sftp line to look like the following:

/etc/ssh/sshd_config

Subsystem sftp internal-sftp

Add this block of settings to the end of the file:

Match group filetransfer    ChrootDirectory %h    X11Forwarding no    AllowTcpForwarding no    ForceCommand internal-sftp

Save the changes to your file.

Restart OpenSSH:

service ssh restart

OpenSSH has been successfully modified.

Modify User Accounts

In this section, we’ll set up the correct new groups, ownership, and permissions for your user accounts.

Create a system group for users whom you want to restrict to SFTP access:

addgroup --system filetransfer

Modify the user accounts that you wish to restrict to SFTP. Issue the following commands for each account, substituting the appropriate username. Please keep in mind that this will prevent these users from being able to log into a remote shell session.

usermod -G filetransfer username chown root:root /home/username chmod 755 /home/username

These users will now be unable to create files in their home directories, since these directories are owned by the root user.

Next, you need to create new directories for each user, to which they will have full access. Issue the following commands for each user, changing the directories created to suit your needs:

cd /home/username mkdir docs public_html chown -R username:filetransfer ./*

Your users should now be able to log into their accounts via SFTP and transfer files to and from their assigned subdirectories, but they shouldn’t be able to see the rest of your server’s filesystem.

Depending on your set up, you can then create a symbolic link from the public_html folder in the user’s home directory and your server root directory:

ln -s /home/username/public_html /var/www/username

More Information

You may wish to consult the following resources for additional information on this topic. While these are provided in the hope that they will be useful, please note that we cannot vouch for the accuracy or timeliness of externally hosted materials.

OpenSSH Documentation

An Introduction to Users and Groups

[josesantiagojr]

How to redirect the WWW subdomain to your root domain

At some point or another, all developers with web projects encounter that moment when their project is ready to go live. A very common mistake that they make when doing so is to forget to properly set up access to yourwebsite.com from www.yourwebsite.com.

Modern web developers have all come to forget that "www." usage is actually still valid and very widespread. It is also very common for it to not be set up out of the box unless you purchased a cheap, underpowered, restrictive, all-in-one bundle with your domain name from a provider like GoDaddy/Register.com/Network Solutions.

In order to properly handle requests to www.yourwebsite.com, you just need to handle a few very simple steps within your DNS/Nameserver records:

In your DNS records, if you have an existing "A" entry for "www", delete it. If you have a "CNAME" for "www" that has either "@" or "yourwebsite.com" as the value field, then congratulations you are a step ahead of us, so consider yourself special and skip step 2.

Add a new DNS "CNAME" record with "www" which points to "@" or "yourwebsite.com" (the "@" just means the root record, which is "yourwebsite.com", so either is valid)

Once this is done: Congratulations, you're now sending all www.yourwebsite.com requests to the same place as your main website. This is where another issue arises now.

You need to make sure to accommodate the WWW requests on your web server.

For a Digital Ocean server created from the LAMP (Linux/Apache/MySQL/PHP), LEMP (Linux/Nginx/MySQL/PHP), or WordPress Application Images, the server will respond indiscriminately to any requests that are directed to it, so regardless of whether it is yourwebsite.com or this-is-so.yourwebsite.com, it will serve up the same content to the user.

The problem here is SEO-related, as you will be penalized for having duplicate content on your domain. As far as search engines are concerned, www.yourwebsite.com and yourwebsite.com are two completely different sites under the same main domain. They don't care whether both URLs respond with identical content from the same server, so this will ultimately hurt your search engine ranking. The solution is to tell your server to redirect all WWW requests to the main non-WWW domain.

Below are two examples of how you can accommodate this kind of request in either Apache or Nginx:

Apache

In the main folder of your website (typically /var/www), you need to add a hidden text file named ".htaccess" (NOTE: the period at the beginning of the name is what causes it to be hidden, and it is absolutely required), which you may already have if you have installed WordPress. If you do have an existing .htaccess file, add the following code to the beginning of the file, above any currently existing content in the file, and if you don't have this file already, create it with the following text as the content (be sure to replace the word "example" in this text with your actual domain name, e.g. www\.example\.com would become www\.yourwebsite\.com):

#Force non-www: RewriteEngine on RewriteCond %{HTTP_HOST} ^www\.example\.com [NC] RewriteRule ^(.*)$ http://example.com/$1 [L,R=301]

Nginx

Nginx is different from Apache when it comes to implementing this solution, as there is no hidden file to edit. Instead, you need to edit the configuration file that contains the Nginx settings for your website (usually found in /etc/nginx/sites-available), or if you don't have a site-specific config file, it may be in the default config, which can be found in the same folder. Once you have located the site config file, you will need to add the following to the top of the file:

server {      server_name www.example.com;      rewrite ^(.*) http://example.com$1 permanent; }

Your final Nginx config file should look similar to the following:

server {     server_name www.example.com;     rewrite ^(.*) http://example.com$1 permanent; } server{     listen 80;     server_name example.com;     index index.php index.html;     root /var/www/example.com/web; }

Now you're all set! All traffic is being routed to and redirected properly from your WWW subdomain to your main website, without incurring the harmful wrath of the almighty Google ranking algorithm for "duplicate" content! Enjoy, and best of luck!

[josesantiagojr]

Create a Virtual Network Interface on Ubuntu 14.04

To add a permanent virtual interface to your network connection (assuming it is eth0) using a public facing IP, simply add the following to your /etc/network/interfaces file (where eth0:0 increments with each virtual IP, so the next additional virt. IP would be labeled eth0:1):

iface eth0:0 inet static address <public ip goes here> netmask 255.0.0.0 broadcast <insert first octet of public ip here>.255.255.255

[josesantiagojr]

Easily copy your SSH public key to another machine using Mac OS X

This utilizes the scripts found in this Github repo, which allows you to use a command similar to the Linux-specific ssh-copy-id command:

https://github.com/beautifulcode/ssh-copy-id-for-OSX

To install it, simply execute this command in your terminal window:

curl -L https://raw.githubusercontent.com/beautifulcode/ssh-copy-id-for-OSX/master/install.sh | sh

To copy your key over to the server, all you have to do is enter the following command now:

ssh-copy-id -i path_to_pub_key username@hostname

Example: ssh-copy-id -i ~/.ssh/id_rsa.pub [email protected]

To customize the port, use quotes and the -p flag: "[email protected] -p 222"

Now you can log in to your server remotely without requiring the password every time.

[josesantiagojr]

Create SWAP Space on Your Digital Ocean Ubuntu VPS

You will probably end up needing some swap space if you plan on using Rails on Digital Ocean 512MB RAM droplet. Specifically, you will run out of RAM when compiling the assets, resulting in the process being quietly killed and preventing successful deployments.

To see if you have a swap files:

sudo swapon -s

No swap file shown? Check how much disk space space you have:

df

To create a swap file:

Step 1: Allocate a file for swap

sudo fallocate -l 2048m /mnt/swap_file.swap

Step 2: Change permission

sudo chmod 600 /mnt/swap_file.swap

Step 3: Format the file for swapping device

sudo mkswap /mnt/swap_file.swap

Step 4: Enable the swap

sudo swapon /mnt/swap_file.swap

Step 5: Make sure the swap is mounted when you Reboot. First, open fstab

sudo gedit /etc/fstab

Finally, add entry in fstab

# /etc/fstab /mnt/swap_file.swap none swap sw 0 0

Save and exit. You're done adding swap. Now your rake assets:precompile should complete without being killed.

[josesantiagojr]

Setting up a Digital Ocean Droplet (VPS) on Ubuntu with Rails, Nginx, Unicorn, Postgres, Redis and Capistrano

Create a Droplet on Digital Ocean

I stuck with the defaults:

Size  512MB / 1 CPU  20GB SSD  $5 / Month

Image  Ubuntu 12.04 x32

ssh to root in terminal with your server's ip address

ssh [email protected]

Add ssh fingerprint and enter the password provided in the email from DO

Change password

passwd

Create new user. I like calling this guy "deployer" so that's what you'll see throughout this post.

adduser deployer

Set new users privileges

visudo

Find user privileges section and add your new user privileges under root. Type cntrl+x then y to save

# User privilege specification root ALL=(ALL:ALL) ALL deployer ALL=(ALL:ALL) ALL

Configure SSH

nano /etc/ssh/sshd_config

Find and change port to one that isn't default(22 is default: choose between 1025 ..65536)

# Port 22 # change this to whatever port you wish to use I'm using 1026 for this example Port 1026 Protocol 2 PermitRootLogin yes # You can change this to "no" if you don't want the root user to be able to ssh in anymore

Add to bottom of sshd_config file after changing port (cntrl+x then y to save)

UseDNS no AllowUsers deployer # Only add this line if you have changed PermitRootLogin to no, or you can do AllowUsers deployer root

Reload ssh

reload ssh

Don't close root! Open a new shell and ssh to your VPS (droplet) with deployer (remember the port you set above or you'll be locked out)

ssh -p 1026 [email protected]

Update the packages as deployer on your VPS. This installs curl, some python stuff, git and node.js (node.js is for the Rails asset pipeline)

sudo apt-get update sudo apt-get -y install curl python-software-properties git-core nodejs

Install Redis (optional)

Prepare to install Redis

sudo apt-get -y install build-essential tcl8.5

Change to your home directory and download Redis with wget (I use it for Sidekiq)

cd ~ wget http://redis.googlecode.com/files/redis-2.4.16.tar.gz

Untar Redis, switch into its directory then run make and make install. Then run the Redis install script.

tar xzf redis-2.4.16.tar.gz cd redis-2.4.16 make make test sudo make install cd utils sudo ./install_server.sh

To automatically start Redis when the server boots

sudo update-rc.d redis_6379 defaults

RVM

Install latest stable version of rvm

curl -L get.rvm.io | bash -s stable

Load rvm

source ~/.rvm/scripts/rvm

Install rvm dependencies

rvm requirements

Install ruby 2.0.0

rvm install 2.0.0

Use 2.0.0 as rvm default

rvm use 2.0.0 --default

Install latest version of rubygems if rvm install didn't

rvm rubygems current

Rails

Install the rails gem

gem install rails --no-ri --no-rdoc

Install bundler

gem install bundler

PostgreSQL

Install postgres

sudo apt-get install postgresql postgresql-server-dev-9.1 gem install pg -- --with-pg-config=/usr/bin/pg_config

Create a new postgres user. It's not a bad idea to use the same username here. Remember these so you can add them to your database.yml file later.

sudo -u postgres psql create user deployer with password 'secret'; alter role deployer superuser createrole createdb replication; create database projectname_production owner deployer; \q

Nginx

Setup nginx

sudo apt-get install nginx

These 3 commands test if nginx is installed

nginx -h cat /etc/init.d/nginx /etc/init.d/nginx -h

Start Nginx

sudo service nginx start # cd /etc/nginx

Preparing for Deployment locally with Unicorn, Nginx and Capistrano

Add unicorn to the gemfile

gem "unicorn"

Manually create these 3 files:

config/nginx.conf

config/unicorn.rb

config/unicorn_init.sh

config/nginx.conf (change projectname and username, I'm usingdeployer, to match your directory structure!)

upstream unicorn { server unix:/tmp/unicorn.projectname.sock fail_timeout=0; } server { listen 80 default deferred; # server_name example.com; root /home/deployer/apps/projectname/current/public; location ^~ /assets/ { gzip_static on; expires max; add_header Cache-Control public; } try_files $uri/index.html $uri @unicorn; location @unicorn { proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $http_host; proxy_redirect off; proxy_pass http://unicorn; } error_page 500 502 503 504 /500.html; client_max_body_size 4G; keepalive_timeout 10; }

config/unicorn.rb

root = "/home/deployer/apps/projectname/current" working_directory root pid "#{root}/tmp/pids/unicorn.pid" stderr_path "#{root}/log/unicorn.log" stdout_path "#{root}/log/unicorn.log" listen "/tmp/unicorn.projectname.sock" worker_processes 2 timeout 30 # Force the bundler gemfile environment variable to # reference the capistrano "current" symlink before_exec do |_| ENV["BUNDLE_GEMFILE"] = File.join(root, 'Gemfile') end

config/unicorn_init.sh

#!/bin/sh ### BEGIN INIT INFO # Provides: unicorn # Required-Start: $remote_fs $syslog # Required-Stop: $remote_fs $syslog # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: Manage unicorn server # Description: Start, stop, restart unicorn server for a specific application. ### END INIT INFO set -e # Feel free to change any of the following variables for your app: TIMEOUT=${TIMEOUT-60} APP_ROOT=/home/deployer/apps/projectname/current PID=$APP_ROOT/tmp/pids/unicorn.pid CMD="cd $APP_ROOT; bundle exec unicorn -D -c $APP_ROOT/config/unicorn.rb -E production" AS_USER=deployer set -u OLD_PIN="$PID.oldbin" sig () { test -s "$PID" && kill -$1 `cat $PID` } oldsig () { test -s $OLD_PIN && kill -$1 `cat $OLD_PIN` } run () { if [ "$(id -un)" = "$AS_USER" ]; then eval $1 else su -c "$1" - $AS_USER fi } case "$1" in start) sig 0 && echo >&2 "Already running" && exit 0 run "$CMD" ;; stop) sig QUIT && exit 0 echo >&2 "Not running" ;; force-stop) sig TERM && exit 0 echo >&2 "Not running" ;; restart|reload) sig HUP && echo reloaded OK && exit 0 echo >&2 "Couldn't reload, starting '$CMD' instead" run "$CMD" ;; upgrade) if sig USR2 && sleep 2 && sig 0 && oldsig QUIT then n=$TIMEOUT while test -s $OLD_PIN && test $n -ge 0 do printf '.' && sleep 1 && n=$(( $n - 1 )) done echo if test $n -lt 0 && test -s $OLD_PIN then echo >&2 "$OLD_PIN still exists after $TIMEOUT seconds" exit 1 fi exit 0 fi echo >&2 "Couldn't upgrade, starting '$CMD' instead" run "$CMD" ;; reopen-logs) sig USR1 ;; *) echo >&2 "Usage: $0 <start|stop|restart|upgrade|force-stop|reopen-logs>" exit 1 ;; esac

Change permissions on unicornt_init.sh

chmod +x config/unicorn_init.sh

Capistrano

Add capistrano and rvm capistrano to gemfile

gem 'capistrano' gem 'rvm-capistrano'

Create Capfile & config/deploy.rb files by running

capify .

For deploy.rb you should change the server ip address, :user (I'm using deployer), :repository path (gertig), and note that :port is not 22 since we changed it above to 1026

config/deploy.rb

require "bundler/capistrano" require "rvm/capistrano" require 'sidekiq/capistrano' server "123.123.123.123", :web, :app, :db, primary: true set :application, "projectname" set :user, "deployer" set :port, 1026 set :deploy_to, "/home/#{user}/apps/#{application}" set :deploy_via, :remote_cache set :use_sudo, false set :scm, "git" set :repository, "[email protected]:gertig/reponame.git" set :branch, "master" default_run_options[:pty] = true ssh_options[:forward_agent] = true after "deploy", "deploy:cleanup" # keep only the last 5 releases namespace :deploy do %w[start stop restart].each do |command| desc "#{command} unicorn server" task command, roles: :app, except: {no_release: true} do run "/etc/init.d/unicorn_#{application} #{command}" end end task :setup_config, roles: :app do sudo "ln -nfs #{current_path}/config/nginx.conf /etc/nginx/sites-enabled/#{application}" sudo "ln -nfs #{current_path}/config/unicorn_init.sh /etc/init.d/unicorn_#{application}" run "mkdir -p #{shared_path}/config" put File.read("config/database.example.yml"), "#{shared_path}/config/database.yml" puts "Now edit #{shared_path}/config/database.yml and add your username and password" end after "deploy:setup", "deploy:setup_config" task :symlink_config, roles: :app do run "ln -nfs #{shared_path}/config/database.yml #{release_path}/config/database.yml" end after "deploy:finalize_update", "deploy:symlink_config" desc "Make sure local git is in sync with remote." task :check_revision, roles: :web do unless `git rev-parse HEAD` == `git rev-parse origin/master` puts "WARNING: HEAD is not the same as origin/master" puts "Run `git push` to sync changes." exit end end before "deploy", "deploy:check_revision" end

Capfile

load 'deploy' load 'deploy/assets' load 'config/deploy'

SSH in to Github to add your keys

# follow the steps in this guide if receive permission denied(public key) # https://help.github.com/articles/error-permission-denied-publickey ssh [email protected]

Add ssh key to digitalocean

cat ~/.ssh/id_rsa.pub | ssh -p 1026 [email protected] 'cat >> ~/.ssh/authorized_keys'

Add your Environment variables like ENV["SECRET_KEY"]

sudo nano /etc/environment

On each new line add something like

SECRET_TOKEN=55555DDDDDDDEEEE44444 REDIS_URL=redis://123.123.123.123:6379

Create repo and push to github

# Add config/database.yml to .gitignore cp config/database.yml config/database.example.yml git init git add . git commit -m "Inital Commit" git remote add origin [email protected]:gertig/reponame git push origin master

DEPLOYMENT

cap deploy:setup

Edit database.yml on server to add username and password to the production database

nano apps/projectname/shared/config/database.yml

Deploy it cold

cap deploy:cold

Then remove the nginx default folder (if it doesn't exist don't worry about it)

sudo rm /etc/nginx/sites-enabled/default

Restart Nginx

sudo service nginx restart sudo update-rc.d -f unicorn_projectname defaults

Now whenever you make changes do the following.

# Make changes git add . git commit -m "Changes" git push origin master

Deploy

cap deploy

Stop and Start the unicorn server

sudo service unicorn_appname stop sudo service unicorn_appname start

Restart Nginx

sudo service nginx restart

Troubleshooting

Nokogiri

If Nokogiri complains about libxml run this:

sudo apt-get install libxslt-dev libxml2-dev

Then try your cap deploy:cold again if that is where you failed.

[josesantiagojr]

Install FFMPEG on Ubuntu From Source

Compile FFmpeg on Ubuntu ¶

Contents

Preparation

Installation

Finish

Optional Installation

Updating FFmpeg

Reverting Changes Made by This Guide

If You Need Help

This guide supports Ubuntu 12.10 (Quantal Quetzal), Ubuntu 12.04 (Precise Pangolin), and Ubuntu 11.10 (Oneiric Ocelot). Separate guides are available for Ubuntu 10.04 (Lucid Lynx) and Ubuntu 8.04 (Hardy Heron). This guide will provide the latest FFmpeg code and enable several external encoding and decoding libraries:fdk-aac (AAC encoder), libfaac (AAC encoder), libmp3lame (MP3 encoder), libopencore-amr (AMR encoder/decoder), librtmp (for additional RTMP protocols), libtheora (Theora encoder), libvorbis (Vorbis encoder), libvpx (VP8 encoder/decoder), and libx264 (H.264 encoder). These are optional and may be omitted if desired. This guide will also install many filters, including the subtitles filter for hardcoding subtitles (see the filter list in the Filtering Guide).

Note: Copy and paste the whole code box for each step.

Preparation

Remove any existing packages:

sudo apt-get remove ffmpeg x264 libav-tools libvpx-dev libx264-dev yasm

Note: The multiverse repository must be enabled in order to install the libfaac-dev package. See  more details on adding repositories.

Get the dependencies (Ubuntu Desktop users):

sudo apt-get update sudo apt-get -y install autoconf build-essential checkinstall git libass-dev libfaac-dev \ libgpac-dev libjack-jackd2-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev \ librtmp-dev libsdl1.2-dev libtheora-dev libtool libva-dev libvdpau-dev libvorbis-dev \ libx11-dev libxext-dev libxfixes-dev pkg-config texi2html zlib1g-dev

Get the dependencies (Ubuntu Server or headless users):

sudo apt-get update sudo apt-get -y install autoconf build-essential checkinstall git libass-dev libfaac-dev \ libgpac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev librtmp-dev \ libtheora-dev libtool libvorbis-dev pkg-config texi2html zlib1g-dev

Installation

Yasm

Yasm is an assembler and is recommended for x264 and FFmpeg.

cd wget http://www.tortall.net/projects/yasm/releases/yasm-1.2.0.tar.gz tar xzvf yasm-1.2.0.tar.gz cd yasm-1.2.0 ./configure make sudo checkinstall --pkgname=yasm --pkgversion="1.2.0" --backup=no \ --deldoc=yes --fstrans=no --default

x264

H.264 video encoder. The following commands will get the current source files, compile, and install x264. See the x264 Encoding Guide for some usage examples.

cd git clone --depth 1 git://git.videolan.org/x264 cd x264 ./configure --enable-static make sudo checkinstall --pkgname=x264 --pkgversion="3:$(./version.sh | \ awk -F'[" ]' '/POINT/{print $4"+git"$5}')" --backup=no --deldoc=yes \ --fstrans=no --default

Note: You can download the nightly  x264 source snapshot as an alternative to using git.

fdk-aac

AAC audio encoder.

cd git clone --depth 1 git://github.com/mstorsjo/fdk-aac.git cd fdk-aac autoreconf -fiv ./configure --disable-shared make sudo checkinstall --pkgname=fdk-aac --pkgversion="$(date +%Y%m%d%H%M)-git" --backup=no \ --deldoc=yes --fstrans=no --default

Note: You can download a  fdk-aac source snapshot as an alternative to using git.

libvpx

VP8 video encoder and decoder.

cd git clone --depth 1 http://git.chromium.org/webm/libvpx.git cd libvpx ./configure --disable-examples --disable-unit-tests make sudo checkinstall --pkgname=libvpx --pkgversion="1:$(date +%Y%m%d%H%M)-git" --backup=no \ --deldoc=yes --fstrans=no --default

Note: You can download a  libvpx source snapshot as an alternative to using git.

opus (optional)

Opus audio encoder and decoder. Add --enable-libopus to your ffmpeg ./configure line if you want to use this.

cd git clone --depth 1 git://git.xiph.org/opus.git cd opus ./autogen.sh ./configure --disable-shared make sudo checkinstall --pkgname=libopus --pkgversion="$(date +%Y%m%d%H%M)-git" --backup=no \ --deldoc=yes --fstrans=no --default

FFmpeg

Note: Ubuntu Server users should remove --enable-x11grab from the following command:

cd git clone --depth 1 git://source.ffmpeg.org/ffmpeg cd ffmpeg ./configure --enable-gpl --enable-libass --enable-libfaac --enable-libfdk-aac --enable-libmp3lame \ --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-librtmp --enable-libtheora \ --enable-libvorbis --enable-libvpx --enable-x11grab --enable-libx264 --enable-nonfree --enable-version3 make sudo checkinstall --pkgname=ffmpeg --pkgversion="7:$(date +%Y%m%d%H%M)-git" --backup=no \ --deldoc=yes --fstrans=no --default hash -r

Note: You can download the nightly FFmpeg source snapshot as an alternative to using git.

Finish

Installation is now complete and FFmpeg is now ready for use. You can keep the x264, libvpx, and ffmpeg directories in your home directory if you plan on updating later. See Updating FFmpeg below for more details. Some optional steps are next followed by instructions on updating FFmpeg and finally instructions on reverting all changes made by this guide.

[josesantiagojr]

FFProbe on Ubuntu Doesn't Print Anything

The cause for this is that the version of ffmpeg provided via the repos is out of date. To get the latest version, do the following:

Add an up-to-date repo:

sudo add-apt-repository ppa:jon-severinsson/ffmpeg

If you're using Ubuntu 12.x, add the backports repo as well (substitute precise for your distro)

deb http://archive.ubuntu.com/ubuntu precise-backports main restricted universe multiverse

Replace the currently installed version with the one from the new repo

sudo apt-get remove ffmpeg 

sudo apt-get autoremove 

sudo apt-get update 

sudo apt-get install ffmpeg

[josesantiagojr]

ImageMagick and PNG's on Mountain lion

ImageMagick installed with HomeBrew does not include a library to work with .png files. This issue was resolved for me by installing imagemagick with this command: brew install imagemagick -vd Looks strange, but it works.

[josesantiagojr]

Sharing A Devise User Session Across Subdomains With Rails 3

Recently I’ve been working on a Rails application that supports subdomains. I’m using Devise for user authentication and need the user to choose a subdomain to use upon registration.

Similar to the 37signals applications, I want a single sign-on to be persistent across subdomains. Since I didn’t have a clue where to begin with subdomains, I followed this tutorial on my new Rails 3.1 beta 1 application. This tutorial worked like a charm and I omitted the friendly_id and tweaked a few things to my liking.

The gist of it is simple. Create a User model like you would normally do with Devise. You add a Subdomain model that is linked to the Users (in my case I only wanted a single subdomain per user). Configuring the routes is pretty simple as you can simply create a constraint that will match the root and fire it off to the right action and let the rest fall through.

The trick comes into sharing the session between domains. Browsers, of course, will separate out the cookies and store them by separated out by subdomain. What you want to do is edit your config/initializers/session_store.rb file to look like this

APPNAMEGOESHERE::Application.config.session_store :cookie_store, :key => '_tourlyapp_session', :domain => "lvh.me"

The trick here is the :domain option. What this does is sets the level of the TLD (top level domain) and tells Rails how long the domain is. The part you want to watch out for here is that if you set :domain => :all like is recommend in some places, it simply won’t work unless you’re using localhost. :all defaults to a TLD length of 1, which means if you’re testing with Pow (myapp.dev) it won’t work either because that is a TLD of length 2.

You might get weird things like halfway Devise sessions sharing, but only allowing you to create and destroy the session on the root domain. Using :all works great if you’re using localhost, but when I started using lvh.me:3000 for testing I had those problems (lvh.me stands for local vhost me and is a domain that simply points to localhost which makes for zero-config subdomain development. It’s super handy.).

The best option might be to comment out this line and put it into your individual environment configurations. This way you can keep things configured easily as the :all option. Once you’ve got your domain string added everything should work like a charm.

BONUS PROTIP: The normal route variables you see used end with _path. These don’t include the domain and therefore ignore the :subdomain option you pass into them. url_for, on the other hand, does support subdomains so you should get into the habit of using root_url instead of root_path and so on.

[josesantiagojr]

Really simple file uploads with Express

Few days ago I was working on a fairly typical web application and I faced the challenge of implementing a fairly typical web application feature - file uploads. It was the first time I was implementing file uploads with Node (and Express) and I did what anyone else would do - I googled it.

Unfortunately all the articles / posts out there are either outdated, too complex or plain wrong. So I did the next most obvious thing - post a question on the mailing list. As always Mr. Holowaychuk was incredibly quick to respond. His answer lead me to do what I should have done in the first place - read the docs.

The upload form

This is the most obvious part of the challenge. You're probably familiar with this already. Anyway, for the sake of completeness of this article, here it is.

You will need a form in your browser for the file upload. I use Jade to generate my HTML and here how it looks:

form(action="...", method="post", enctype="multipart/form-data")   input(type="file", name="displayImage")

The form.action will point to a route that handles the file upload. More below.

Accessing the uploaded file

If you're using recents versions of Node and Express, file uploads are a piece of cake. And I'll back this claim but before we go any further make sure you're familiar with routes, requests and responses in Express.

Okay, now let's justify the "piece of cake" claim. In our file upload route, the req parameter has req.filesavailable. Here's an example of what the req.files would contain:

{   displayImage: {     size: 11885,     path: '/tmp/1574bb60b4f7e0211fd9ab48f932f3ab',     name: 'avatar.png',     type: 'image/png',     lastModifiedDate: Sun, 05 Feb 2012 05:31:09 GMT,     _writeStream: {       path: '/tmp/1574bb60b4f7e0211fd9ab48f932f3ab',       fd: 14,       writable: false,       flags: 'w',       encoding: 'binary',       mode: 438,       bytesWritten: 11885,       busy: false,       _queue: [],       drainable: true     },     length: [Getter],     filename: [Getter],     mime: [Getter]   } }

In the req.files object above, the property displayImage is the name of the file field in your HTML form andreq.files will contain one property each for every valid HTML file form field.

The file object contains the type, size and name properties for your server side validations.

Saving the uploaded file

Assuming the file is valid, you use the path property for the next step. The path would typically contain a location in the tmp folder. Your application logic could either require you to access the contents of the file or simply move the uploaded file to another location.

fs.readFile(req.files.displayImage.path, function (err, data) {   // ...   var newPath = __dirname + "/uploads/uploadedFileName";   fs.writeFile(newPath, data, function (err) {     res.redirect("back");   }); });

In the fs.readFile callback, we have the data parameter through which we can access the contents of the file. The example above is taken from an application that needed to modify the file and save it in a new location. Thus fs.writeFile is used to write data to the newPath.

If your app needs to simply move the uploaded file without modifying the contents fs.rename can be used as more simpler option.

That's all there is to it. I've done file uploads in many server side languages including Python, Java, Scala and PHP and I don't think its ever been this simple. So much for JavaScript being labeled as an inferior server side language.

[josesantiagojr]

Deploying Node.js With Upstart and Monit

So you like Node.js? You want to deploy it?

If I heard two "Yes"'s, then you are in the some boat as me, and being in that boat feels really really vulnerable. Like the kind of vulnerable you would feel if you were trapped in a cage with lions. And here is why:

If Node.js decides to crash, you are screwed.

If the above isn't enough for you, then you may need to reconsider.

There are two well-known technologies that can save us from this mess, and you'd better believe we're going to use them!

Problems

The first problem we will get thrown by, is the fact that we cannot run Node.js as a daemon. A daemon, for the unaware, is a child process that spawns from a process, leaving the parent to die. Tragic story I know, but this allows things to run in the background. But why is this a problem? Well if Kevin's blog post isn't enough for you, it essentially allows one to separate node from any form of interface, meaning terminal doesn't have stay open all day. I highly recommend you pause now and read Kevin's material, as it will expand more on daemonizing the node process.

upstart

As Kevin stated in his blog, the first tool we are going to look at is upstart, which will allow us to:

Run Node.js as a daemon

Provide an easy set of commands for stop / starting our Node.js application

Most linux distributions that have a decent package manager which will allow you to install upstart the easy way. On debian systems this is usually:

#!sh sudo apt-get install upstart

If you're running the latest Ubuntu, you've got it built in already.

Otherwise you will need to configure and compile from source, and this blog post will not go off topic! So we resume...

We now will want to configure upstart, and I am shamelessly borrowing Kevin's example:

#!upstart description "node.js server" author      "joe" start on startup stop on shutdown script     export HOME="/root"     echo $$ > /var/run/yourprogram.pid     exec sudo -u username /usr/local/bin/node /where/yourprogram.js >> /var/log/yourprogram.sys.log 2>&1 end script pre-start script     # Date format same as (new Date()).toISOString() for consistency     echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Starting" >> /var/log/yourprogram.sys.log end script pre-stop script     rm /var/run/yourprogram.pid     echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Stopping" >> /var/log/yourprogram.sys.log end script

You will need to replace username with the user you want to run node as, /where/yourprogram.js with the location of your application, /var/run/yourprogram.pid with your program's pid file and/var/log/yourprogram.sys.log with the location of your log file. You can then save this file to/etc/init/yourprogram.conf for later use. (Dont't forget to make it executable!) If you are using an older linux distribution, you may need to save the file to /etc/event.d/yourprogram

Using your program is now a cinch:

#!sh start yourprogram stop yourprogram

And now node will automatically start at boot and log output to /var/log/node.log. But I assumed you read all that on Kevin's blog, right? Moving on...

The real problem

Turning your application into a daemon isn't enough. A daemon can still crash, and those lions are getting awfully close. We need a tool that keeps an eye out for any falls our node instances may have. When something crashes our server, we need that tool to take evasive action. Also that tool should be capable of expanding its reach to any other services our app may need; such as databases and nginx instances. Thankfully this isn't taken lightly by most, and several helpful tools that fit our description do exist.

monit

Now that we have our application in a easy to manage form, we need to look at the real issue we are facing. What happens when Node.js crashes? Fortunately for us mortals someone has done most of the hard work for us, and blessed us with the monit utility. Essentially monit is a monitoring tool, which you configure tests that will be evaluated at certain intervals. If one of the tests fails, then it will take action depending on the rules you assign to it.

I'm not going to tell you how to install it, their website has plenty on information for that, but here instead is an example config file designed for our upstart node daemon will made earlier:

#!monit set logfile /var/log/monit.log check process nodejs with pidfile "/var/run/yourprogram.pid"     start program = "/sbin/start yourprogram"     stop program  = "/sbin/stop yourprogram"     if failed port 8000 protocol HTTP         request /         with timeout 10 seconds         then restart

You can save this in /etc/monit/monitrc. Here is the break down:

set logfile /var/log/monit.log check process nodejs with pidfile "/var/run/yourprogram.pid"

This will tell monit to log all output to /var/log/monit.log, and it also gives our node instance a name and location. I am assuming monit will be running on the same machine as your node app, so we will need to listen on 127.0.0.1 . If you wanted to run monit on another box, you most certainly can, in fact I recommend have multiple instances of monit running in different locations. You just have to ensure that monit is listening on the correct IP address, otherwise monit is rendered useless. The next part is the vital part, which defines how we will test for failures:

#!monit start program = "/sbin/start yourprogram" stop program  = "/sbin/stop yourprogram" if failed port 8000 protocol HTTP     request /     with timeout 10 seconds     then restart

The first two lines should be self-explanatory, this defines how monit will start and stop your application. You will need to specify an absolute path to upstart's start and stop utilities, while suffixing your application name as an argument.

The third line is the crux of monit's usefulness. If we were running our application on port 8000, serving through the HTTP protocol, then this would apply. Monit will perform an analysis on the specified port and protocol, and if its routines discover that something is not right, it will execute the next few lines. Monit has lots of different options for dealing with service failures, such as sending e-mails and restarting servers. In this case we are going to do a simple request to the root of the local domain, and if 10 seconds pass without the expected response, monit will restart the application.

Now all that is left, is to start your application, then set monit off to do its tedious task of saving the world from crashing servers.

#!monit sudo start yourprogram monit -d 60 -c /etc/monit/monitrc

Setting the -d 60 flag tells monit to check against your configuration every 60 seconds. I recommend setting this to the same time as any response timeouts you may have installed. You have now passed monit 101! Easy, huh?

Monit's useful-ness doesn't hit a brick wall there either, monit can be extended further to monitor the other services your web application relies upon. This may range from databases to nginx instances. Their website has many more examples and configurations, and even more again can be found littered over the internet.

[josesantiagojr]

Ruby 1.9.3 + Rails 3.2.3, Fresh Ubuntu 12.04, Issues via RVM

I recently completed Michael Hartl’s excellent online book; a Ruby on Rails tutorial that allows you to learn via doing. I told one of my mates about it and convinced him to do the same.

I use OSX, so everything worked swimmingly for me. Unfortunately, I had a really tough time helping my mate deploy ruby and rails to a fresh Ubuntu installation, so I sent him on his way to try again another time.

Firing up a Virtual Machine later in the evening (ie now, whilst I’m typing this), I actually received the same issues as I did on his laptop – this was a fresh Ubuntu 12.04 LTS install!

And so, with that in mind, I sought to resolve the issue. If you’re also experiencing issues with zlib, openssl or other missing packages, here is my winning formula!

First, I imploded my existing RVM install, this gave me a fresh start rvm implode

I installed RVM (make sure you have git-core and curl installed before you do this [use apt-get]) curl -L get.rvm.io | bash -s stable and thensource ~/.rvm/scripts/rvm based on instructions at rvm.io

I installed zlib manually via rvm  rvm pkg install zlib

I installed openssl manually via rvm  rvm pkg install openssl

I installed ruby with the following args rvm reinstall 1.9.3 --with-openssl-dir=$rvm_path/usr

I installed some additional packages  sudo apt-get install libxslt-dev libxml2-dev libsqlite3-dev as per Michael’s recommendation

I installed rails gem install rails -v 3.2.3

Hopefully that helps you as well!

Final thought: I wasn’t able to run rails server for my test app on this fresh install either; by default there isn’t a javascript runtime. I installed nodejs.

https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager

sudo apt-get install python-software-properties sudo add-apt-repository ppa:chris-lea/node.js sudo apt-get update sudo apt-get install nodejs npm

[josesantiagojr]

How to install Ruby 1.9.2 and Rails via RVM and Homebrew on a fresh OS X 10.8 Mountain Lion Install

Hello again!

This is more for my own knowledge than anything, but I figured others may be able to use it as well.

This post assumes you already have Homebrew and RVM installed (RVM has a native OS X GUI tool as well that can install RVM for you, and it can make things easier for those that are not so comfortable with the Terminal, called JewelryBox).

Once these two things are installed, we're ready to move forward.

Some people may encounter issues with improper permissions and ownership on the /usr/local/include and /usr/local/lib directories when using Homebrew. To fix this, you can execute the following exactly as it is (DON'T replace $USER with anything):

sudo chgrp wheel /usr/local/

sudo chown -R $USER /usr/local/

As of Xcode 4.2, gcc is no longer installed, but it is required for compiling ruby when installing via RVM. As of Xcode 4.4 (released alongside Mountain Lion), UNIX command line tools are no longer installed with Xcode by default either. To remedy this, open Xcode, go to the Preferences Menu, click the Downloads tab, and press the Install button for the "Command Line Tools" item in the list. Any other option in the list is totally up to you to decide if you'd like to install it or not. (Screenshot below shows where the menu, tab, and button are.)

Next, according to Homebrew's own wiki, you'll need to install a binary gcc 4.2 formula made available via Homebrew-dupes by running the following:

brew install https://raw.github.com/Homebrew/homebrew-dupes/master/apple-gcc42.rb

Now you can install Ruby 1.9.2 via RVM:

rvm install 1.9.2

Make Ruby 1.9.2 your system default (optional):

rvm use 1.9.2 --default

Install the latest version of the Rails (Rails 3.2.7 at this time) and bundler gems:

RAILS:

A.) gem install rails

(or if you prefer without the docs to save some time do this instead):

B.) gem install rails --no-rdoc --no-ri

BUNDLER:

gem install bundler

Voila, ready to go! The only thing left is to install the gem of your choice for database usage.

[josesantiagojr]

Remember to secure your server!

The one thing people always seem to overlook, but should be the first thing anyone should do when setting up a new server is configure their firewall.

Ubuntu 10.10 comes bundled with UFW (Uncomplicated Firewall), which is a terminal-based firewall application. To manage the firewall and its configuration, you'll need to understand a few basic terminal commands. However, if your server is also a development or personal machine with a Desktop GUI installed, like GNOME, the alternative (and my personal choice in that situation) is to manage the firewall using a graphical interface. You can do so by installing Gufw (Graphical Uncomplicated Firewall). Installation can be done the usual way with:

     sudo apt-get install gufw

NOTE: When installing Gufw, UFW is not enabled by default. You must explicitly enable it through the graphical control interface.

The graphical interface can be accessed by going to System -> Administration -> Firewall Configuration. From there, enable the firewall by checking the box labeled "Enabled", under the "Actual Status" title, and adding/removing an exception to the firewall rules is pretty straight forward. It even provides you with presets when adding a new rule for common services, such as Samba, NFS, HTTP, FTP, SSH, VPN, etc.

Testing the Firewall

To test the firewall, you have two options:

You can utilize a popular application called nmap. This is best done from a second linux-based machine.

You can take advantage of online firewall testing services, such as https://www.securitymetrics.com/portscan.adp

If you choose to use nmap, installation on Ubuntu is straightforward with the command:

     sudo apt-get install nmap

Run nmap with the following command to view a list of currently open ports (view nmap's options summary):

     nmap -vAPN 192.168.1.100

NOTE: Substitute 192.168.1.100 with the IP address of your server

Reference:  The Official Ubuntu Documentation