Dropbox on Linux with encrypted home directory

9 Replies

Dropbox dropped support for all files systems except ext4 on Linux. This is a problem for everybody using an encrypted home directory since those are usually mounted via ecryptfs or similar. The following workaround makes use of an ext4 formatted file system image that is mounted via a loopback device upon login.

Step 1: create a mount point and make it read-only if not mounted

mkdir remote/Dropbox
sudo chattr +i remote/Dropbox

Change the “remote” part of the paths if you prefer to place your Dropbox folder at a different location.

Step 2: create an image file and format it

Change 10G to something that corresponds to the space that you need in order to sync your Dropbox files:

truncate -s 10G remote/.Dropbox.ext4

Alternative way of creating the image using dd:

dd if=/dev/zero of=remote/.Dropbox.ext4 count=10240 bs=1048576

Format the image with ext4:

mkfs.ext4 -F remote/.Dropbox.ext4

Step 3: create an entry in /etc/fstab

/home/<username>/remote/.Dropbox.ext4 /home/<username>/remote/Dropbox ext4 user,noauto,rw,loop,x-gvfs-hide 0 0

We use the parameter x-gvfs-hide to avoid showing the folder in sidebar of the file manager.

Step 4: use a systemd user service to mount the Dropbox image upon user login

Create the file .config/systemd/user/mountdropbox.service with the following content:

[Unit]
Description=Mounts a Dropbox ext4 image in the home directory of a user
After=home-username.mount
Requires=home-username.mount

[Service]
ExecStart=/bin/mount %h/remote/Dropbox
ExecStop=/bin/umount %h/remote/Dropbox
RemainAfterExit=yes

[Install]
WantedBy=default.target

Now lets enable and start the service. Slashes must be replaced by dashes if used as systemd parameters.

systemctl --user enable mountdropbox.service
systemctl --user start mountdropbox.service

After executing the commands above the service will be started (i.e., the Dropbox folder will be mounted) automatically upon user login.

Note for Ubuntu 18.04 or newer: for some reason systemd seems to “forget” the user service after reboot. Please check the comments of this blog post for a solution to this.

We also make sure that we own the mounted folder:

sudo chown <username>:<username> remote/Dropbox

Step 5: tell Dropbox to move your files to the new location

You can use the Dropbox GUI to move the Dropbox folder location to the newly created one.

The way how Dropbox detects the file system in use is a bit awkward as it does not let you choose the mount point itself as Dropbox folder location, instead you need to sync to a subfolder. So if you mount point is remote/Dropbox you need to sync to remote/Dropbox/<username> or something like that as Dropbox does not believe that the mount point is an ext4 file system.

Optional: grow the Dropbox image if you need more space

On the command line run the following commands (change 15G to something appropriate for your needs, but never change it to a lower size than your existing image as this cuts of the image which may lead to data loss):

dropbox stop
systemctl --user stop mountdropbox.service
truncate -s 15G remote/.Dropbox.ext4
fsck.ext4 -f remote/.Dropbox.ext4
resize2fs remote/.Dropbox.ext4
systemctl --user start mountdropbox.service
dropbox start

Fixing IntelliJ IDEA font glitch on Ubuntu

1 Reply

This post is mostly for myself to remember what changes to make in IntelliJ IDEA. The problem is that fonts are ugly and not antialized in stock-IDEA. In my case it affects IDEA 13 and 13.1 so far.

The problem is still not completely solved, the fonts are looking better, but still not as good as in Eclipse. Don’t ask me why, I just don’t know.

After googling for a good while I came up with the following additions that improve how fonts are rendered:

In idea64.vmoptions add the following lines:

-Dawt.useSystemAAFontSettings=on
-Dswing.aatext=true
-Dsun.java2d.xrender=true

At the very end of idea.sh exchange the following line

eval "$JDK/bin/java" $ALL_JVM_ARGS -Djb.restart.code=88 $MAIN_CLASS_NAME "$@"

for

eval "/usr/lib/jvm/jdk-7-oracle-x64/bin/java" $ALL_JVM_ARGS -Djb.restart.code=88 $MAIN_CLASS_NAME "$@"

This is to make sure that Oracles JDK is used as there seems to be a problem with OpenJDK and fonts in IDEA (even though this works in Eclipse). Make sure you use the path that is correct for your JDK.

While at it I also increased the default memory settings and my complete idea64.vmoptions looks like this now:

-server
-Xms256m
-Xmx2048m
-XX:MaxPermSize=512m
-XX:ReservedCodeCacheSize=256m
-ea
-Dsun.io.useCanonCaches=false
-Djava.net.preferIPv4Stack=true
-XX:+UseCodeCacheFlushing
-XX:+UseConcMarkSweepGC
-XX:SoftRefLRUPolicyMSPerMB=50
-Dawt.useSystemAAFontSettings=on
-Dswing.aatext=true
-Dsun.java2d.xrender=true

