The pi-web-agent

Remember the Hackmanchester winning project pi-web-agent? Well, we released the first version of the pi-web-agent in the pistore. Here is the wiki page of the project as generated and exported from our github repository

pi-web-agent

The pi-web-agent is a web application that aims to provide a more user friendly way of interacting with the Raspberry Pi and performing basic tasks by eliminating the need of using the command line directly.

How to use

After starting the pi-web-agent service by executing run.sh or sudo /etc/init.d/pi-web-agent start , you can access the application with your browser via either https://raspberrypi:8003 or https://ip_address_of_your_pi:8003 if your internet router does not resolve hostnames to IPs. To access the application inside your Pi just access the local host without https: http://127.0.0.1:8004

Provided functionalities

The web application currently provides the following functionalities:

• Firewall management by controlling the iptables.
• A package management system for installing useful applications easily.
• Service management for starting or stopping services
• Update management for updating the underlying Linux distribution with a simple click
• GPIO management for controlling the pins on the Raspberry Pi (special thanks to the author of wiringPi for his excellent open source program)
• General purpose information of the system (memory usage, disk capacity, ip, cronjobs, swap usage)
• Tightvnc is provided, by setting up a vncboot service and enabling users to use tightvnc java applet to access the system by the tightvnc viewer (special thanks to tightvnc for their open source tightvnc client)
• Power management for rebooting or powering off the system with a simple click

Firewall management

Currently the Firewall management section displays the current state of the iptables. Enabling input for altering the iptables state is under development

Package management

The package management provides a list with useful packages and a short description. You can request an uninstall or install of the application by simply clicking on the switch button.

Service management

Service management allows you to stop or start services. Only services with known state are shown.

Update management

The update management aims to arrange or the hassle about updates for you. It takes care of checking for updates and notifies you on the live information feed. The update section also provides information of weather there is an update or not and if yes, it provides a list of packages with there description that need update. The update can be initiated with a simple click of a button at the end of that list.

GPIO management

The GPIO management provides access to the General Purpose Input Output pins on the Raspberry Pi. You can convert a pin to input or output and activate outputs. Currently only GPIO0-GPIO7 pins are available. The solution is under development to provide more functionality on the second release.

VNC

VNC is very important because most users want to access their pi from their laptop and have an image of the desktop in their screen. That's why the application has the tightvnc server as a dependency and provides the tightvnc client java applet. The whole vnc solution is pre-setup and only clicking at the vnc section should work. The tightvnc service on the RPi should be started manually because you need to setup a password.

Requirements

Currently the web application agent supports the Raspberry Pi with Raspbian installed. Any debian based Linux distribution should also work but is not thoroughly tested yet.

Authors

Vasilis Nicolaou, Angelos Georgiadis, Georgios Chairepetis, Kyriacos Georgiou and Maria Charalambous

License

GPLv2. Imported projects have their own license.

Developer information

Please consult the README file in order to setup an environment for testing purposes of the application. Note that architecture specific code won't work (just the GPIO for the moment). The application is based on the micro-CernVM web appliance agent developed at CERN by Vasilis Nicolaou and documentation section contains documents for that web application but are highly relevant to the forked version (the pi-web-agent)

Documentation

Report (only relevant information of the web application, ignore update management section)

Presentation (first 9 slides)

Follow usr/share/pi-web-agent/doc for documentation on key python modules.

Last edited by vaslabs, 7 days ago

A Dropbox client for the raspberryPI

Overview

Raspybox is a minimalistic but powerful dropbox client written in python for the RaspberryPI.

How to use it

There are three forms that the program can be executed. The simplest is the graphical way. First you have to execute raspberryDropy.py and type login. Follow the instructions and when you finish press ctrl+D to exit. Now you can use it in any of the three forms.

Setting things up

You need to install the dropbox sdk for python (which can be found in dropbox developer page) and create your own app. Download all the files from the file directory of this project and place them in a directory. Create an app for the whole dropbox and copy paste the keys in raspberryDropy.py accordingly.

User Interfece

