Configure Neo4j 4.x database connection in PDI

Configure Neo4j 4.x database connection in PDI

Once your Pentaho server is installed and working, you will want to establish a connection to your Neo4j database.

This tutorial will show you how to enable connectivity between Pentaho and Neo4j:

What you need to before you begin

Configured and running Neo4j 4.x database server Configured and working Pentaho Data Integration 9.x server Neo4j JDBC database driver Pentaho PDI neo4j output plugin

Because I frequently use both the generic "Execute SQL script" tasks - which uses the generic PDI database connections and supports multi-transaction CYPHER statements, and ALSO the open source Neo4j output plugin by @mattcasters because it handles data maps and parameters passed from other steps WAY more elegantly than the "Execute SQL script" task.  We will need to configure two neo4j database configurations.

For this tutorial the neo4j server is the same server as the Pentaho Data Integration server. (So you will see the 127.0.0.1 address) - If you have these on separate computers, either use the FQDN or IP address of your neo4j server in the various name/address fields.

1. Download the latest Neo4j database JDBC driver and place the jar file in the /lib folder of your Pentaho server installation.
   
   
   
   
   
   
2. Download the latest PDI neo4j output plugin, unzip and place the neo4j output folder in the /plugins folder of your Pentaho server installation.
   
   
   
   
   


3. Launch Spoon
   Create a new transformation, and select the "Execute SQL Script" Step and drag it onto the transformation.
   
   
   
   
   
4. View the properties dialog
   by double clicking on it, or right-click → Edit
   Then on the Connection property, click New
   
   
   
   
   
5. Use the following Connection Settings:
   Use the following settings (These would be typical settings for a default neo4j installation.  You may need to customize these according to your server settings):
   

   Connection Name	<A unique descriptive name>
   Connection Type	Generic database
   Access	Native (JDBC)
   Custom connection URL	jdbc:neo4j:bolt://<servername>:<bolt port>
   Custom driver class name	org.neo4j.jdbc.Driver *note this is case sensitive!
   Username	<neo4j username>
   Password	<neo4j password>

   
   
   
   
6. Click "Test" and verify connectivity to your neo4j database
   
   If successful you should see the following message:
   
   
   
   
   
7. "SHARE" this database connection
   with other transformations/jobs, otherwise you would have to repeat these steps for EACH Transformation/Job.
   
   Switch from the Design to the View Tab
   
   

   

   
   
   
   
8. Expand Database connections

   

   Right-Click on your new database connection and select Share
   
   You will know the connection is shared if it is displayed in "BOLD"
   
   Now this connection is available to all jobs/transformations for this installation of Spoon/PDI
   
   Now you have a Neo4j data connection for all the generic tasks that support SQL style tasks.  Next we want configure the custom Neo4j Output plugin:
   
   
9. At the top under the Neo4j header select "Create connection"
   
   
   
   
   
10. Use the following settings (These would be typical settings for a default neo4j installation.  You may need to customize these according to your server settings):
    
    

    Connection name	<A unique descriptive name> I use the same connection name as above to keep things simple!
    Server or IP address	<address of your neo4j server>
    Database name (4.0)	neo4j
    Version 4 database?	checked
    Bolt Port	7687
    Browser Port	7474
    Use routing, neo4j:// protocol	unchecked
    Routing Policy
    Username	<neo4j username>
    Password	<neo4j password>
    Use encryption

    
    
    
    
    
11. Click Test to verify your connection
    
    
    
    
    
12. Now you can use The Neo4j functions like Neo4J Output, Neo4j Cypher, Graph Output and others.  Here's an article that dives much deeper into their functionality.

Configuring Pentaho Data Integration (PDI) on Windows

Configuring Pentaho Data Integration (PDI) / Kettle community edition on Windows:

This short tutorial will focus on Setting up a PDI server to ingest data from RangerMSP into Neo4j.
You should first setup and configure a working Neo4j 4.x server (it can be on the same server).  

