Setting everything up

On SERVER01 (this will be the replication Master) you will need to add the following to the my.cnf file:

bind-address=SERVER01's IP ADDRESS
log_bin=/var/log/mysql/mysql-bin.log
server-id=100
innodb_flush_log_at_trx_commit=1
sync_binlog=1

Make sure that skip-networking is disabled!

If you use functions and are sure they don’t modify data – are save for replication – you may want to add the following line the my.cnf as well:

log-bin-trust-function-creators=1


In mysql create a replication user and grant them access to all databases:

mysql> CREATE USER 'replusr'@'localhost' IDENTIFIED BY 'password';
mysql> GRANT ALL ON *.* to replusr@'10.0.0.2' IDENTIFIED BY 'password';
mysql> FLUSH PRIVILEGES;


Restart the MySql server to load the updated my.cnf file

On SERVER02 (this will be the replication slave) install mysql and add the following to the my.cnf file:

bind-address=SERVER02's IP ADDRESS
log_bin=/var/log/mysql/mysql-bin.log
server-id=101

Note that the server-id MUST be different from the master and any other slaves you set up for replication.

Starting replication

On SERVER01 (the replication Master)

Open two terminals with mysql.  In the first terminal run:

mysql> FLUSH TABLES WITH READ LOCK;


In the second terminal run:

mysql> SHOW MASTER STATUS;

Write down the values for the column FILE and POSITION. You will need them later when setting up the Slave! (the values will look like mysql-bin.000001 and 106).

In the second terminal exist mysql and issue the following command to backup all databases, so you can import them on the slave machine:

shell> mysqldump --all-databases --master-data > dbdump.db

The backup may take a while if you have a big database.  Once completed you can go to terminal one and close it, this will automatically release the lock and allow you to continue using the master normally.
Copy the backup file (dbdump.db) to the slave machine and continue with the next steps.

On SERVER02 (the replication Slave)

Start the MySql server with the –skip-slave-start option so that replication doesn’t start and import the database backup you copied from the master.

shell> mysqld_safe –-skip-slave-start
shell> mysql –u root –p < dbdump.db

Execute the following command on mysql to let the slave know where the master is and how to access it.  This is also where you’ll be using the FILE and POSITION you wrote down earlier when starting replication on the master.

CHANGE MASTER TO MASTER_HOST='SERVER01', MASTER_USER='replusr', MASTER_PASSWORD='password', MASTER_LOG_FILE='mysql-bin.000001', MASTER_LOG_POS=106;

Stop the MySql server to exit safe mode.

Start the MySql server normally so the slave will start up and you’re done.

You can run the following command to check if the slave is up and running:

show status like ‘Slave%’;

You should see output like the following

+----------------------------+-------+
| Variable_name | Value |
+----------------------------+-------+
| Slave_open_temp_tables | 0 |
| Slave_retried_transactions | 0 |
| Slave_running | ON |
+----------------------------+-------+
3 rows in set (0.00 sec)

Check that Slave_running is set to ON.
 

Open it and add a line for each job you want to run:

0 * * * * /usr/bin/unison
0 */5 * * * /usr/bin/cleanup

The first line will run unison every hour, while the second line will run a process called cleanup every 5 hours.

After saving the file run

crontab -u USERNAME cronjobs.txt

where USERNAME is your username.

You can verify that the cronjob is added successfully by running:

crontab -l


Each line is the cronjob file has the following syntax:

minutes(0-59) hours(0-23) day(0-27/28/29/30) month(0-11) weekday(0-6) command

A star for any of the above means any, so 0 * * * *  means every hour of every day on minute 0, which is an hourly job

*/5 means every fifth, */2 every second etc, so */5 * * * * would mean every 5th minute of every hour of every day, which is a job that repeats every five minutes.

To create the webapp using Maven you need to specify the DarchetypeArtifactId as being a webapp. In your command line you will type the following:

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-webapp

The webapp structure will be created in the directory called my-webapp.

The next steps assume that you have installed the Maven plugin for Eclipse (m2e).

Open Eclipse and from the “File” menu select “Import…” and in the window that opens up find the Maven folder and select “Existing Maven Projects”.
Browse to the directory where you created my-webapp and the pom.xml file is located, in this example that is /workspaces/my-webapp. and click the “Finish” button to complete the import.

Your project will now appear in Eclipse and you can edit and add source files as you need.

You can run Maven install to let Maven compile your code and put it in the target directory:

If you want to run the application through Eclipse and you’ve already setup your server, then you need to perform some additional steps to make sure that Eclipse will allow you to run the application from the server.

Firstly you will need to convert the project to a faceted form:

Secondly you will need to add “Dynamic Web Module” in Project Facets and make sure to check the “Further configuration options” and set the Content Directory to the target directory where Maven has placed your compiled code:

And that’s it, you should now be able to add the output of you project to your server and run it from Eclipse!

We like open source a lot and have extensive experience with PHP as well as MySQL database. Other language we develop in are Java, Ruby and we’ve dabbled a bit in Python, but like any good developer we can adapt to different languages in a very short period of time.

As a lot of the applications we development as web-based, we are up to date with the latest web technology like HTML5, CSS3 and awesome new things like WebSockets. To speed up development we use libraries like jQuery and jQuery Mobile, or Sencha Touch if you prefer, and on the server side frameworks like Kohana and Spring take care of security as well.

To allow us fast turn-around times and good feedback to clients we’ve adapted methodologies like the agile methodology to deliver software that is not only of great quality, but also is exactly what the client needs.

We believe that each approach has its merits and much depends on the application that needs to development and whether the client has a clear vision off their requirements or not.

If the client has a clear vision then there is great advantage in doing an upfront design of the entire system, like the waterfall approach suggests, but not going into the level of detail this approach needs. This provides our team with a clear understanding of what the client wants and gives us the opportunity to accurately estimate the costs that will be involved in creating the application. But it is important to note that even when we have done an upfront design, we still split the project in small sprints and involve the client in each step, because we have learned that even the most clear “visioned” client will still require changes along the way…

Once we know what the client wants (either the entire application, or just a part of it) the we start developing the software in small incremental “batches” referred to as sprints in the agile world. After each sprint – which take from one week to a month – the client is presented with the newly completed features that were developed during that sprint. After discussing the changes with the client it is decided which features will be implemented during the next sprint or if a change is required to the design. Once that is done the next sprint starts and the process repeats itself until the final product is delivered.

Here at VR Software we realize that communication is essential, not only between team members, but also between our team and our clients.  Unlike a lot of software development companies we do not just involve you in the design phase, where plans are made as to what the application must do and look like, but we keep you in the loop and ask for feedback even while we are developing the application.  This ensures that problems are identified and fixed as early as possible, instead of waiting for the final product to be delivered.

The result of this approach is that the application that you get is exactly what you need, because you’ve been involved every step of the way.  If you see somewhere during the development process, that your processes could be adapted to a much simpler approach, we can immediately change track and implement it that way.  This way we don’t waste time developing feature that are not optimal, and you don’t incur extra costs because as we don’t necessarily see the change as “scope creep” like other software development companies would.

And the best part is that we don’t stop communicating with you once we deliver the product.  We stay involved to help your users, add additional functions as you need them and make sure that everything is running smoothly.   We want our clients to stay with us and grow with us.  We are passionate about software development and we want you to be passionate about our products!