To execute the user interface simply type ./raspberryDropy_gui.py . The user interface should come up after a few seconds.
You can also use some shortcuts instead of the menu:
For upload press insert key.
For delete press delete key.
To refresh press F5
To navigate through your directories use the arrow keys and enter or double mouse click to either enter a directory or download a file.
There will be some messages in the console, don't worry about them. If the program crashes send the output as a bug report to the developer. This is because it is the initial version, so it might have some serious bugs.

Dropbox command line

You can also execute the raspberryDropy.py and use the dropbox from the command line. Type help to view the necessary commands.

Alternative command line

Because the RaspberryPI is very useful when using scripts and command line fire and forget programs such a functionality is supported. Instead of running ./raspberryDropy.py to access command line, you can supply a dropbox command as argument. Then the program will start-up execute the command, display the output and die. Be ware that the cache can't work on such situations. You can modify it to keep a cache on a file instead of the memory or use your own in your script.
This part however needs further development and consideration, so the command line can be used efficiently and fast enough (for example it makes no sense to run a command for changing directory, it will be of no use for this purpose)

Contribution

Currently the code is not very well commented, but it should not be very difficult to understand it, since it's a small program. However, a commenting will be done soon, I hope. If you want to contribute to this program, please send a request.

Download

Currently, the target groups are developers, testers and PI hobbyists, but anyone can have a go with it.
You can find everything here:   http://sourceforge.net/p/raspybox/wiki/Home/

Finding probabilities for RISK

During holidays we find ourselves playing board games. One of the best out there is RISK. During game-play, one might wonder what are the probabilities for each battle scenario. Moreover, if that someone is, well, a geek, he might write a program during game-play to support his army with a little of, em, technology.
So, do we know an equation to find those probabilities? No. Probably we'll find one with a little google search, but why not study it using a more programming method? We have the technology, we know a little bit of programming, so, let's take our chances.

