I recently installed GeoNode and integrated an application into it and thought I would share some notes on the process.
By the end of the guide you should have a fully functioning GeoNode installed including multiple client and Django application locally or on a server.

In part I of the blog I covered installing GeoNode onto Ubuntu 10.10 server and adding a client application. Part II covers using Django-schemata/South in the context of GeoNode and adding multiple Django applications to GeoNode.

Step 3: Adding a Django a Application

If you also have a Django application that you would like to integrate there are just a few steps needed.

First place a copy of the application somewhere on your server or local machine and then create a symlink of your Django application in /var/lib/geonode/src/GeoNodePy/geonode with a comment like:

ln -s /location/of/Django_app/ /var/lib/geonode/src/GeoNodePy/geonode/Django_app

Then let GeoNode know that there is a new Django application by editing the client build.xml

<property name="app.proxy.MYDJANGOAPP" value="http://localhost/MYDJANGOAPP/"/>

Next add your Django application to INSTALLED_APPS in /var/lib/geonode/src/GeoNodePy/geonode/settings.py:

INSTALLED_APPS = (
    'geonode.YOURDJANGOAPP',
    ....
)

You will then need to restart tomcat, apache, and postgres.

How are you feeling? Everything ok?  At this point you should be able to view your application at the IP address you used above or localhost.

For my application it does not end here, there’s more… I need GeoNode to handel database schema migrations. I will be adjusting tables and views frequently. I also need my geometry columns to be properly registered within geometry_columns in the database.

Django south and Django Schemata are a solution. This allows one to migrate database changes, it allows one to use multiple database schemas, and it registers the geometry columns.

Step 4: Adding a Django-Schemata & South

Install Django South. * note you need to install south from inside your GeoNode virtual environment, to do so run:

 source /var/lib/geonode/bin/activate

and then:

pip install South

You need to clone the Django-schemata github repository to your GeoNode server and the make a symlink to django_schemata/ directory from /var/lib/geonode/src/GeoNodePy/geonode

Now you’ve installed South system-wide, you’ll need to configure Django to use it. Doing so is simple; just edit your settings.pyand add to the end of INSTALLED_APPS:

'south'

and

'django_schemata'

Also in settings.py add to MIDDLEWARE_CLASSES:

'django_schemata.middleware.SchemataMiddleware'

In local_settings.py I have the following settings for the DATABASE:

DATABASES = {
      'default': {
            'ENGINE': 'django_schemata.postgresql_backend',
            'NAME': DATABASE_NAME,
            'USER': DATABASE_USER,
            'PASSWORD': DATABASE_PASSWORD,
            'HOST': DATABASE_HOST,
            'PORT': DATABASE_PORT,
        }
    }

Also add to local_settings.py:

SOUTH_DATABASE_ADAPTERS = {
   'default': 'south.db.postgresql_psycopg2',
}

To test and see if Django-Schemata and South are running correctly, and to set up your domains please refer to the schemata management commands
For more information:

At this point I am going to pass you along to other resources. You can find more information about GeoNode’s plans to use these tools here. You can learn more about how to setup and use Django-Schemat here at the project’s GitHub project repository, and in a nice blog written my colleague: PostgreSql schema support, PostGIS and Django. At this point I apologies for the limited documentation on the topic as we have been limited on time, here you can see some information about what was done on our specific application.

In summary you need to install Django South

Step 5: Adding multiple Django applications to GeoNode

With all of this in place you can now merge multiple Django application into one GeoNode environment, each one managing it’s own perspective database schema, while conglomerating all the required geometry columns into the public geometry_columns table.

First create a new Django app from your root Django project directory using django south with:

sudo python ./manage.py startapp YOURNEWDJANGOAPP

Add the new Django app to INSTALLED APPS in settings.py as we did above in step 3.

Then add the application to SCHEMATA_DOMAINS in /var/lib/geonode/src/GeoNodePy/geonode/local_settings.py this should look something like this:

SCHEMATA_DOMAINS = {
    '178.79.183.128': {
        'schema_name': 'gem',
    },
    '178.79.185.195': {
        'schema_name': 'ged',
    },
    'django': {
        'schema_name': 'public',
    },
}

Now add the symlink for the new Django application in /var/lib/geonode/src/GeoNodePy/geonode/

then run (within your GeoNode virtual environment) in /var/lib/geonode/src/GeoNodePy/geonode:

python ./manage.py schemamigration YOURNEWAPPIP --initial