Recap of OKFestival sustainability stream and recorded sessions

Leave a reply

The sustainability stream (in which I was involved) published a detailed recap of the OKFestival, don’t miss this!

At the same time, videos of most of the sessions have been added to the web page of the streams. Look out for the keyword “video documentation” that have been added to the original description of the sustainability stream.

Green Hackathon at OKFestival in Helsinki

Leave a reply

And so it was time again! We are going to run a two-days Green Hackathon at the OKFestival in Helsinki. The conference will last for the whole week with the Green Hackathon happening on September 19 and 20. I will not write so much more in this blog, I link instead to other sites where event information and press releases have been published.

You do not need a ticket for the OKFestival in order to participate in the Green Hackathon, however, you have to sign up at http://lanyrd.com/2012/okfestival-green-hackathon/ to get your name onto the guest list.

See you in Helsinki!

Links

Green Hackathon at OKFestival
Post by OKFN
Post by EIT ICT Labs
Post by CESC

The oldest Swedish university – a fact check with SPARQL and DBpedia

Leave a reply

This morning I started to read a newspaper article about Gotland University College being merged into Uppsala University, but I stopped after the second sentence which basically stated that Uppsala University was the oldest university in Sweden. I remembered a discussion between some friends of mine years ago in which they disagreed on which Swedish university was established first. I don’t quite remember which universities they talked about, but I think it was Lund and Uppsala.

Not remembering to which conclusion they came I just wanted to do a quick fact check. The easiest and probably least time-consuming approach would have been to just click through a couple of Wikipedia pages about Swedish universities or just look at the Wikipedia list of universities in Sweden which also happens to include the dates of establishment.

Well, googling and clicking on a few links is neither the most exciting thing to do on an average Thursday morning nor does it solve a general problem, so I decided to get an answer with a SPARQL query against DBpedia Live. As an absolute minimum I needed the names of all Swedish universities and their date of establishment. A quick check at the DBpedia page about Uppsala University revealed which properties I possibly can use, so I drafted a first query:

SELECT DISTINCT ?name ?established
WHERE {
  [] dbpprop:country dbpedia:Sweden;
     rdf:type dbpedia-owl:University;
     dbpprop:nativeName ?name;
     dbpprop:established ?established.
}
ORDER BY ?established
LIMIT 50

(You can use prefix.cc to expand the namespaces in the query above.)

Nice, this worked! But was Umeå University really established in the year 17? Let’s check what went wrong by taking a look at the DBpedia page of Umeå University. There are two values for “established”, one as xsd:integer (the wrong one), the other one is an xsd:date (and correct). All other universities use integers. Well, there is not so much I can do about this, except for perhaps falling back to the dbpedia-owl:foundingDate property (which is given for Umeå but no other university).

What about university colleges? They are not included in the query result because they are not of the University type. Let’s see how we can include those: perhaps rdf:type yago:UniversitiesAndCollegesInSweden? I dislike several things about this: universities and colleges are summarized in the same property, this should better be a handled by a UNION in the query itself. The country is included too, but I already have a property stating the country in the query. The same applies to rdf:type http://schema.org/CollegeOrUniversity (even though is quite interesting to see that schema.org properties are being used).

So let’s give rdf:type dbpedia-owl:EducationalInstitution a try, this should cover all organizations we want (given there is sufficient information in Wikipedia and the transition into DBpedia went well). It also seems that sometimes we get multiple values for the number of students. As a dirty hack we just average the number of students with the avg() function in the first line of the query. If we also add some other information such as website,  amount of students, and a fallback to the literal "Sweden" (in addition to the resource dbpedia:Sweden) then we end up with the following query:

SELECT DISTINCT str(?name) as ?name, ?url, xsd:integer(?established) as ?established, avg(?students) as ?students
WHERE {
  { ?s dbpprop:country dbpedia:Sweden } UNION { ?s dbpprop:country "Sweden"@en }
  ?s dbpprop:nativeName ?name;
     dbpprop:established ?established;
     rdf:type dbpedia-owl:EducationalInstitution.
  OPTIONAL { ?s dbpedia-owl:numberOfStudents ?students }
  OPTIONAL { ?s foaf:homepage ?url }
  FILTER (datatype(?established) != xsd:integer && ?established > 500)
}
ORDER BY ?established
LIMIT 100

Done! You can take a look at the result yourself. (Side note: I used the datatype functions to make the output more pleasant for human eyes.)

Let’s double-check with the list of Swedish universities on Wikipedia to see whether we got the same result… there seems to be a difference between “established as a university” and “first establishment” which is not reflected by the data in DBpedia. Checking the information about Lund University tells us:

“The university […] traces its roots back to 1425 […] making it the oldest institution of higher education in Scandinavia followed by studium generales in Uppsala in 1477 and Copenhagen in 1479. The current university was founded in 1666.”

