Merge pull request #407 from JuliaRobotics/master

v0.7.5-rc1

Author: dehann

.travis.yml

@@ -1,6 +1,6 @@
 language: julia
 sudo: required
-dist: trusty
+# dist: trusty
 
 os:
     - linux
@@ -22,9 +22,14 @@ env:
 jobs:
   include:
     - julia: 1.3
+      dist: trusty
       env: IIF_TEST=true
       if: NOT branch =~ ^release.*$
-    # - arch: arm64
+      # Set the password for Neo4j to neo4j:test
+      before_script:
+        - sleep 10
+        - curl -v POST http://neo4j:neo4j@localhost:7474/user/neo4j/password -d"password=test"
+    - arch: arm64
     - stage: "Documentation"
       julia: 1.3
       os: linux
@@ -35,17 +40,27 @@ jobs:
   fast_finish: true
   allow_failures:
       - julia: nightly
-      # - arch: arm64
+      - arch: arm64
       #- env: IIF_TEST=true
 
 notifications:
     email: false
 
 
-# Set the password for Neo4j to neo4j:test
-before_script:
-    - sleep 10
-    - curl -v POST http://neo4j:neo4j@localhost:7474/user/neo4j/password -d"password=test"
+# Attempt to install neo4j on Xenial and set the password for Neo4j to neo4j:test
+# Cloud tests errors with authentication error
+#before_script:
+#   - sudo add-apt-repository -y ppa:openjdk-r/ppa
+#   - sudo apt-get update
+#   - wget -O - https://debian.neo4j.com/neotechnology.gpg.key | sudo apt-key add -
+#   - echo 'deb https://debian.neo4j.com stable latest' | sudo tee -a /etc/apt/sources.list.d/neo4j.list
+#   - sudo apt-get update
+#   - apt list -a neo4j
+#   - sudo apt-get install neo4j=1:4.0.0
+#   - sudo service neo4j start
+#   - sleep 10
+#   - sudo neo4j-admin set-initial-password test
+#   - curl -I http://localhost:7474/
 
 after_success:
     - julia -e 'using Pkg; cd(Pkg.dir("DistributedFactorGraphs")); Pkg.add("Coverage"); using Coverage; Codecov.submit(process_folder())'

Project.toml

@@ -1,6 +1,6 @@
 name = "DistributedFactorGraphs"
 uuid = "b5cc3c7e-6572-11e9-2517-99fb8daf2f04"
-version = "0.7.4"
+version = "0.7.5"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -31,7 +31,7 @@ LightGraphs = "1.2, 1.3"
 Neo4j = "2"
 Reexport = "0.2, 0.3, 0.4, 0.5, 1"
 Requires = "0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 1"
-Unmarshal = "0.3"
+Unmarshal = "0.3, 0.4"
 julia = "1.2"
 
 [extras]

README.md

@@ -58,17 +58,17 @@ addFactor!(dfg, [v1, v2], DFGFactor{Int, :Symbol}(:f1)) # Rather use a RoME-type
 Please see the documentation for more information on interacting with the factor graph.
 
 ## Setting up a Quick Neo4j Database
