Sunday, January 26, 2014

Gradle installation and example / tutorial for Linux (Fedora 20)

When I wanted to re-learn Ant, I found Maven. When I found Maven, I found out about Gradle being better than Maven. And indeed it did seem to be so.
The Gradle build script appeared a lot shorter and more powerful than Maven. There is also a more feature-rich C++ version for Gradle coming up and a demo and cpp plugin already available.

This is intended to be a simple tutorial for Gradle. Recording my path in learning the what and why of Gradle.

To give it a shot, download the Gradle binaries, extract them into /usr/local/ with sudo unzip gradle-1.10-bin.zip.

To run Gradle, you have to add the path of the Gradle bin folder to PATH. So do this:

sudo vim ~/.bash_profile

Add the path this way in .bash_profile

 PATH=$PATH:$HOME/.local/bin:$HOME/bin:/usr/local/gradle-1.10/bin

Save, exit and type source ~/.bash_profile to incorporate the changes immediately.

Type gradle -v and you'll see the Gradle version, build time, build number etc. Congratulations.

To try out Gradle, create a file named build.gradle file in any directory you like and as the Gradle documentation says, paste the following content in it:

task hello {
    doLast {
        println 'Hello world!'
    }
}

Save, exit and then type gradle hello for the script to execute (gradle.build isn't exactly a build script. It's a build configuration script; which means that it's a script we write, which internally creates the necessary build script automatically. Saves us a lot of trouble, really!)

Now that you know Gradle works, you have to understand that Gradle thinks in terms of high-level tasks. You have to learn the syntax of writing tasks.

Type gradle tasks at the terminal (in some other directory which does not have a build.gradle file in it) to see the list of tasks that gradle supports by default. You'll see something like this:

All tasks runnable from root project
------------------------------------------------------------

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
dependencies - Displays all dependencies declared in root project 'navin'.
dependencyInsight - Displays the insight into a specific dependency in root project 'navin'.
help - Displays a help message
projects - Displays the sub-projects of root project 'navin'.
properties - Displays the properties of root project 'navin'.
tasks - Displays the tasks runnable from root project 'navin'.

To see all tasks and more detail, run with --all.

BUILD SUCCESSFUL

Total time: 3.327 secs
This means that similar to how you had defined a "hello" task above, Gradle already has such tasks named dependencies, help, properties etc., already defined somewhere. To see proof of it, type gradle help and see the result. These tasks are already part of Gradle by default. That's why you didn't need a build.gradle file.

Now go back to the directory where you created the build.gradle file. Now type gradle tasks and you'll see a similar output as above, with the additional display of "hello" as a task. Which means that in this directory if you type gradle hello, the hello task will be executed.

Gradle encourages convention over configuration, so it'll be easier for us to create a new project with the following directory structure:

src/main/java  for production Java source
src/main/resources for production resources
src/test/java for test Java source
src/test/resources for test resources
src/sourceSet/java for java source for the given source set
src/sourceSet/resources for resources for the given source set

Create a simple java class inside src/main/java, named Main.java with the following contents.
public class Main
{
    public static void main(String[] args)
    {
        System.out.println("in main");
    }//main
 }//Main class

Go back to the folder where your build.gradle file is. Now to be able to build a Java project, you haven't created any tasks. Thankfully, Gradle comes with a plugin which has the necessary tasks for building a Java project, predefined. Open your build.gradle file and add this line as the fist line of the file: 

apply plugin: 'java'


Save and exit and type gradle tasks. Now you'll see a lot more tasks listed. Running the gradle build command will automatically find your Main.java file, create a build directory for it, place the ".class" file there and will also create a jar file for you in build/libs.

Now if you try to run the jar file with java -jar jarname.jar, it won't execute because you didn't specify the application entry point in manifest.mf.

So now open your build.gradle file and add the following info to it:


apply plugin: 'java'

jar {
    manifest {
        attributes(
            "Implementation-Title": "Tutorial",
            "Implementation-Version": 1.0,
            "Main-Class": "Main"
            )
    }
}
Now executing the gradle build command will create the manifest file and you'll be able to execute the jar. Similar to make files in C and C++, you can run a clean command with gradle clean and the build directory will get cleared.


Gradle can  automatically create Eclipse project files for you. Just add to your build.gradle, the following line 
apply plugin: 'eclipse'
Type gradle tasks and see a new set of tasks you've got.

Now type gradle eclipse and when you type ls -altr you'll see the Eclipse project files have been generated. Open Eclipse, go to File > Import > General > Existing projects into workspace and you'll be able to use this newly created Eclipse project.













Learn to use a mouse with your other hand

If you're working a lot on the computer, wrist discomfort is a sign that you should be taking rest more often. If you still have to work, and you're sure the discomfort is because of using the mouse, then do consider this:

Learn to use the mouse with your other hand. Switching hands this way gives your overworked wrist the rest it needs. I started doing it and it really helped. It'll take a couple of weeks of practice to get used to it, but it'll help a lot. Do give it a shot!

Installing Jenkins on Fedora 20

Typing sudo yum install jenkins strangely didn't work (even though it was on the Jenkins website). It's then I realized that what they showed on the website was a three step process and not options to choose from. The first two steps are meant to do the initial setup necessary for downloading jenkins. So this is what you do:

Type:
sudo wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat/jenkins.repo
sudo rpm --import http://pkg.jenkins-ci.org/redhat/jenkins-ci.org.key
sudo yum install jenkins

Once that's done, use the following for their obvious functions:
sudo service jenkins start
sudo service jenkins stop
sudo service jenkins restart 

So  start Jenkins, open a browser and type "localhost:8080" in the address bar. You'll see the Jenkins page. The default port used by Jenkins is 8080. 

_______________________________________


Bonus info

You can create aliases for Jenkins in bashrc so you won't have to type those long commands again.
Open up bashrc with 

vi ~/.bashrc

and type in these lines into it.

alias startjen='sudo service jenkins start'
alias stopjen='sudo service jenkins stop'
alias rejen='sudo service jenkins restart'

Save and exit by pressing. (Make sure you type capital Z's).

Escape key and ZZ

Type this at the command prompt to activate the aliases you just created

source ~/.bashrc

The feel of Linux UI vs Windows UI vs Mac UI vs the ideal UI

I've worked on all three OS'es, and it's just a personal opinion that the UI I've loved the most is that of Windows XP.

People who haven't had the chance to venture into the field of interaction design would usually not mind this aspect, but after having had internationally acclaimed interaction designers as my bosses for two years, I've developed a similar gut -feel for quality that they have.

A product has to look and feel right. It has to have an emotional value that appeals to a certain kind of user.

The Windows XP UI has a nimble, crisp, efficient feel to it. Especially after you disable the special animations and effects in the performance settings. The 'click' sound played on every folder click adds to the experience. It just feels right. Feels comfortable to work on (except maybe for the way the taskbar tab flashes in orange :-) ). The UI responds promptly to clicks and key-presses. A good operating system for a new person entering the world of computers.

The Linux UI has a lot of visible effort put into creating it. With distros like Fedora and Ubuntu opting for a minimalist design, the UI has become less usable for a person already accustomed to an OS like Windows. Much less usable for a person with no experience with computers. The UI feels cumbersome to use. It's not as responsive to clicks as Windows XP, and some operations are just un-intuitive. Eg: If a Firefox window is open and you click the Firefox icon again, it doesn't open another window. Right clicking on the file-browser does not produce the option for creating a new text file. Clicking the shutdown button shows options to shutdown, but no logout button (you have to click the user icon to see the logout button). 
But then again, Linux was not really meant to have a lovely UI (although I wish they'd make it like Windows XP). It's power comes from the commandline, and that's what programmers love about it! In terms of the commandline and security, Linux beats Windows hands-down any day. As a programmer, this is the reason I like Linux.

The Mac UI, although pretty much like Linux, has a kind of a sticky, dragging feel to it (as compared to the crisp feel of XP). I was using a G4. It's a combined effect of the hardware and the software that produces this feel. In terms of intuitiveness, the Mac was good. I just loved the fact that to remove a program, I could just delete the folder instead of being like the add and remove programs of Windows or the uninstall techniques of Linux. The animations and sounds were un-intrusive and pleasant. 

The Ideal UI though, as just a figment of my imagination, would be part of a machine that can read the mind of a living being (note that I didn't mention it as 'human'). It would be a machine we wouldn't have to talk to, for it to understand exactly what task we want to accomplish. It would not be made of metal or plastic or any material which would incorporate delays in input/response. It would give us the perfect aesthetic and emotional feel customized to our personality and interface needs. Such a technology may be very far away in the future, but I'm predicting it now because I do believe it can be a reality.

Until then, back I go to working on my hobby project for which I'm trying to design an intuitive UI.

Saturday, January 18, 2014

Installing Adobe Flash on Fedora 20

Numerous people including me have been at a loss when we tried installing Adobe Flash on or Fedora installations and it never worked!
Finally, I found that there is a solution that works:
 
sudo yum install flash-plugin nspluginwrapper alsa-plugins-pulseaudio libcurl
 
Enjoy! :)

Installing Net-SNMP and SNMPTT in Fedora 20

Documenting this on-the-fly for my reference and anyone else who would find it useful.

After freshly installing Fedora 20, I was perplexed to find that it didn't have gcc or g++ installed. So step 1 is to get them. (You don't really have to use sudo in all steps below)

sudo yum install gcc 

sudo yum install gcc-c++

You can also optionally install mysql (if you wish to have MYSQL Trap Logging) like so:

sudo yum install mysql
sudo yum install mysql-server
sudo yum install mysql-devel
sudo chgrp -R mysql /var/lib/mysql
sudo chmod -R 770 /var/lib/mysql
sudo service mysqld start 


Also ensure Perl and a supporting module is installed:

sudo yum install perl

(you might be able to install all supporting modules for Perl like this: "sudo yum install perl-*", do give it a shot. It'll be a larger download though)

You'll need two ExtUtils of Perl which you can either install separately like this:

sudo yum install perl-ExtUtils-MakeMaker
sudo yum install perl-ExtUtils-Embed

or install everything in one go like so:

sudo yum install perl-ExtUtils-*

For running snmptt, you'll also need:

sudo yum install perl-Config-*
 
 

Then download Net-SNMP, and extract it into your /usr/local/ folder with:

sudo tar -xvzf net-snmp-5.7.2.tar.gz.

Navigate into the newly created net-snmp directory and type:


sudo ./configure --enable-embedded-perl --enable-shared --with-mysql

Or if you don't want embedded perl, type (you'll need to install with embedded perl for this tutorial):

sudo ./configure --with-perl-modules --with-mysql

You'll be given a lot of options. Just keep pressing enter for all of them (unless you want to configure it differently).
Once configuration is done, type:

sudo make -j 4

The -j 4 is to tell make that it can use the four cores of my processor. It works faster this way, by dividing the make process into separate jobs which complete parallelly. You can also simply type "sudo make". At any point if you want to redo the make process, type "sudo make clean" and you'll be able to start from the configure step again.


Now you can optionally start "make test" which is not really required, but it is what helped me find out that I didn't have ExtUtils-MakeMaker installed. I wasn't able to make install without it, and the net-snmp mailing list was unable to figure it out either. I updated the mailing list with the solution when I found it.

sudo make test
sudo make install 

...and tadaah! You now have net-snmp installed!
The snmptrapd file which snmptt requires, you'll now find installed in /usr/local/sbin/snmptrapd

To be able to start and stop snmptrapd, a script is also included.
sudo cp /usr/local/net-snmp-5.7.2/dist/snmptrapd-init.d /etc/rc.d/init.d/snmptrapd

You can optionally use the above script to start snmptrapd with the command "sudo service snmptrapd start"or "snmptrapd -On"



------------------------------------

Now for snmptt:

Extract the snmptt tar file into /usr/local/ using:

sudo tar -xvzf snmptt_1.4.tgz

Navigate into the newly created snmptt_1.4 directory and create a file named snmptrapd.conf:

sudo vim snmptrapd.conf



To test out snmptrapd, add the line "disableAuthorization yes" to the snmptrapd.conf file (remove this line later for proper authorizations) and type the following command at the terminal:

sudo /usr/local/sbin/snmptrapd -f -Lo -c /usr/local/snmptt_1.4/snmptrapd.conf

snmptrapd will start and will keep listening for traps.
Meanwhile, download and start a MIB browser like the one iReasoning has.
Go to Tools > Trap sender in the MIB browser and type the address to send traps to, as "localhost" (without the quotes). Then click the "Send Trap" and immediately, you'll see the trap being received at the terminal where you started snmptrapd.


You have the choice of installing snmptt as a standard handler or as an embedded handler. I'd recommend installing as the embedded handler, because it is loaded when snmptrapd is started, so it won't need a process to be created everytime a trap is received (which is what happens with the standard handler). Type the following commands:

sudo cp snmptt /usr/sbin 
sudo chmod +x /usr/sbin/snmptt
sudo cp snmptthandler-embedded /usr/sbin/
sudo mkdir /etc/snmp/
sudo cp snmptt.ini /etc/snmp/ (you can change settings in this file)

sudo cp examples/snmptt.conf.generic /etc/snmp/snmptt.conf
sudo mkdir /var/log/snmptt/

Open the snmptrapd.conf file and add the following line to it "perl do "/usr/sbin/snmptthandler-embedded";"

sudo mkdir /var/spool/snmptt

sudo cp snmptt-init.d /etc/rc.d/init.d/snmptt (this is a script that can be used to start and stop snmptt)

and now add snmptt as a service:
sudo chkconfig --add snmptt

Configure snmptt to start at runlevel 2345
sudo chkconfig --level 2345 snmptt on

The above command will start snmptt automatically on reboot. You can also start it right now using:

sudo service snmptt start

To stop it, use:
 
sudo service snmptt stop


Copy a script to rotate log files:
sudo cp snmptt.logrotate /etc/logrotate.d/snmptt (you can edit this file if you wish)