So, depending on your definition of “establishment” the winner is either Uppsala or Lund. You decide…

We saw that SPARQL queries on DBpedia are powerful and can be used for checking some simple facts, but it takes some attempts to build a query that returns the results we need and want. This is mostly caused by the heterogeneity of the queried data (e.g. some deviating properties, see the date of establishment vs founding date), even though it originates from the same repository.

One could now of course continue, grab sgvizler and try to visualize an eventual correlation between date of establishment and number of students on a scatter chart…

Turning Europeana into a source for educational content

2 Replies

Together with my colleague Matthias Palmér I participated in the “Hack4Europe!” competition in Stockholm which has been arranged by the Swedish National Heritage Board in the context of the Europeana project. The goal of the competition was to show the potentials of the Europeana content and APIs by building applications to showcase the social and business value of open cultural data.

Hannes Ebner and Matthias Palmér at Hack4Europe! in Stockholm. (BY-NC-SA by Kristina Alexanderson)

During the hack day we worked in a team of two (representing our newly founded spin-off MetaSolutions) and developed a showcase to demonstrate how heterogeneous metadata can be managed using an approach that we have developed in research projects both at the Royal Institute of Technology and Uppsala University. During Hack4Europe! a combination of the SCAM framework (EntryStore) and Confolio (EntryScape) is used, and both applications are extended so that they can search in Europeana and extract Europeana metadata from the search results. This allows for adding resources directly from a Europeana search result to a user’s personal portfolio for further annotation with educational metadata (or, depending on the use case, some other metadata in a non-educational context).

Screenshot of the demonstrated Europeana showcase.

The demonstrated use case was to search for resources which are suitable to be used in an educational context and to turn them into learning resources by annotating them with educational metadata. Technically this means searching and caching metadata described using the Europeana Data Model and adding educational metadata (e.g. in LOM/DCAM) on top of it. Everything is integrated into the Confolio interface and the end user does not have to know anything about where the metadata originates from, which standards are used, etc.

See the following video for a demonstration of our use case at the end of the competition:

Technical details

The annotation process of Europeana content with educational metadata as implemented in our showcase is greatly supported by the Resource and Metadata Management Model (ReM3) which is described in a paper submitted to the Semantic Web Journal (not yet accepted). ReM3 is an information model for keeping track of resources and their metadata. It is based on the concepts of Contexts and Entries where each context manages a set of entries. An entry contains a resource, descriptive metadata about the resource and some administrative information about the entry.

Schematic overview of an ReM3 entry

The information model is RDF-oriented and relies on the concept of Named Graphs (NG).  This is used to express that NGs are related, as it is the
case when the same resource is described in different contexts. In a typical situation where already existing metadata is built upon – such as in our Europeana showcase – the referenced resource is described by an additional metadata graph, resulting in at least two metadata graphs per resource: the original one from Europeana and the additional one with educational metadata in our system.

The relation between the original external metadata and the newly created metadata is stored in the entry information, where it is indicated that there are multiple descriptions for the same resource. The use of NGs makes contextualisation of metadata possible. Without the fourth piece of information in the quadruple it would be hard to differentiate between triples from different sources.

The information structure of ReM3 is represented by a hierarchical URI model which has been implemented as a REST-ful interface using HTTP. An easy-to-use and REST interface which exposes the functionality of ReM3 allows for enrichment of metadata as the protocol makes communication in both ways possible (read/write). Resources in other systems can be described by linking to them and building a connection between the metadata and the resource. Such connections are in turn exposed using Linked Data which integrates heterogeneous information sources.

Links

Educational metadata in RDF with SPARQL endpoint

3 Replies

Some time ago (within the Organic.Edunet project that ended in late 2010) I implemented a mapping of IEEE LOM to the Dublin Core Abstract Model (thanks to my colleague Mikael Nilsson who did this work) and also applied it to some bigger data sources such as the repository of the ARIADNE foundation. This post is basically a write-up of what I produced and in which ways it can be used/exploited by others. This is about public data (namely metadata describing educational resources) and a contribution to the LOD cloud.

The software used for harvesting, converting, and exposing are the SCAM framework and the Confolio frontend (I’ll post links to these applications as soon as we have some usable documentation online). Organic.Edunet uses the SCAM/Confolio combination natively so a conversion as with ARIADNE was not necessary in the case of this project.

Harvested repositories exported to RDF files

One RDF file per harvested repository is exported every Monday  morning and can be downloaded from: http://knowone.csc.kth.se/rdf/.

