Construct

« Older Entries

Newer Entries »

Archive

Easy Web Access to Construct - Construct PHP Class

Published

matt

on July 9, 2008

in PHP, Python and Tutorials

. 0 Comments

Using PHP to access construct is desirable to allow interesting construct based web applications to be developed that allow easy implementation, and rapid prototyping. On this basis, we developed a PHP class that allows a developer to connect to a running instance of Construct and manipulate data quicky and easily, without the need to run standalone JAVA applications.

(Download Construct PHP Class)

The PHP Class has been tested on Windows versions of PHP (using XAMPP) and on Mac XServe (Darwin), it should work with any webserver running PHP 5, (possibly 4) with sockets support.

The Construct PHP Class also contains a file called constructmananger.php and example.php, the Construct Manager uses the Construct class to give an advanced web interface to Construct, and the Example shows a simple implementation of a sparql query using the Construct class.

Put the files in any web accessible directory, and edit the example.php file to point at the machine that is running Construct.

<?php

$host = "localhost";

// find the class

include_once('Construct.class.php');

// create a new construct object

$construct = new Construct($host);

?>

After importing the class and instatiating it (see above) it is then possible to query Construct as shown below

// prepare a query

$sparql_query = "SELECT ?subject ?predicate ?object WHERE {?subject ?predicate ?object}";

// execute query

