Author: wplaat

Apache fuseki on Raspberry Pi

# Install Docker
sudo apt install docker.io docker-compose -y

# Install Fuseki
sudo docker pull secoresearch/fuseki:latest
sudo docker run -d –name fuseki –restart unless-stopped -p 3030:3030 -v fuseki-data:/fuseki -e ADMIN_PASSWORD=admin -e ENABLE_DATA_WRITE=true -e ENABLE_UPDATE=true -e ENABLE_SHACL=true -e QUERY_TIMEOUT=100000 secoresearch/fuseki:latest

# Remove Fuseki
sudo docker stop fuseki
sudo docker remove fuseki

# Control Fuseki
sudo docker ps
sudo docker start fuseki
sudo docker stop fuseki

# Show Fuseki logging
sudo docker logs -f fuseki

Kubernetes on Raspberry Pi

# Install SNAP
sudo apt-get install snap

# Upgrade SNAP
sudo snap install snapd

# Install kubernetes on master node
sudo snap install microk8s –classic

# Check kubernetes master node status
sudo snap run microk8s kubectl get all –all-namespaces

# Analyze failing pod
sudo snap run microk8s kubectl describe pod -n
sudo snap run microk8s kubectl describe pod calico-node-w75q9 -n kube-system

# Remove kubernetes on master node
sudo snap remove microk8s
sudo snap remove core20

PlaatRisk 0.4.0

The next version of PlaatRisk is released

Version 0.4.0 (12-04-2025)
– Frontend: Make it compliant with backend again
– Frontend: Now Popup also show info for City without Player
– Backend: Added graph datastore (Apache Fuseki)
– Backend: Added game reset logic
– Backend: Geometry of new city if automatically added
– Backend: Added BAG service connection

Screenshot of the game

Example of OWL Turtle file

PREFIX ex:
PREFIX geo:
PREFIX owl:
PREFIX rdf:
PREFIX rdfs:
PREFIX xsd:

ex:Army rdf:type owl:Class;
rdfs:comment “A class representing army.”@en;
rdfs:label “Army” .

ex:hasArmy rdf:type owl:ObjectProperty;
rdfs:comment “The player has army.”@en , “The city has army.”@en;
rdfs:domain ex:Player , ex:City;
rdfs:label “has army”;
rdfs:range ex:Army .

ex:City rdf:type owl:Class;
rdfs:comment “A class representing city.”@en;
rdfs:label “City” .

ex:hasPlayer rdf:type owl:ObjectProperty;
rdfs:comment “The army has player.”@en;
rdfs:domain ex:Army;
rdfs:label “has player”;
rdfs:range ex:Player .

ex:hasCity rdf:type owl:ObjectProperty;
rdfs:comment “The army has city.”@en;
rdfs:domain ex:Army;
rdfs:label “has city”;
rdfs:range ex:City .

geo:hasGeom rdf:type owl:DatatypeProperty;
rdfs:comment “The city has geom.”@en;
rdfs:domain ex:City;
rdfs:label “has geom”;
rdfs:range geo:wktLiteral .

ex:hasConnection rdf:type owl:ObjectProperty;
rdfs:comment “The city has connection.”@en;
rdfs:domain ex:City;
rdfs:label “has connection”;
rdfs:range ex:City .

geo:hasCrs rdf:type owl:DatatypeProperty;
rdfs:comment “The city has crs.”@en;
rdfs:domain ex:City;
rdfs:label “has crs”;
rdfs:range .

ex:hasName rdf:type owl:DatatypeProperty;
rdfs:comment “The army has name.”@en , “The player has name.”@en , “The city has name.”@en;
rdfs:domain ex:Army , ex:Player , ex:City;
rdfs:label “has name”;
rdfs:range xsd:string .

ex:hasProduction rdf:type owl:DatatypeProperty;
rdfs:comment “The city has production.”@en;
rdfs:domain ex:City;
rdfs:label “has production”;
rdfs:range xsd:integer .

ex:hasSize rdf:type owl:DatatypeProperty;
rdfs:comment “The army has size.”@en;
rdfs:domain ex:Army;
rdfs:label “has size”;
rdfs:range xsd:integer .

ex:Player rdf:type owl:Class;
rdfs:comment “A class representing player.”@en;
rdfs:label “Player” .

ex:hasEmail rdf:type owl:DatatypeProperty;
rdfs:comment “The player has email.”@en;
rdfs:domain ex:Player;
rdfs:label “has email”;
rdfs:range xsd:string .

PlaatRisk 0.2.0

The next version of PlaatRisk is released