What you need to before you begin

System Requirements: Prepare Windows for Install Virtually all modern desktop/server OS are supported JAVA x64 (OpenJDK/OracleJDK) 8.x Neo4j Server, Developer or Desktop Edition Pentaho 9.x Community Edition Download here Be aware the latest neo4j DB (4.x) requires JAVA 11.  PDI requires 8, so you will need to install BOTH!

1. Verify the JAVA_HOME system variable.  For my installation I used the OpenJDK so the path was C:\Program Files\AdoptOpenJDK\jre-8.0.265.01-hotspot
   
   
2. Extract the archive into the folder you want to be your installation folder
   
   
3. Navigate to the installation folder and run spoon.bat
   
   
   
   
   
4. IF you see the _PENTAHO_JAVA variable point to a JAVA version other than 8 then prepend a proper path to the JAVA version 8 at the beginning of the spoon.bat:
   
   

   SET JAVA_HOME =C:\Program Files\AdoptOpenJDK\jre-8.0.265.01-hotspot
   
   
5. BE PATIENT.  It takes a little while to load.  After a moment you should see the Pentaho Data Integration splash screen:
   
   

   
   
   This will stay on the screen for a minute or so, and then the program will finish loading.
   If all went well you should now see the welcome screen:
   
   
   
   
   
   
6. Ok - now we need some connectivity.  You want to query a Microsoft SQL Server database right?   Of course you do!  Why not?
   
   First Download the Microsoft JDBC driver for MS SQL Server.
   
   Extract the contents.
   
   