try{

$results = $construct->query($sparql_query);

}Catch(Exception $e){

// catch any problems

echo $e->getMessage();

exit();

// output the results

print_r($results);

The results are returned as a PHP array by default, but can also be returned as JSON, XML or a Simple XML Object.

$construct->query($querystring, [$xsl=null, [$format=null, [&$error=null]]])

Where $querystring is the SPARQL query, $xsl is the xsl-stylesheet to apply (send null if not used), $format indicated the format of the returned data, and $error is an array into which errors should be placed. Values in [] are optional.

The values for format are:

JSON, XML, XMLOBJECT or ARRAY

It is also possible to insert data, the following gives an example

$timeout = "30000"; // Time in ms to keep data in store

try{

$success = $construct->insert($rdftriplets, $timeout);

}Catch(Exception $e){

echo $e-getMessage();

Where $rdftriplets are in valid n-triple format.

If links are unavailable, you can try here

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Adding Construct to your Ubuntu start menu.

Published

stephen

on July 9, 2008

in Advanced and Tutorials

. 0 Comments

In this post, I show you how to add construct to your ubuntu start menu. The assumption I am making is that you have the most recent version of construct (currently 0.74) downloaded and installed.

Step 1

This step allows you to run construct without being in the construct directory.

Open the ‘construct.sh’ file and change the line:

CONSTRUCT_HOME=.

CONSTRUCT_HOME=YOUR CONSTRUCT DIRECTORY

For me it is: $HOME/construct

Save the file and exit.

Step 2

Create a symbolic link to the executable shell script.

This allows you to just type ‘construct’ in the terminal, much the same way you would write ‘emacs’ etc.

Open a terminal and type:

cd /usr/bin/

now type:

ln -s LOCATION_OF_CONSTRUCT_DIRECTORY/construct.sh construct

Now type cd

Type ‘construct’. Construct should start running.

It will tell you, however that it could not find the properties file.

Step 3

Copy the construct.properties file to your home directory.

Exit construct if you have it open.

Open a terminal.

cd to your construct directory (in my case cd ~/construct)

Copy the file to your home directory:

cp construct.properties ~/ (~/ is a shorthand notation for your home directory)

Step 4

In your ubuntu status bar, double click on the ’start menu’ — the orange circular icon on the left.

Click on ‘Edit Menus’

Click on the ‘New Item’ button on the right

For ‘Name’, type ‘Construct’

For ‘Command’, type ‘construct’

Click OK.

That’s it!

Construct is now in your start menu!

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Understanding the construct.properties file

Published

graeme

on July 9, 2008

in Beginners and Tutorials

. 1 Comment

As the name suggests, the construct.properties file defines settings for the Construct platform. The settings cover three things: global properties for Construct, the components to be instantiated at runtime, and the individual properties of each component.

In the current release, all (bar one) of the global properties are related to logging. The other refers to the hostname of the machine running the Construct software:

Logging level	The level of log messages to be recorded
The Logging limit	The maximum number of bytes to write to any one log file
The logging file count	The number of log files to rotate
The logging file name	The base name to use for log files
The logging directory	The directory in which the log files are stored
The hostname	The hostname or IP address of the machine running the Construct software

The components that you wish to instantiate once the Construct framework is started are also contained in the properties file. Some components also contain properties which are specific to those components and must be declared as children of the components in the properties file. The structure of the properties file is explained further on. Below is an example of some Construct components. More thorough explanations can be found elsewhere on the Wiki.

Data Store Manager	Provides a single point of access to the data store
Query Service	Processes application and entity queries made in SPARQL
Data Port	Accepts RDF data provided by sensors and adds them to the data store
Registry Service	Stores information on registered services
Discovery Service	Handles requests from clients for available Construct services
Gossiping Components	Allows distribution of data store contents
Extension Components	Add-on components such as a Query Viewer

Once the start button is clicked on the Construct GUI, a Component Loader is created which reads in the contents of the properties file and instantiates any components that are specified. On instantiation, each component fetches it’s properties and caters for them.

Reading and Writing to the construct.properties File

The construct.properties file is and XML encoded file in which all properties and components must be contained within the parent node, construct (i.e. it takes the form … ). Global properties must be contained directly inside the construct tags and they are indicated by a property tag. Thus, all properties take the form,

<property name=“[the name here]“ value=“[the value here]“ />

Components must also be defined directly inside the construct tags. The component specific properties must be declared directly inside the opening and closing tags of the component in question. Components are scripted as follows:

<component interface=“[the interface to the component here]“ implementation=“[the implementation of the component here]“>
<property … />
</component>

where the interface specifies the path to the interface for the component and the implementation specifies the path to the concrete implementation of the component.

There is an example properties file contained in the release of Construct. To add new properties follow the structure of the document as explained above. HTML style comments (i.e. <!– [the code to comment here] –>) can be used to prevent a property or component contained in the file from being read in. Ensure to comment the property or component by adding the opening comment (<!–) before the opening tag of the component or property and adding the closing comment (–>) after the closing tag.

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

HTTP Port - Part 2

Published

steve

on July 9, 2008

in Construct internals

. 0 Comments

In part 1 of this post I described the new HTTP Port in Construct. In this part of the post I’ll explain how to write a web form and style the return values.

SPARQL Query

You can send a query to Construct with GET or POST. Here is how we do it in HTML with GET:

<form method=“GET” action=“http://duvel.ucd.ie:8888/”>
<textarea name=“q” cols=“64″ rows=“10″>SELECT ?subject ?predicate ?object WHERE {?subject ?predicate ?object}</textarea><br/>URL of XSLT to apply (optional):<br/><input type=“text” name=“xsl” size=“56″ value=“http://www.construct-infrastructure.org/stylesheets/default.xsl type=”submit” value=”Submit Query“>
</form>

the only thing the HTTP Port wants is the query field to be called either “q” or “query”. The returned XML will be sent back to your browser. Something like this:

<?xml version=“1.0″?>
<?xml-stylesheet type=“text/xsl” href=“http://duvel.ucd.ie:8888/xsl/www.construct-infrastructure.org/stylesheets/default.xsl”?>
<sparql
xmlns:rdf=“http://www.w3.org/1999/02/22-rdf-syntax-ns#”
xmlns:xs=“http://www.w3.org/2001/XMLSchema#”
xmlns=“http://www.w3.org/2005/sparql-results#”>
<head>
<variable name=“subject”/>
<variable name=“predicate”/>
<variable name=“object”/>
</head>
<results>
<result>
<binding name=“subject”> <uri>http://www.pervasive-ontologies.org/ontologies/sensors/bluetooth#reading00:19:63:96:56:01@00:80:98:94:AE:4B@1201631502</uri>
</binding>
<binding name=“predicate”>
<uri>http://www.pervasive-ontologies.org/ontologies/sensors/bluetooth#spotted</uri>
</binding>
<binding name=“object”>
<literal>00:19:63:96:56:01</literal>
</binding>
</result>
</results>
</sparql>

To make the results look neater you can apply and XSL stylesheet. Send the URL for the XSL stylesheet as a field “xsl” in the form. This stylesheet must be web accessible. We’ve made a default example stylesheet you can use to get started.

Inserting N-3 RDF Data

You can insert new data into Construct using a form like this (we’re using POST this time for variety but GET works too):

<form method=“POST” action=“http://duvel.ucd.ie:8888/”>
<textarea name=“i” cols=“64″ rows=“10″><http://www.pervasive-ontologies.org/ontologies/sensors/bluetooth#reading00:19:63:96:56:01@00:80:98:94:AE:4B@1201631502><http://www.pervasive-ontologies.org/ontologies/sensors/bluetooth#spotted>“00:19:63:96:56:01″.</textarea><br/>Expiry time for data (optional):<br/><input type=“text” name=“expiry” size=“15″ value=“20000″><br/><input type=“submit” value=“Submit Data”>
</form>

in this form you send the data to be inserted as a field “i” or “insert”.

The returned data from an insert is an XML document with a status code and any messages given back from Construct. It looks something like this:

<response>
<status>OK</status>
<description>The data <http://www.pervasive-ontologies.org/ontologies/sensors/bluetooth#reading00:19:63:96:56:01@00:80:98:94:AE:4B@1201631502><http://www.pervasive-ontologies.org/ontologies/sensors/bluetooth#spotted>“00:19:63:96:56:01″. with given expiry 20000 was passed to the Construct data store without error.
</description>
</response>

Well, that is about it. You can make calls to Construct over HTTP from browsers or web applications using the HTTP Port. Have fun.

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

HTTP Port - Part 1

Published

steve

on July 9, 2008

in Construct internals

. 2 Comments

The latest release of Construct has the new HTTP Port enabled by default. The HTTP Port has similar functionality to the data port — you can use it to insert and query for data in Construct. The difference is that the data port works over raw TCP sockets, whereas the HTTP Port works over HTTP.

Now we can query Construct through a web browser and web apps… neat, huh?

First off, the construct.properties file now contains:

<!– http port –>
<component interface=“org.construct_infrastructure.component.httpport.HttpPort” implementation=“org.construct_infrastructure.component.httpport.HttpPortImpl”>
<property name=“port” value=“8888″ />
</component>

these lines activate the HTTP Port on port 8888. When you have Construct running, open your web browser and go to http://localhost:8888/ and you should a simple set of forms for querying and inserting data using HTTP GET and HTTP POST. It looks something like this:

From this page you can send RDF data in N-3 format or SPARQL queries to Construct. Try clicking on one of the buttons to test it out.

This is the end of Part 1 on the HTTP Port. Part 2 of this post will explain how to build your own web forms and use of XSL stylesheets for your results.

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Construct and Python - Part 3

Published

lorcan

on July 9, 2008

in Beginners, Python and Tutorials

. 0 Comments

This tutorial shows how to insert RDF from a file (joebloggs_foaf.rdf) into Construct. It then shows how to send a SPARQL query to query this data from Construct. The resulting QueryResults object is printed in N3 format.

from construct.proxy import proxy
from construct.constructservice import ServiceError
from rdflib.Graph import ConjunctiveGraph
# Create a new proxy object.
proxy = proxy()
print “Executing Script”
try:
# Generate a piece of FOAF RDF
store = ConjunctiveGraph()
store.load(“joebloggs_foaf.rdf”)
data = store.serialize(format=“nt”)
# Send the FOAF RDF to the data store
if(proxy.insert(data)):
# Now query for joebloggs web address
query = “”“SELECT ?nickname WHERE{
?subject <http://xmlns.com/foaf/0.1/name> “Joe Bloggs“.
?subject <http://xmlns.com/foaf/0.1/nick> ?nickname.}
““”
results = proxy.query(query)
print “Here is the N3 form of the QueryResults Object:”
print results
except ServiceError, e:
print e
# Close the proxy.
proxy.close()

If this script executes properly something like the following should be printed out:

Executing Script

Here is the N3 form of the QueryResults Object:

_:A6a94e801X3aX118515eda06X3aXX2dX7ffa <http://www.w3.org/2001/sw/DataAccess/tests/result-set#value> “joe” .

_:A6a94e801X3aX118515eda06X3aXX2dX7ffa <http://www.w3.org/2001/sw/DataAccess/tests/result-set#variable> “nickname” .

_:A6a94e801X3aX118515eda06X3aXX2dX7ffb <http://www.w3.org/2001/sw/DataAccess/tests/result-set#binding> _:A6a94e801X3aX118515eda06X3aXX2dX7ffa .

_:A6a94e801X3aX118515eda06X3aXX2dX7ffc <http://www.w3.org/2001/sw/DataAccess/tests/result-set#solution> _:A6a94e801X3aX118515eda06X3aXX2dX7ffb .

_:A6a94e801X3aX118515eda06X3aXX2dX7ffc <http://www.w3.org/2001/sw/DataAccess/tests/result-set#resultVariable> “nickname” .

_:A6a94e801X3aX118515eda06X3aXX2dX7ffc <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2001/sw/DataAccess/tests/result-set#ResultSet> .
This post is the final part of a python and Construct tutorial. Part 1 is here and part 2 is here.

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Construct and Python - Part 2

Published

lorcan

on July 9, 2008

in Beginners, Python and Tutorials

. 1 Comment

This code demonstrates how to interact with the client proxy using the RDFLib package:

from construct.proxy import proxy
from construct.constructservice import ServiceError
from rdflib import RDF, Namespace, Literal
from rdflib.Graph import ConjunctiveGraph
FOAF = Namespace(“http://xmlns.com/foaf/0.1/”)
exampleNS = Namespace(“http://www.example.com/”)
# Create a new Proxy object.
proxy = proxy()
print “Executing Script”
try:
# Generate a piece of FOAF RDF
store = ConjunctiveGraph()
store.bind(“foaf”, “http://xmlns.com/foaf/0.1/”)
store.add((exampleNS["~joebloggs"], RDF.type, FOAF["Person"]))
store.add((exampleNS["~joebloggs"], FOAF["name"], Literal(“Joe Bloggs”)))
store.add((exampleNS["~joebloggs"], FOAF["nick"], Literal(“joe”)))
store.add((exampleNS["~joebloggs"], FOAF["givenname"], Literal(“Joe”)))
store.add((exampleNS["~joebloggs"], FOAF["family_name"], Literal(“Bloggs”)))
data = store.serialize(format=“nt”)
# Send the FOAF RDF to the data store.
if proxy.insert(data):
print “The following data were added correctly:”
print data
else:
print “Problem encountered when adding the following data:”
print data
except ServiceError, e:
print e
# Close the proxy.
proxy.close()

If this code has run correctly the following should be printed:

Executing Script

The following data were added correctly:

<http://www.example.com/~joebloggs> <http://xmlns.com/foaf/0.1/givenname> “Joe”.

<http://www.example.com/~joebloggs> <http://xmlns.com/foaf/0.1/nick> “joe”.

<http://www.example.com/~joebloggs> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person>.

<http://www.example.com/~joebloggs> <http://xmlns.com/foaf/0.1/name> “Joe Bloggs”.

<http://www.example.com/~joebloggs> <http://xmlns.com/foaf/0.1/family_name> “Bloggs”.
This post is the second part of a tutorial on construct and python. Back to Part 1 of this tutorial or on to Part 3.

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Construct and Python - Part 1

Published

lorcan

on July 9, 2008

in Beginners, Python and Tutorials

. 2 Comments

This post will show how to connect to a Construct Data Port and submit RDF data.

If an instance of Construct is available, this code will insert two pieces of RDF in N3 format. The first of these is good RDF, the second of these is not. The script is below, and example output beneath that again.

#Import the python construct proxy.
from construct.proxy import proxy
from construct.constructservice import ServiceError
#Create a new Proxy object.
proxy = proxy()
print “Executing Script”
try:
# Send a VALID piece of RDF to the data store
insertGoodResponse = proxy.insert(“<http://hello><http://construct>\”world\”.”);
print “Response to good RDF: “ + str(insertGoodResponse)
# response should be “1″
# Send an INVALID piece of RDF to the data store.
insertBadResponse = proxy.insert(“<http://badly><http://formed>\”rd\”f\”.”);
print “Response to bad RDF: “ + str(insertBadResponse)
# response should be “None”
except ServiceError, e:
print e.value
# Close the proxy.
proxy.close()

If this code has executed correctly (i.e., if an instance of Construct is discovered) the following will be printed:

Executing Script

Response to good RDF: 1

Response to bad RDF: None

If the Construct proxy is not found the following will be printed:

Executing Script

Error - unable to contact an instance node of Construct (using address localhost:3826). Is the Construct Proxy running at that address?

and if no instance of Construct is discovered the following will be printed:

Executing Script

Error: No instance of Construct found. Please ensure you are within Zeroconf range of a running instance of Construct
This post is the first part of a tutorial on construct and python. Part 2 of this tutorial is here and part 3 is here

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Construct and Java - Part 2

Published

graeme

on July 9, 2008

in Beginners, Java and Tutorials

. 0 Comments

In Part 1 of this series of posts, I described how to add data to Construct. This post will teach you how to get data back out again using the Query Service.

The Java libraries bundled with Construct make use Jena, and the SPARQL query language in the process of querying Construct. If you’re already familiar with Jena, then there is only a couple of additional steps to learn.

Working with Jena and SPARQL

(download the sample code)

To start, we need to open a connection to the Query Service. This is done in the same way as a connection to the Data Port, by creating a new instance of the appropriate class.

final QueryServiceProxy qsProxy = new QueryServiceProxy()

The next step is to create the SPARQL query. In this example, we wish to query for the name property of the subject http://example.com/people/bob that we created in Part 1.

final String query = “SELECT ?name WHERE{
<http://example.com/people/bob>
<http://example.com/terms#name>
?name}”;

Then we call the query() method of the proxy object, passing the query as an argument. The return value is a Jena ResultSet object corresponding to the result of the query.

final ResultSet resultSet = qsProxy.query(query);

What you do with the result set is obviously dependent on your need for the data. For the purposes of this example, we’ll print the result to the console.

if (resultSet.hasNext()) {
final QuerySolution solution = resultSet.nextSolution();
final Literal name = solution.getLiteral(“name”);
System.out.println(name.toString());
}

Finally, we close the connection to the query service.

qsProxy.close();

That’s the basics of querying data with Construct.

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks

Email This to a Friend

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Construct and Java - Part 1

Published

graeme

on July 9, 2008

in Beginners, Java and Tutorials

. 1 Comment

After you install Construct, the next thing you might want to do is add some data. This post will describe the basics.

The Java libraries bundled with Construct give you a couple of ways to contribute date: You can either pass RDF triples in directly, or work with Jena and submit a model when you’re ready to publish its contents.

Working with Triples

(download the sample code)

The first step is to create a connection to the DataPort. This is achieved by creating a new instance of the DataPortProxy class.

final DataPortProxy proxy = new DataPortProxy();

Next, we call the add() method of the proxy object, passing the RDF triple as an argument. Multiple triples can be added simultaneously by separating them with a period. The return indicates whether the add operation was successful.

final boolean response = proxy.add(“<http://example.com/people/bob>
<http://example.com/terms#name>
\”Bob Smith\”.”);

Finally, we close the connection to the data port.

proxy.close();

Working with Jena

(download the sample code)

When using Jena, the process is very similar. As before you should begin by creating a new instance of the DataPortProxy object. Next, a new model should be created, and populated with data.

final Model model = ModelFactory.createDefaultModel();
final Resource person = model.createResource(“http://example.com/people/bob”);
final Property name = model.createProperty(“http://example.com/terms#name”);
person.addProperty(name, “Bob Smith”);

Then, the contents of the Jena model is added to Construct through another of the proxy object’s add() methods. Remember to close the connection as before when you are finished.

final boolean response = proxy.add(model);

That’s the basics of adding data to Construct. The next post in this series will describe how to get data from Construct using the Query Service.

Bookmark and Share

Close this Window Bookmark and Share This Page

Save to Browser Favorites / Bookmarks