Some quick facts about the exports:

  • This is a direct and metadata-only export from SCAM which means that only educational metadata is included here. I.e. I assume that the ACL, provenance, etc information from SCAM is not of general interest so I don’t include it in the export.
  • SCAM supports contextualized annotation of resources, that’s why all metadata is stored in separate graphs with a URI. This basically means that the same resource (identified by a URI which you can use to download/refer to/view the resource) can be described by different graphs, e.g. in different educational contexts, or simply with some generic metadata and educational metadata on top of it.
  • The format it TriG, mainly because it has the needed support for including information about Named Graphs (and because it is a nice format ;-)).
  • Of course you can import the RDF data into your own triple store and provide/use your own SPARQL endpoint (or use it in a completely different way). If you want to play around before you do this you can also access the public SPARQL endpoint as described below.

SPARQL endpoint to query educational metadata

Using Sesame and Snorql I created a public SPARQL endpoint with a simple interface which you can use to play around. If you intend to use this more heavily in own applications you are kindly asked to setup your own endpoint to avoid hitting the server too hard. The endpoint currently supports SPARQL 1.0.

The endpoint currently only contains quadruples generated from the ARIADNE repository. I am thinking of providing also separate endpoints for other repositories, I only have to find a way of maintaining this in a way which it not too much effort. The graph URIs you can request in SPARQL (using the GRAPH keyword, see some examples below) can also be queried using plain HTTP. With content negotiation (either through the HTTP header) you can request different RDF serializations, JSON, and LOM/XML.

Examples for such URIs for a GET request look like this:

The response of these requests is a full metadata instance describing a resource, the root of the graph is the resource URI. You can get some administrative information by replacing “cached-external-metadata” by “entry”. If you had username/password an access rights to the SCAM installation you could also perform a PUT in order to update the metadata.

Enough about this, let’s get the hands dirty with some…

SPARQL query examples

Because it is always easier to build upon and modify existing things you can have a look at the following queries that have been shown to work. Preceding the query is a short description what it actually does. Depending on the query you will also need some of the following prefixes. They are predefined in the web interface, but you have to provide them yourself if you send the SPARQL query using an different client:

Prefixes

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX dcterms: <http://purl.org/dc/terms/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX vcard: <http://www.w3.org/2001/vcard-rdf/3.0#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
PREFIX lom: <http://ltsc.ieee.org/rdf/lomv1p0/lom#>
PREFIX lomvoc: <http://ltsc.ieee.org/rdf/lomv1p0/vocabulary#>
PREFIX lomterms: <http://ltsc.ieee.org/rdf/lomv1p0/terms#>
PREFIX lre: <http://organic-edunet.eu/LOM/rdf/voc#>
PREFIX oe: <http://organic-edunet.eu/LOM/rdf/>

Find all contexts describing a resource

SELECT DISTINCT ?g WHERE {
  GRAPH ?g { <http://www.orgfoodfed.com/> ?p ?o }
}

Find all resources from FAO in English language

SELECT DISTINCT ?uri ?title ?g WHERE {
  GRAPH ?g {
    ?uri dcterms:title ?title ;
      dcterms:language ?b .
      ?b rdf:value "en"^^dcterms:RFC4646 .
    FILTER(regex(str(?uri), "^http://www.fao.org/", "i"))
  }
} LIMIT 10

Get all available types from the repository

SELECT DISTINCT ?types WHERE {
  ?s rdf:type ?types
} ORDER BY ?types

Search including various LOM elements, language, and regexp

SELECT ?context ?uri ?title ?desc WHERE {
  GRAPH ?context {
    ?uri dcterms:title ?title ;
      dcterms:audience lomvoc:IntendedEndUserRole-learner ;
      lom:copyrightAndOtherRestrictions "false"^^xsd:boolean ;
      lom:status lomvoc:Status-final ;
      dcterms:description ?b .
      ?b rdf:value ?desc .
    FILTER(
      langMatches(lang(?title),"en") &&
      langMatches(lang(?desc),"en") &&
      regex(str(?title), "^organic", "i")
    )
  }
}

I’ll probably post some more examples soon, I provided the examples above only to get the interested ones started. I also hope to be able to upgrade to SPARQL 1.1 soon (the Sesame guys are working on it; looking forward to the next release!), which provides a more complex query syntax/logic.

Long time no blog post

Leave a reply

It feels as if it is time again to start blogging, there are some things to write about which do not fit into the traditional scientific publication format. I guess blog posts are an appropriate complementary medium. I moved my blog from electricbum.wordpress.com (including all old posts) over to this one and will only post here in the future.

Stay tuned for some upcoming blog posts on Linked Data in the fields of Educational Metadata and Sustainability (mainly environmental).

New release of Java 1.5

Leave a reply

Sun released Java 1.5.0_17 today. This release fixes (among other things) the regression bug of Java 1.5.0_16 which made it impossible to view and edit metadata in Conzilla. I wrote about this in a previous blog post.

Generally I recommend to use Java 1.6, but if you have to use 1.5 for some reason you can get the new version directly from Sun.