7. Copy the mssql-jdbc.x.y.z.jre8.jar into the \lib folder of your PDI installation folder (assuming you are using JAVA JRE/JDK v8.  That's it!  next time you launch spoon it will have the SQL jdbc driver available.
   
   For some more data connectivity examples see the following:
   

• Configuring Neo4j 4.x data connectivity in PDI
• Configuring RangerMSP (Advantage SQL) data connectivity in PDI

Configuring Neo4j 4.x server on Windows

Configuring Neo4j 4.x server on Windows:

This is an update from a previous article based on Neo4j v3.x

Yes, there are plenty of tutorials for setting up Neo4j already, but I wanted to focus on a few settings that makes it easier to use it with data integration.

This tutorial will focus on Neo4j server for windows.  It is NOT very complicated, and you'll be up and running in no time flat:

What you need to before you begin

System Requirements: Virtually all modern desktop/server OS are supported JAVA (OpenJDK/OracleJDK/ZuluJDK) 11 Neo4j Server or Desktop Edition.For these instructions I used the community edition which you can download from https://neo4j.com/download-center/#community

1. Extract the archive into the folder you want to be your installation folder
2. Use an editor to modify /conf/neo4j.conf

   Setting	Action	Description
   #dbms.directories.import=import	Comment out	allows custom imports on-demand
   apoc.import.file.enabled=true dbms.security.procedures.allowlist=apoc.coll.*,apoc.load.*,gds.*,apoc.* dbms.security.procedures.unrestricted=apoc.schema.*	add	Allow APOC file imports and apoc procedures
   #dbms.memory.heap.initial_size=5g #dbms.memory.heap.max_size=5g #dbms.memory.pagecache.size=7g	customize memory	Memory configuration will depend on how large your graphDB will become.  Here's a good primer:  https://neo4j.com/docs/operations-manual/current/tools/neo4j-admin-memrec/
   dbms.connectors.default_listen_address=0.0.0.0	uncomment	Allows non-local connections



3. Example Configuration for Plugins*:
   

   Plugin	Description	Download URL	Notes
   APOC library	Don't ask, just install it.  No really!  You want this.	https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/	Install binary .jar into /plugins folder: You need to MATCH the APOC version with the Neo4j version!
   MSSQL JDBC	Add this if you need to connect to MS SQL	https://go.microsoft.com/fwlink/?linkid=2168495	Extract mssql-jdbc-9.x.x.jre11.jar into /plugins folder
   Excel (multiple file formats)	If you need support to import from these formats download the dependencies	https://repo1.maven.org/maven2/org/apache/poi/poi/5.0.0/poi-5.0.0-javadoc.jar https://repo1.maven.org/maven2/org/apache/poi/poi-ooxml/5.0.0/poi-ooxml-5.0.0.jar https://repo1.maven.org/maven2/org/apache/poi/poi-ooxml-schemas/4.1.2/poi-ooxml-schemas-4.1.2.jar https://repo1.maven.org/maven2/org/apache/xmlbeans/xmlbeans/5.0.2/xmlbeans-5.0.2.jar https://repo1.maven.org/maven2/com/github/virtuald/curvesapi/1.06/curvesapi-1.06.jar	Place these .jar files into the /plugins folder
   Advantage Database JDBC	To connect to Advantage (sybase) SQL  via JDBC	https://devzone.advantagedatabase.com/dz/content.aspx?Key=20&Release=19&Product=12	This is to support the CRM I use (RangerMSP)


*For most of my installations I ONLY install the APOC plugin.  This is because I typically use an ETL tool like Pentaho Data Integration for ingesting data from other sources (Excel, JDBC, etc), rather than natively from a Neo4j cypher query.  This makes it easier to manage security, tasks and jobs  rather than hard-coding right into a CYPHER statement.


4. Configure Windows Service
   Neo4j should be configured to run as a Windows service. Launch a command shell, and install the service from within the /bin folder
   
   
   neo4j install-service
   
   
   If you are upgrading from an older version, you will need to first unregister the service for the old version:
   neo4j uninstall-service
     
5. Set Initial Password
   neo4j-admin set-initial-password mysupersecretpassword
   
   
6. Start the service
   sc start neo4j
   (or use the service control panel)
   
   
7. Verify your installation.  Browse to http://127.0.0.1:7474
   username: neo4j
   password: <same as you supplied on step 5>
   
   

   

   
   
   That's it!  You should be ready to go with a neo4j server that's ready to connect to SQL Server, import from CSV/XLS files, and you will have the APOC library plugins at your disposal!

Neo4J Installation on CentOS

note: This was some internal documentation I wrote a couple years ago.. based on neo4j 3.5.14 for CentOS, but with some small adjustments you can perform against newer versions, and other Linux distros..

# Patch your new CentOS installation:

yum -y update

yum -y install epel-release

# I like htop

yum -y install htop

# First, you'll need the yum repository and key.

rpm --import https://debian.neo4j.org/neotechnology.gpg.key

cat <<EOF>  /etc/yum.repos.d/neo4j.repo

[neo4j]

name=Neo4j RPM Repository

baseurl=https://yum.neo4j.org/stable

enabled=1

gpgcheck=1

EOF

# View available versions/editions:

yum list neo4j

# I'm going to install the latest community edition, so here we go:

yum -y install neo4j-3.5.14-1

#verify installation

rpm -qa | grep neo

# Increase the open file limits for the neo4j service

#https://community.neo4j.com/t/warning-max-1024-open-files-allowed-minimum-of-40000-recommended-see-the-neo4j-manual/3679/7

systemctl edit neo4j.service

# Paste the following values into the file and save:

* soft nofile 40000

* hard nofile 40000

#create firewall service template for neo4j bolt, http, and https protocols (modify if you do not want to allow all 3)

cat <<EOF>> /usr/lib/firewalld/services/neo4j.xml

<?xml version="1.0" encoding="utf-8"?>

<service>

  <short>neo4j</short>

  <description>Neo4j is an ACID-compliant graph database management system developed by Neo4j, Inc.  Neo4j supports clients using either the Bolt binary protocol or HTTP/HTTPS.</description>

    <port protocol="tcp" port="7687"/>

  <port protocol="tcp" port="7474"/>

  <port protocol="tcp" port="7473"/>

</service>

EOF

# Add our newly created service to the firewall, reload and verify

firewall-cmd --permanent --add-service=neo4j

firewall-cmd --reload

firewall-cmd --list-services

# If you have SELinux you'll need to do this as well:

semanage port -a -t http_port_t -p tcp 7474

semanage port -a -t http_port_t -p tcp 7473

semanage port -a -t http_port_t -p tcp 7687

# Change the default password

cd /usr/bin

neo4j-admin set-initial-password Password1

# Configure neo4j connector to allow network connections

# use an editor to modify /etc/neo4j/neo4j.conf

# uncomment the line dbms.connectors.default_listen_address=0.0.0.0 if you want to accept non-local network connections

#You should adjust your memory settings.  For recommendations see

# https://neo4j.com/docs/operations-manual/current/tools/neo4j-admin-memrec/

# Add any plugins.  I can't live without APOC, so here we go:

cd /var/lib/neo4j/plugins

wget https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/3.5.0.6/apoc-3.5.0.6-all.jar

# and because I am connecting with SQL Server, I will need the SQL JDBC 7.x jar

cd /tmp

wget https://download.microsoft.com/download/2/F/C/2FC75210-EDDE-464C-8E54-45C0291032FF/sqljdbc_7.0.0.0_enu.tar.gz

tar -xzf sqljdbc_7.0.0.0_enu.tar.gz

cp /tmp/sqljdbc_7.0/enu/mssql-jdbc-7.0.0.jre8.jar /var/lib/neo4j/plugins/

# I also want Advantage (SAP Sybase) JDBC:

cd /tmp

wget http://devzone.advantagedatabase.com/dz/download.aspx?Key=iE/9IfXlCOePTGOfVrmGwsL+4iRlo8+R -O adsinstall.jar

unzip adsinstall.jar -d /tmp/ads

cp /tmp/ads/jdbc/adsjdbc.jar  /var/lib/neo4j/plugins/

# Configure neo4j service to start automatically

systemctl enable neo4j

systemctl start neo4j

graph-commit project

graph-commit project: Powershell "interpreter" for Cypher

This is the evolution from my 2nd draft: Using Powershell to execute cypher scripts with secure credentials and logging results/errors.

What was the issue?

I was running several .cypher scripts as a scheduled task on Windows using cypher-shell to execute them.  This was fine, however my .cypher files had to provide plain-text to authenticate to various REST-API sites (and other datasources) I was using to feed my Neo4j database.  So I created some powershell credential storage/retrieval functions.

What was the other issue?
As I made changes to my scripts, I would inevitably write some syntax errors into my cypher scripts, and unknowingly break my import process.  But often, just break it a little.  Unless I manually ran each bit of code in the Neo4j Browser, I didn't have a simple method to verify or validate the results (or lack-thereof).

MY SOLUTION: A set of powershell scripts/cmdlets that would allow cypher execution and log the results (and some statistics meta-data), while showing syntax errors (exceptions) from the cypher.  I use the term "interpreter" loosely.

HOW IT WORKS:

• Provide a Cypher query language (cql) source file script that you wish to execute.  Be sure to replace any sensitive credentials or session keys with a unique string or "placeholder text" For example: mysecretvaluegoeshere
• Supply your Neo4j database destination & credentials by first using set-regcredentials.ps1
  
  
• Then supply any additional (API, web credentials) also using set-regcredentials.ps1
  
  Any credentials stored with set-regcredentials store the password (in the registry) with secure-string. This is relatively secure, as it can only be retrieved by the SAME username logged onto the SAME computer.  In a future version I'd prefer the script retrieve credentials from a secure store like Vault (HashiCorp)
• When executing the commandline you can supply -creds1 (thru -creds4) to have the wrapper perform a find-replace based on the key/value pair you created with set-regcredentials.ps1
• Alternatively you can supply data in realtime on the commandline using the -findrep switch (then you supply json values of find/replace string pairs) This is useful for manual testing, or if you are supplying a dynamic sessionkey.  This would be common when authenticating to a WebAPI that gives you a one-time-use key for authorization.  We use this method when graphing data using the Veeam Backup Enterprise Manager webAPI.

Then execute your cypher by running get-cypher-results.ps1:
 POWERSHELL 

.\get-cypher-results.ps1 -Datasource 'N4jDataSource' -cypherscript 'C:\path-to-my-script\myscript.cypher' -logging 'N4jDataSource' -creds1 'mycredname'

Or let's say you wanted to embed some cypher execution within another powershell script.  You may do something like this:
 POWERSHELL 

cd "$env:programfiles\blue net inc\graph-commit"
. "$PSScriptRoot\bg-sharedfunctions.ps1" | Out-Null
$neo4jdatasource = "myn4jserver"
$scriptpath = -join ($PSScriptRoot,"\get-cypher-results.ps1")
$csp= "c:\the-path-to\my-source-script.cypher"
$frstring='{"mysecretvaluegoeshere":"1234567890abcd"}'
. $scriptPath -Datasource $neo4jdatasource -cypherscript $csp -logging $neo4jdatasource -findrep $frstring -verbosity 1

Results:

The get-cypher-results.ps1 will segment your script into individual transactions (a semicolon followed by a linefeed)

You can also give "sections" of your code a label by using the keyword section at the beginning of comments in the cypher script:

// section Main import routine to create (:Asset) nodes
...
Each transaction will be run and the metadata results will be (optionally) recorded in a log entry (per transaction).  The logging is done (of course) as a neo4j graph using the label (:Cypherlogentry) The following counter items will be recorded as properties:

ConstraintsAdded
ConstraintsRemoved
IndexesAdded
IndexesRemoved
LabelsAdded
LabelsRemoved
NodesDeleted
Notifications
Plan
Profile
PropertiesSet
RelationshipsCreated
RelationshipsDeleted
ResultAvailableAfter (how long did the transaction take to run)
StatementType
Version (of the target Neo4j server)
date (epoch when the transaction ran)
linenumber (of where this transaction begins in the script)
script (full path and filename of the .cypher script)
section (named section of code)
server: fqdn or IP and port of the neo4j server
source: name of the computer the powershell script was executed from
error: (any exception error thrown by the neo4j engine will be recorded here)
All transactions from a single .cypher script will be bookended by a "BEGIN SCRIPT" and "END SCRIPT" section marker, with the END SCRIPT logging a "ResultAvailableAfter" that is a sum of all the transactions within the script.

All entries for a particular script execution will be tied together with a relationship: -[:PART_OF_SCRIPT_EXECUTION]- The wrapper will complete the execution and supply some example cypher queries to return the error logging for that execution.

This gave me a method to quickly run batches of .cypher code against a neo4j database, and determine if I generated any exceptions, and log metadata to track trends for code sections.

GRAPH-COMMIT Installation procedure: 

PRE-REQUISITES:

Windows PC or server An existing neo4j database installation.  If you need help visit the Configuring Neo4j server post. Powershell v5.0 or newer DotNET neo4j driver (script will install if it is missing)

Script Repositories:

Github repo: pdrangeid/graph-commit Please review github code before running it in your environment!  Be safe folks!

powershell

set-executionpolicy remotesigned -scope Process

Run the following commands to download them from the git repositories via 
 POWERSHELL 

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
$client = new-object System.Net.WebClient
$client.DownloadFile("https://raw.github.com/pdrangeid/graph-commit/master/update-modules.ps1","$Env:Temp\update-modules.ps1")
. "$Env:Temp\update-modules.ps1"

The 'update-modules.ps1' script can be used to update graph-commit scripts automatically (or from other git repositories)  I use to to automatically update my own operational scripts via windows scheduled tasks.

Configure your Neo4j datasource by providing the servername and credentials.  This will also verify that you have the DotNet neo4j driver installed (will prompt to install for you if it is missing)

 POWERSHELL 

cd "$env:Programfiles\Blue Net Inc\Graph-Commit"
.\set-regcredentials.ps1 -credname myn4jserver -n4j

 

If you haven't already installed the Neo4j DotNet driver, click no, and then answer YES when prompted to install it for you.

You will be prompted within the powershell to confirm installation of the Neo4j driver.
If it is successfully installed you will next be prompted to verify the logical name for the Neo4j datasource to be stored:

Next provide the address for your Neo4j server.  Neo4j's binary binary protocol is bolt, and defaults to TCP port 7687.  You can customize this and use name or ip address.

If the Neo4j server was able to be verified you will be asked to provide logon credentials.

If your credentials are correct you should see something like this:



You are now ready to run your .cypher scripts via powershell.

Review the get-cypher-results.ps1 script for more detail, but the command line works as such:

.\get-cypher-results.ps1 -Datasource 'yourdatasource' -cypherscript 'path-to-cypher-source-code' -creds1 -findrep {json string for find/replace pairs}
There are examples of using the get-cypher-results powershell wrapper for Cypher in my other posts. 

• Create Veeam Graph
• Create vCenter Graph

Create Veeam Graph

via the Veeam Backup Enterprise Manager webAPI

Problem:

How can I identify VMs that were never properly configured for backups.  Or somehow aren't being backed up at the frequency intended?

Solution:

Create a knowledge graph with data from my Veeam backup servers in order to verify that backups were configured and running for intended VMs. 

For example: The data could be compared via query against data in your IT Asset Management that defines which machines are supposed to be protected.

You may find it helpful to also have your VMware data within your graph.  Here's how to do that.

The schema for this graph is fairly simple:

But enough of all that, on to the instructions!

Prerequisites:

Already installed the graph-commit project https://github.com/pdrangeid/graph-commit run on workstation that has connectivity to the Veeam Backup Enterprise Manager webAPI A Neo4j database server User credentials to access the neo4j database instance User credentials to access Veeam Backup Enterprise Manager webAPI Neo4j /plugins: Awesome Procedures on Cypher (APOC) Optional: the vCenter graph project https://github.com/pdrangeid/vmware-graph

Known Issues:

The scripts currently don't clean up after themselves.  I'm still working out exactly how often to purge old job data.  You could also just INIT the whole graph periodically. This graph isn't intended to import ALL information about backups.  It's focused on capturing the latest successful backup for each configured VM.

Installation: Steps (powershell)

Login using the account you intend to use (particularly if scheduling for automation) 

Now download the scripts to run the veeam data ingester from the github repositories via powershell:
This will result in the scripts being downloaded into %programfiles%\blue net inc\Graph-Commit"\

 POWERSHELL 

cd "$env:programfiles\blue net inc\graph-commit"
.\update-modules.ps1 -gitrepo pdrangeid/veeam-maint -gitfile purge-veeam.cypher
.\update-modules.ps1 -gitrepo pdrangeid/veeam-maint -gitfile init-veeam-wrapper.ps1
.\update-modules.ps1 -gitrepo pdrangeid/veeam-maint -gitfile init-veeam.cypher
.\update-modules.ps1 -gitrepo pdrangeid/veeam-maint -gitfile refresh-veeam.cypher
.\update-modules.ps1 -gitrepo pdrangeid/veeam-maint -gitfile refresh-veeam-last-backup.cypher

If this is the first time using your neo4j database with my scripts, you will need to identify your Neo4j server location and provide credentials.

This cmdlet will also verify you have the DotNET neo4j driver installed (The set-regcredentials cmdlet can install it automatically for you using the nuget package manager):
 POWERSHELL 

.\set-regcredentials.ps1 -credname myn4jserver -n4j

The prerequisites (Nuget, Neo4J dotNet driver) will be validated and prompted to be installed if missing.  Once complete it will validate connectivity to your neo4j database instance.  A successful result should look like this:

Now let's set our veeam credentials and store them in the registry.This will display a prompt for you to supply your veeam username and password.  This data will be stored in

HKEY_CURRENT_USER\Software\neo4j-wrapper\Credentials\yourveeamservername
The password will be stored as a securestring value which can only be decrypted on this computer when logged in as the user you are currently authenticated as now.

If successful you will see a message, you can also verify it in the registry:
 POWERSHELL 

.\set-regcredentials.ps1 -credname yourveeamservername -credpath "neo4j-wrapper\Credentials"

Let's test the script.  By using the -sessionkey switch we indicate we don't want to run the script, but just authenticate to the VeeamAPI and return a session key to use.
 POWERSHELL 

.\init-veeam-wrapper.ps1 -baseapiurl http://yourveeamserver:9399/api -veeamcred myveeam -neo4jdatasource myn4jserver -sessionkey

 

If you returned a proper session id that means the wrapper script was able to retrieve a session key for authentication.  Run the command again omitting the -sessionkey switch and adding the -init switch to run the script for real this time.

 POWERSHELL 

.\init-veeam-wrapper.ps1 -baseapiurl http://yourveeamserver:9399/api -veeamcred myveeam -neo4jdatasource myn4jserver -init

What does -init do?
The -init switch runs the initial ingestion of Veeam backups.  It also takes the longest.

a)  Creates (:Veeamserver) nodes
b)  Create (:Veeamjob) nodes, and relates them to their (:Veeamserver)
 