-The simplest way to set up a test database is with Docker.
+The simplest way to set up a test database is with Docker. The Neo4j driver currenly doesn't work with Neo4j 4.0, version 3.5 can be used as in this example.
 
 To pull the Neo4j image:
 ```bash
-docker pull neo4j
+docker pull neo4j:3.5
 ```
 
 To run the image with user `neo4j` and password `test`:
 
 ```bash
-docker run -d --publish=7474:7474 --publish=7687:7687 --env NEO4J_AUTH=neo4j/test neo4j
+docker run -d --publish=7474:7474 --publish=7687:7687 --env NEO4J_AUTH=neo4j/test neo4j:3.5
 ```
 
 > **Note** If you just installed docker and having permission issues, please see [this ask Ubuntu forum](https://askubuntu.com/questions/941816/permission-denied-when-running-docker-after-installing-it-as-a-snap).

src/BigData/services/AbstractBigDataEntries.jl

@@ -20,7 +20,7 @@ end
     $(SIGNATURES)
 Add Big Data Entry to a DFG variable
 """
-function addBigDataEntry!(var::AbstractDFGVariable, bde::AbstractBigDataEntry)::AbstractBigDataEntry
+function addBigDataEntry!(var::AbstractDFGVariable, bde::AbstractBigDataEntry)
     haskey(var.bigData,bde.key) && error("BigData entry $(bde.key) already exists in variable")
     var.bigData[bde.key] = bde
     return bde
@@ -31,33 +31,63 @@ end
 Add Big Data Entry to distributed factor graph.
 Should be extended if DFG variable is not returned by reference.
 """
-function addBigDataEntry!(dfg::AbstractDFG, label::Symbol, bde::AbstractBigDataEntry)::AbstractBigDataEntry
+function addBigDataEntry!(dfg::AbstractDFG, label::Symbol, bde::AbstractBigDataEntry)
     return addBigDataEntry!(getVariable(dfg, label), bde)
 end
 
+addDataEntry!(x...) = addBigDataEntry!(x...)
+
+"""
+$(SIGNATURES)
+Add Big Data Entry to distributed factor graph.
+Should be extended if DFG variable is not returned by reference.
+"""
+function addDataEntry!(dfg::AbstractDFG,
+                       lbl::Symbol,
+                       descr::Symbol,
+                       mimeType::AbstractString,
+                       data::Vector{UInt8} )
+  #
+  node = isVariable(dfg, lbl) ? getVariable(dfg, lbl) : getFactor(dfg, lbl)
+  # Make a big data entry in the graph - use JSON2 to just write this
+  element = GeneralBigDataEntry(dfg, node, descr, mimeType=mimeType)
+  # Set it in the store
+  addBigData!(fec.datastore, element, data)
+  # Add the entry to the graph
+  addBigDataEntry!(node, element)
+end
+
+"""
+    $SIGNATURES
+
+Does a data entry (element) exist at `key`.
+"""
+hasDataEntry(var::DFGVariable, key::Symbol) = haskey(var.bigData, key)
+const hasBigDataEntry = hasDataEntry
+
 """
     $(SIGNATURES)
 Get big data entry
 """
-function getBigDataEntry(var::AbstractDFGVariable, key::Symbol)::Union{Nothing, AbstractBigDataEntry}
-    !haskey(var.bigData, key) && (error("BigData entry $(key) does not exist in variable"); return nothing)
+function getBigDataEntry(var::AbstractDFGVariable, key::Symbol)
+    !hasDataEntry(var, key) && (error("BigData entry $(key) does not exist in variable"); return nothing)
     return var.bigData[key]
 end
 
-function getBigDataEntry(dfg::AbstractDFG, label::Symbol, key::Symbol)::Union{Nothing, AbstractBigDataEntry}
+function getBigDataEntry(dfg::AbstractDFG, label::Symbol, key::Symbol)
     return getBigDataEntry(getVariable(dfg, label), key)
 end
 
 """
     $(SIGNATURES)
 Update big data entry
 """
-function updateBigDataEntry!(var::AbstractDFGVariable,  bde::AbstractBigDataEntry)::Union{Nothing, AbstractBigDataEntry}
+function updateBigDataEntry!(var::AbstractDFGVariable,  bde::AbstractBigDataEntry)
     !haskey(var.bigData,bde.key) && (@warn "$(bde.key) does not exist in variable, adding")
     var.bigData[bde.key] = bde
     return bde
 end
-function updateBigDataEntry!(dfg::AbstractDFG, label::Symbol,  bde::AbstractBigDataEntry)::Union{Nothing, AbstractBigDataEntry}
+function updateBigDataEntry!(dfg::AbstractDFG, label::Symbol,  bde::AbstractBigDataEntry)
     # !isVariable(dfg, label) && return nothing
     return updateBigDataEntry!(getVariable(dfg, label), bde)
 end
@@ -66,31 +96,36 @@ end
     $(SIGNATURES)
 Delete big data entry from the factor graph.
 Note this doesn't remove it from any data stores.
+
+Notes:
+- users responsibility to delete big data in db before deleting entry
 """
-function deleteBigDataEntry!(var::AbstractDFGVariable, key::Symbol)::Union{Nothing, AbstractDFGVariable} #users responsibility to delete big data in db before deleting entry
+function deleteBigDataEntry!(var::AbstractDFGVariable, key::Symbol)
     bde = getBigDataEntry(var, key)
     bde == nothing && return nothing
     delete!(var.bigData, key)
     return var
 end
-function deleteBigDataEntry!(dfg::AbstractDFG, label::Symbol, key::Symbol)::Union{Nothing, AbstractDFGVariable} #users responsibility to delete big data in db before deleting entry
+function deleteBigDataEntry!(dfg::AbstractDFG, label::Symbol, key::Symbol)
+    #users responsibility to delete big data in db before deleting entry
     !isVariable(dfg, label) && return nothing
     return deleteBigDataEntry!(getVariable(dfg, label), key)
 end
 
-function deleteBigDataEntry!(var::AbstractDFGVariable, entry::AbstractBigDataEntry)::Union{Nothing, AbstractDFGVariable} #users responsibility to delete big data in db before deleting entry
+function deleteBigDataEntry!(var::AbstractDFGVariable, entry::AbstractBigDataEntry)
+    #users responsibility to delete big data in db before deleting entry
     return deleteBigDataEntry!(var, entry.key)
 end
 
 """
     $(SIGNATURES)
 Get big data entries, Vector{AbstractBigDataEntry}
 """
-function getBigDataEntries(var::AbstractDFGVariable)::Vector{AbstractBigDataEntry}
+function getBigDataEntries(var::AbstractDFGVariable)
     #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractBigDataEntry}}?
     collect(values(var.bigData))
 end
-function getBigDataEntries(dfg::AbstractDFG, label::Symbol)::Union{Nothing, Vector{AbstractBigDataEntry}}
+function getBigDataEntries(dfg::AbstractDFG, label::Symbol)
     !isVariable(dfg, label) && return nothing
     #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractBigDataEntry}}?
     getBigDataEntries(getVariable(dfg, label))
@@ -101,10 +136,10 @@ end
     $(SIGNATURES)
 getBigDataKeys
 """
-function getBigDataKeys(var::AbstractDFGVariable)::Vector{Symbol}
+function getBigDataKeys(var::AbstractDFGVariable)
     collect(keys(var.bigData))
 end
-function getBigDataKeys(dfg::AbstractDFG, label::Symbol)::Union{Nothing, Vector{Symbol}}
+function getBigDataKeys(dfg::AbstractDFG, label::Symbol)
     !isVariable(dfg, label) && return nothing
     getBigDataKeys(getVariable(dfg, label))
 end

src/CloudGraphsDFG/entities/CloudGraphsDFG.jl

@@ -10,6 +10,7 @@ mutable struct CloudGraphsDFG{T <: AbstractParams} <: AbstractDFG
     userId::String
     robotId::String
     sessionId::String
+    description::String
     encodePackedTypeFunc
     getPackedTypeFunc
     decodePackedTypeFunc
@@ -26,38 +27,41 @@ function CloudGraphsDFG{T}(neo4jConnection::Neo4j.Connection,
                             userId::String,
                             robotId::String,
                             sessionId::String,
+                            description::String,
                             encodePackedTypeFunc,
                             getPackedTypeFunc,
                             decodePackedTypeFunc,
                             rebuildFactorMetadata!;
                             solverParams::T=NoSolverParams()) where T <: AbstractParams
     graph = Neo4j.getgraph(neo4jConnection)
     neo4jInstance = Neo4jInstance(neo4jConnection, graph)
-    return CloudGraphsDFG{T}(neo4jInstance, userId, robotId, sessionId, encodePackedTypeFunc, getPackedTypeFunc, decodePackedTypeFunc, rebuildFactorMetadata!, Symbol[], solverParams)
+    return CloudGraphsDFG{T}(neo4jInstance, userId, robotId, sessionId, description, encodePackedTypeFunc, getPackedTypeFunc, decodePackedTypeFunc, rebuildFactorMetadata!, Symbol[], solverParams)
 end
 """
     $(SIGNATURES)
 Create a new CloudGraphs-based DFG factor graph by specifying the Neo4j connection information.
 """
 function CloudGraphsDFG{T}(host::String,
-                            port::Int,
-                            dbUser::String,
-                            dbPassword::String,
-                            userId::String,
-                            robotId::String,
-                            sessionId::String,
-                            encodePackedTypeFunc,
-                            getPackedTypeFunc,
-                            decodePackedTypeFunc,
-                            rebuildFactorMetadata!;
-                            solverParams::T=NoSolverParams()) where T <: AbstractParams
+                           port::Int,
+                           dbUser::String,
+                           dbPassword::String,
+                           userId::String,
+                           robotId::String,
+                           sessionId::String,
+                           description::String,
+                           encodePackedTypeFunc,
+                           getPackedTypeFunc,
+                           decodePackedTypeFunc,
+                           rebuildFactorMetadata!;
+                           solverParams::T=NoSolverParams()) where T <: AbstractParams
     neo4jConnection = Neo4j.Connection(host, port=port, user=dbUser, password=dbPassword);
-    return CloudGraphsDFG{T}(neo4jConnection, userId, robotId, sessionId, encodePackedTypeFunc, getPackedTypeFunc, decodePackedTypeFunc, rebuildFactorMetadata!, solverParams=solverParams)
+    return CloudGraphsDFG{T}(neo4jConnection, userId, robotId, sessionId, description, encodePackedTypeFunc, getPackedTypeFunc, decodePackedTypeFunc, rebuildFactorMetadata!, solverParams=solverParams)
 end
 
 
 function show(io::IO, c::CloudGraphsDFG)
     println(io, "CloudGraphsDFG:")
     println(io, " - Neo4J instance: $(c.neo4jInstance.connection.host)")
     println(io, " - Session: $(c.userId):$(c.robotId):$(c.sessionId)")
+    println(io, " - Description: ", c.description)
 end