Version 0.2.0 (23-03-2025)
– Frontend: Added keyboard map control logic
– Frontend: Added Player name + army size in Polygon
– Frontend: Change screen layer (map / detail part)
– Frontend: Added polygon background color based on player
– Frontend: Added realtime x, y mouse position on map
– Frontend: Added scale information on map
– Frontend: Connect to Backend WFS/GML endpoint based on BBOX< - Frontend: Added Release Notes page - Backend: Added WFS/GML POST endpoint - Backend: Added WFS/GML GET endpoint

PlaatRisk 0.1.0

The first version of PlaatRisk is released

Version 0.1.0 (14-03-2025)
– Frontend: Create GUI based on OpenLayers
– Frontend: Connect to Backend WFS/GeoJSON endpoint
– Backend: Added some Land, Army and Road geography data
– Backend: Added WFS/GeoJSON GET endpoint
– Backend: Added WFS/XSD GET endpoint
– Backend: Added Jenkinsfile pipeline configuration
– Start development

IntelliJ add untrusted certificate

Step 1:
Run the standard keytool to import the certificate to JVM
keytool -import -alias -keystore cacerts -file
When prompted Enter keystore password:, enter “changeit”
When prompted Trust this certificate? [no]:, enter “yes”

Step 2:
Start IntelliJ
On IntelliJ op goto Setting -> Tools -> Server Certificates
On the box Accepted certificates click the plus icon (+)
Search the certificate filename and click Apply and OK

Install Jenkins native on Raspberry Pi

# Basic installation of Jenkins latest LTS version
sudo wget -O /usr/share/keyrings/jenkins-keyring.asc https://pkg.jenkins.io/debian/jenkins.io-2023.key
echo “deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc]” https://pkg.jenkins.io/debian binary/ | sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null
sudo apt-get update
sudo apt-get install fontconfig openjdk-17-jre
sudo apt-get install jenkins
sudo apt-get install maven
sudo apt-get install gradle

Now the Jenkins UI is available on port 8080
Answer some extra installation questions and wait for the installation to complete.

# Enable Maven in Jenkins
Goto Jenkins UI
Go to “Manage Jenkins” -> “Plugins” -> “Available Plugins” -> Select “Maven integration plugin”
Go to “Manage Jenkins” -> “Tool” -> “Maven installations”
Press “Add Maven”
Select “MAVEN_HOME”
Enter “/usr/share/maven”
Press “Save”

# Enable Gradle in Jenkins
Goto Jenkins UI
Go to “Manage Jenkins” -> “Plugins” -> “Installed Plugins” -> Select “Gradle plugin”
Press “Enable plugin”
Press “Save”
Restart Jenkins
Go to “Manage Jenkins” -> “Tools” -> “Gradle installations”
Press “Add Gradle”
Select “GRADLE_HOME”
Enter “/usr/share/gradle”
Press “Save”

# Create Project (Public GitHub REPO)
Goto Jenkins UI
Select “New Item”
Enter Project Name
Select “Maven Project”
Press “Ok”
Select “Source Code Management”
Select “GIT”
Enter by Repository URL the GIT URL
Press “Save”
Press “Build”
Now project will be build and all unit tests are automatic run.

# Create GitHub REPO Access key
Goto GitHub UI
Select “Setting” -> “Developer Settings”
Select “Personal access token” -> “Tokens (classic)”
Press “Generate new Token (Classic)”
Enter Name
Select “No expiration”
Select “all scopes”
Press “Generate Token”
Copy token key to clipboard

# Create jenkins Maven Project
Select “New Item”
Enter Project Name
Select “Maven Project”
Press “Ok”
Select “Source Code Management”
Select “GIT”
Enter by Repository URL the GIT URL
Select “Credentials” -> “Add” -> “Jenkins”
Select “Username with password”
Enter “Username” -> Its your Github username
Enter “Password” -> Copy token key from clipboard
Select “Threat username as secret”
Press “Save”
Press “Build”
Now project will be build and all unit tests are automatic run.

PlaatDomotica 2.0.0

PlaatSoft has released a new version of PlaatDomotica.

Version 2.0.0 (13-10-2024)

  • Major rewrite – Split frontend and backend logic
  • Added table paginating logic
  • Switch from H2 to Postgres database
  • Upgrade Java to 17
  • Upgrade Spring Core to 3.3.4
  • Upgrade Spring Thymeleaf WebUI to 3.3.4
  • Upgrade Spring Security to 1.3.2
  • Upgrade Tomcat to 10.1.30
  • Upgrade JSON library to 20240303
  • Added Lombok 1.18.34

More information click here

RDF vs Property GRAPH (NoSQL) database