export DJANGO_SCHEMATA_DOMAIN=YOURNEWAPPIP

python ./manage.py migrate_schemata YOURNEWAPPNAME # add "--fake" depending on weather sync db has been used

If you have made it this far, congrats! You should now have fully functioning GeoNode that has multiple Django applications, all of which are maintaining their perspective database schemas.

Hope this helps and happy GeoNoding

After another Openquake.org site outage, I thought I better copy over this post…

I recently installed GeoNode and integrated an application into it and thought I would share some notes on the process.
By the end of the guide you should have a fully functioning GeoNode installed including multiple client and Django application locally or on a server.

Step 1: Install GeoNode onto Ubuntu 10.10 server

Before installing GeoNode, there was one dependency that was not included in the GeoNode package that added some python packages, to meet this requirement I first I ran:

sudo apt-get install python-software-properties

Installing GeoNode: OpenGeo has made great progress in recent months with the process of installing GeoNode, and now you can simply follow the three commands here to install GeoNode to your local machine or to a server.

Once GoeNode is installed please follow the required and recommended settings as needed on the Configuring GeoNode for Production.

Check that your GeoNode is working by opening your browser to http://YOURIPADDRESS, you should see the GeoNode welcome page.

Now that you have a working GeoNode it is likely that you are going to want to integrate an application into it. If you do not already have an application, a good place to start is with the readygxp which has been set up specifically to provide a simple reusable template for GeoExt/GXP applications bound for a servlet container.

Step 2: Adding a Client Application
Now for the nuts and bolts of this guide, integrating the client application into GeoNode.
If you have deployed GeoNode locally or on a server and if you have your own application or have used the readygxp this guide should help get it all set up.

I would recommend to place a copy of the client application onto the server or local machine. Then you will need to prepare your client application by setting up the application build.xml to reflect the new GeoNode IP address and project name. This is done by navigating to the root directory of the client application and editing the build.xml, your setting should look like:

<property name="app.proxy.geoserver" value="http://localhost/geoserver/"/>

You will need to create a .war file of your application, lets pretend it’s called application.war. From your client root directory run (don’t forget to first run git submodule init and git submodule update if needed and ant init (just the first time after cloning the application from github)):

ant static-war

Now copy the application.war to your GeoNode /var/lib/tomcat6/webapps path.

Next add the correct IP address to the /var/lib/geonode/src/GeoNodePy/geonode/local_settings.py:

 SITEURL = YOURIPADDRESS

If you have a SCHEMATA_DOMAINS defined in your local_settings.py, then you will also have to change it’s IP address

You will also need to add the project IP to /var/lib/tomcat6/webapps/geoserver/WEB-INF/web.xml:

GEONODE_BASE_URL

Add proxies for application in /etc/apache2/sites-available/geonode it should look something like this:

ProxyPass /YourApplication http://localhost:8080/YourApplication
ProxyPassReverse /YourApplication http://localhost:8080/YourApplication

**NOTE you also need to add a path to your additional applications to the first line of /etc/apache2/sites-available/geonode so that the customized applications can be found, in my case the path looks like this:

:/var/lib/geonode/src/GeoNodePy/geonode/

Add the ip address to /var/lib/geoserver/geonode-data/gs-data/printing/config.yaml under # the list of allowed hosts:

- !dnsMatch host: YOUIPADDRESS port: 80

If you use PGAdmin to view or manage your database and your GeoNode installation is on a remote server, optionally you can allow postgress to be accessed via ssh by adding ‘trust’ to /etc/postgresql/8.4/main/pg_hba.conf and restart postgres, my settings looked like this:

local all all trust # IPv4 local connections: host all all 127.0.0.1/32 
trust # IPv6 local connections: host all all ::1/128 trust

once this is done you can view the database via PGAdmin with this ssh string:

ssh -L5433:127.0.0.1:5432 user@YOUIPADDRESS

Then open PGAdmin and change the port to 5433

One more thing to note… when adding or removing layers in GeoServer, GeoNode is not aware of these changes. To make GeoNode aware of layer changes navigate to /var/lib/geonode/ directory you need to run:

source bin/activate

then:

django-admin.py updatelayers --settings=geonode.settings

If this command fails then if could be that you need to increase the time-out time in:
/var/lib/tomcat6/webapps/geoserver-geonode-dev/WEB-INF/classes/applicationSecurityContext.xml
This completes part I of this topic, please check out part II which covers:

• Adding a Django a Application
• Adding a Django-Schemata & South
• Adding multiple Django applications to GeoNode