1. import java.util.Arrays;
2. public class RiskProbability
3. {
4. private static int[] diceThrow(int n)
5. {
6. int[] dice = new int[n];
7. for (int i = 0; i < dice.length; i++)
8. dice[i] = (int)(Math.random()*6) + 1;
9. Arrays.sort(dice);
10. return dice;
11. }
12. public enum winner {ATTACKER, DEFENDER, TIE};
13. private static winner battle(int a, int d)
14. {
15. int[] attacker = diceThrow(a);
16. int[] defender = diceThrow(d);
17. int aSoldiersLost=0;
18. int dSoldiersLost=0; 
19. int j=defender.length - 1;
20. for (int i = attacker.length - 1; i >= 0 && j >= 0 ; i--)
21. {
22. if (attacker[i] > defender[j--])
23. dSoldiersLost++;
24. else
25. aSoldiersLost++;
26. }
27. if (aSoldiersLost > dSoldiersLost)
28. return winner.DEFENDER;
29. else if (dSoldiersLost > aSoldiersLost)
30. return winner.ATTACKER;
31. else
32. return winner.TIE;
33. } 
34. public static void main(String[] args)
35. {
36. int experimentSize = Integer.parseInt(args[0]);
37. int attWins = 0, defWins = 0, ties = 0;
38. int attStyle = Integer.parseInt(args[1]);
39. int defStyle = Integer.parseInt(args[2]);
40. for (int ex = 1; ex <= experimentSize; ex++)
41. {
42. winner w = battle(attStyle, defStyle);
43. switch (w)
44. {
45. case ATTACKER: attWins++; break;
46. case DEFENDER: defWins++; break;
47. case TIE: ties++; break;
48. default: break;
49. }//switch
50. }
51. System.out.println("Experiment is with " + attStyle + " attackers and " + defStyle + " 
52. defenders " + experimentSize + " times");
53. System.out.println((attWins/(double)experimentSize) + " attackers");
54. System.out.println((defWins/(double)experimentSize) + " defenders");
55. System.out.println((ties/(double)experimentSize) + " ties");
56. }//main
57. }

Let's explain the code a bit.
Lines 4-11 is the definition of a throw dice function. You specify the number of dice to throw, and a sorted array of the values of each die is returned. Watch out because the dice are sorted in ascending order.

Line 12 is an enumeration to be used for specifying the winner.
Line 13 is the definition of the battle function that takes two arguments, the number of dice the attacker will use and those of the defender as a second argument. Then the diceThrow is called and the battle begins on lines 20-26 until one runs out of dice.
Line 34 is the main method where the battle is initiated for 'experimentSize' number of times using the specified number of dice for each player.
To run this properly you have to pass 3 integer arguments, the experiment size (1000000 should be more than enough), the number of dice of the attacker and the number of dice of the defender. These are the results obtained by using the above program:

$ java RiskProbability 1000000 3 2
Experiment is with 3 attackers and 2 defenders 1000000 times
0.371734 attackers
0.291923 defenders
0.336343 ties

java RiskProbability 1000000 2 2
Experiment is with 2 attackers and 2 defenders 1000000 times
0.227412 attackers
0.448301 defenders
0.324287 ties

$ java RiskProbability 1000000 3 1
Experiment is with 3 attackers and 1 defenders 1000000 times
0.66038 attackers
0.33962 defenders
0.0 ties

$ java RiskProbability 1000000 2 1
Experiment is with 2 attackers and 1 defenders 1000000 times
0.578971 attackers
0.421029 defenders
0.0 ties

$ java RiskProbability 1000000 1 1
Experiment is with 1 attackers and 1 defenders 1000000 times
0.416221 attackers
0.583779 defenders
0.0 ties

$ java RiskProbability 1000000 1 2
Experiment is with 1 attackers and 2 defenders 1000000 times
0.25389 attackers
0.74611 defenders
0.0 ties

So, the next time you'll play RISK, you'll know.

 

Linux: The power of Open Source

Everyone that had a go with Linux, has an idea of what Open Source Software means. For those who don't, open source means that the code of the programming language that the software is written and in general the pre-compiled units of it are available to the public.
This gives a lot of advantages. Many programmers can contribute to the code or users that know a couple of things in programming can modify a piece of code and re-compile it to cover their needs and then maybe share it with others that have the same needs. That's how every open source community has been working so far.
We've all heard about it, but few of us have seen it. How do we modify the code? How do we find it? There are a lot of possibilities and options here. For example, most recent programs for Ubuntu are written in Python (e.g. Gwibber). In those programs it won't be difficult to find the code, since Python is not compiled but it's an interpreter based environment. In other words, you can see the code if you open the program with a text editor.

Let's see the real stuff now with an example. We came along the program "fortune" recently and tried to run fortune -f in Fedora, which displays the files that fortune looks at to generate a fortune cookie. We wanted to pass the output data through pipe but it didn't work:
fortune -f | grep humour
After a couple of failures, we assumed that the output was redirected to STDERR instead of STDOUT. But, this is unacceptable code practice. Why send data that are normal output to the error stream? So we downloaded the fortune source rpm package. Here is the process that followed:

• Find the repository of the fedora-mod.rpm, google is your friend.
• Find the source code which is in form fortune-mod.src.rpm
  Create a folder in your home directory (/home/username/) named rpmbuild and inside it a directory named SOURCES 
• Install developer tools and recode-devel: sudo yum install @development-tools recode-devel
• Extract the rpm in the /home/username/SOURCE/ directory.
• Modify the code, in that case we found fortune.c and changed in the function print_list() every fprintf(stderr... to fprintf(stdout... (yes it was that simple)
• To compile it and pack it run rpmbuild -ba fortune-mod.spec.

You can find the rpm now in the rpmbuild/RPMS directory from where you can install it but first run yum remove fortune-mod if you already have it install in your machine.


We've found the source from here

Android presentation

Download the android presentation (08/10/2012- Man-UP) from here.

jlab : Your own Java Testing Lab by VasLabs for you!

What is the way of programming big programs? You create object classes and test them individually. You configure them to work as you want and then you put them together to form a nice new shiny program.
Most of the programmers use IDE's to do that. However, if you are a hardcore of the kind, you may wish to create your own environment just as how you like it to be.
VasLabs has created a small script to give you ideas and/or help you start building your own lab environment to do what everyone does in labs; tests!
The philosophy behind it is that for every object class you get a test class. And for every test you do, you can view a log file containing the results. Then you can compare it with the expected results by reading it or using cmp, or even better, you could initially create a file that contains the expected results and then use jlab to run the test by comparing for you both results.
The program works on your current directory. I.e. you should change directory to the directory you want to build your lab and then run jlab.
Here is the manual of the program (you can also view it by running jlab without arguments):

To use this program use the format jlab --argument [file]
-----------------------------------
The list of available arguments are:
--initialise
Initialises your lab environment in your current directory creating the appropriate folders

--create [file1 ... fileN]
Creates the given class names and puts them in the src directory. It also opens them using gedit

--create_tests
Creates a test class for each class in the src directory. It then opens them with gedit

--compile
Compiles every src file in all directories and puts the .class files in the bin directory

--run_tests
Runs all tests and puts the results in log files. Then it opens the log files with gedit

--test file expectedResults
Runs the given test file and compares its results with the given expectedResults file. If there is a difference it opens the results with gedit

Requires: gedit text editor

Author: Vasilis Nicolaou
Distributed by: vaslabs
User Agreement:
This script shall be used with care by people who know what they are doing. This program intends to help building a java lab. By java lab
we mean a virtual environment that behaves like IDE with the difference that offers simple functionalities for testing java object classes.
The author has no responsibility for any loss of data or damage caused by using this script.
You can edit and re-distribute this script as you wish. If you do not agree delete this script file from you computer.

Tip: You can create aliases for every different functionality and put it in .my_bashrc
08/01/2012

Using this idea you can build a similar lab for every language or facility you want.
Download it from here.
This is written in bash, and therefore can be run only on Unix based OS which have bash installed.
By VasLabs

The great convert tool of ImageMagick

It's of those days where you are just wondering why you are failing to program as usual. Your mind is sleepy, your thinking slow. While drinking a cup of coffee in order to awake your brain (even if you know that in such situations coffee just fails) you listen something not so important (as most things sound at the beginning). "I have a large pdf file how do I reduce its size?".
(I want to inform you now that this article is not about pdf resizing).
Then, as the coffee sinks in, along with this words, there is another question on the horizon. Can you reduce anything without losing something? Of course not. Anyway, that's not my point.

I decided to try and find how to do that, with linux, using scripts. After a couple of google searches I found ghostscript. It was quite a fail, since the pdf was at its minimum size that ghostscript could convert, so it made it bigger.

Then, I looked at my pictures. I always do this when I fail to find a solution for something. Great images, with high resolution. Hang on! What about making every pdf page as a jpg file and then reducing the resolution of those images, and after that putting all these images back as pdf pages?

If you have the knowledge of a normal user this could mean hours of work, especially if pdf has 100 pages. Imagine having at the end another bigger pdf file.

So, I realised that it was a lot of work. What about using a script to do that? Here it comes the convert of ImageMagick!

I might failed to find an optimised solution for the pdf problem, but I've found a great tool! Convert is a terminal program created by ImageMagick that can convert any image file into another by user's will. In addition, it is open source, written in C.

You can reduce your size of your images, transform them, skew them, flip them, change colours with mapping and more more advance image things! It's like having photoshop in a small program, without the heavy brashes and tools. Type the commands, you have your image converted. Just visit man pages on your linux. Or visit  http://www.imagemagick.org/script/convert.php to download a version with GUI or for a different operating system.

For the story, I used this to convert my pdf:
convert input.pdf -scale 500 output.pdf
And got a smaller file with a terrible resolution.
Anyone knows anything about it?

That's a story about how something irrelevant results to an exploration of another irrelevant thing (but useful).


So, even if you are going to fail, never mind, explore! Even if it's pangolins! :)