RDF Graph example (Query language: SPARQL)

As a framework for representing the Web, Resource Description Framework (RDF) captures structure using a triple, the basic unit in RDF. A triple is a statement with three elements: two nodes connected by an edge (also known as a relationship). Each triple is identified by a Uniform Resource Identifier (URI) as subject-predicate-object:

– The subject is a resource (node) in the graph;
– The predicate represents an edge (relationship)
– The object is another node or a literal value.

More information:
https://rdf4j.org/documentation/tutorials/getting-started/

Property Graph example (Query Language: Cypher)

Information is organized as nodes, relationships, and properties in a property graph. Nodes are tagged with one or more labels, identifying their role in the network. Nodes can also store any number of properties as key-value pairs. Relationships provide directed, named connections between two nodes. Relationships always have a direction, a type, a start node, and an end node, and they can have properties, just like nodes. Although relationships are always directed, they can be navigated efficiently in either direction.


What is the difference between SPARQL and Cypher Query Language?
– SPARQL is the query language for accessing data in the Resource  description Framework (RDF) GRAPH database.
– Cypher is the corresponding language for the data represented in property GRAPH database

More information:
https://neo4j.com/blog/rdf-vs-property-graphs-knowledge-graphs/

Cypher queries examples

INSERT
CREATE (diana:Person {name: “Diana”})
CREATE (melissa:Person {name: “Melissa”, twitter: “@melissa”})
CREATE (xyz:Company {name: “XYZ”})
CREATE (diana)-[:WORKS_FOR]->(xyz)
CREATE (diana)-[:IS_FRIENDS_WITH]->(melissa)

UPDATE
MATCH (p:Person {name: ‘Diana’}) SET p.birthdate = date(‘1980-01-01’)
MATCH (:Person {name: ‘Diana’})-[rel:WORKS_FOR]-(:Company {name: ‘XYZ’}) SET rel.startYear = date({year: 2018})

DELETE
MATCH (j:Person {name: ‘Diana’})-[r:IS_FRIENDS_WITH]->(m:Person{name: ‘Melissa’}) DELETE j,r,m

SELECT
MATCH (p:Product) RETURN p.productName, p.unitPrice ORDER BY p.unitPrice DESC LIMIT 10;

SPARQL examples

INSERT

PREFIX plaat: <http://www.plaatsoft.nl/>
INSERT DATA {
<http://leerling/1> plaat:firstName “Kees”.
<http://leerling/2> plaat:firstName “Jan”.
<http://leerling/3> plaat:firstName “Piet”.
<http://leerling/4> plaat:firstName “Klaas”.
<http://school/1> plaat:name “Bospark”.
<http://school/1> plaat:level “LTS”.
<http://school/1> plaat:city “Alphen aan den Rijn”.
<http://school/2> plaat:name “Lammerschans”.
<http://school/2> plaat:level “MTS”.
<http://school/2> plaat:city “Leiden”.
<http://school/3> plaat:name “Hogeschool van Utrecht”.
<http://school/3> plaat:level “HTS”.
<http://school/3> plaat:city “Utrecht”.
<http://leerling/1> plaat:school <http://school/1>.
<http://leerling/1> plaat:school <http://school/2>.
<http://leerling/1> plaat:school <http://school/3>.
<http://leerling/2> plaat:school <http://school/1>.
<http://leerling/3> plaat:school <http://school/2>.
}

QUERY
# Show all leerlingen of school1
PREFIX plaat: <http://www.plaatsoft.nl/>
SELECT ?x ?firstName
WHERE
{
?x plaat:firstName ?firstName.
?x plaat:school <http://school/1>
}

DELETE
PREFIX plaat: <http://www.plaatsoft.nl/>
DELETE { ?x plaat:firstName ‘Kees’ }
WHERE { ?x plaat:firstName ‘Kees’ }

UPDATE (SPARQL use delete / insert pattern)
PREFIX plaat: <http://www.plaatsoft.nl/>
DELETE { ?x plaat:firstName ‘Kees’ }
INSERT { ?x plaat:firstName ‘William’ }
WHERE { ?x plaat:firstName ‘Kees’ }

Activate GIT SSH key access

Generate ssh key
ssh-keygen -t ed25519 -C “blabla@gmail.com”

Fetch public key content
notepad C:\Users\blabla\.ssh\id_ed25519.pub

Go https://github.com/settings/keys
Press “add public SSH key”
Fill form + public key content

Go to eclipse
Select menu Windows -> Preferences -> General -> Network Connections -> SSH2
Add here your secure key.

The GIT communication is now based on SSH instead op HTTPS.