c) Creates (:Veeamprotectedvm) nodes (these are all the VMs that Veeam is aware of)

d) Finally it locates restore points to discover the MOST RECENT restore point for each (:Veeamprotectedvm)
Discovery is performed from most recent through 32 days old.  Once a valid restore point is discovered it stops trying to find valid restore points for that VM (remember, we're just trying to validate the most recent valid restore point for each protected asset)

If you have multiple Veeam backup servers, be sure to run the -init process for any additional Veeam API endpoints.
Now we want to put the Veeam backups into "buckets" identifying how recently they are backed up:

 POWERSHELL 

$scriptpath = "$env:programfiles\blue net inc\graph-commit\get-cypher-results.ps1"
$csp="$env:programfiles\blue net inc\graph-commit\refresh-veeam-last-backup.cypher"
. $scriptPath -Datasource 'myn4jserver' -cypherscript $csp -logging 'myn4jserver'

Finally, you can now run the lighter-weight "refresh" script periodically (I run it hourly).
You only need to re-run the "init" script if you want to purge the data and start over.

 POWERSHELL 

$scriptpath = "$env:programfiles\blue net inc\graph-commit\get-cypher-results.ps1"
$csp="$env:programfiles\blue net inc\graph-commit\refresh-veeam-last-backup.cypher"
. $scriptPath -Datasource 'myn4jserver' -cypherscript $csp -logging 'myn4jserver'

Review the Veeam data that was imported.  Here are some sample cypher queries that will present an explorable graph:
 CYPHER 

// SHOW veeam backups
MATCH (lgb:Lastgoodbackup)
MATCH (lgb)--(vvm:Veeamprotectedvm)
return lgb,vvm

Show specific Job information:

 CYPHER 

// Show jobs, backups, VMs, and lastgoodbackup for any jobs with 'exchange' in the job name
MATCH (vs:Veeamserver)--(vj:Veeamjob)--(vb:Veeambackup) where toLower(vj.name) contains 'exchange'
OPTIONAL MATCH (vb)--(vvm:Veeamprotectedvm)--(lgb:Lastgoodbackup)
return vs,vj,vb,vvm,lgb