introduce new node 'spaces'

current_nodes/spaces/json.lua

@@ -0,0 +1,377 @@
+-----------------------------------------------------------------------------
+-- JSON4Lua: JSON encoding / decoding support for the Lua language.
+-- json Module.
+-- Author: Craig Mason-Jones
+-- Homepage: http://json.luaforge.net/
+-- Version: 0.9.40
+-- This module is released under the MIT License (MIT).
+-- Please see LICENCE.txt for details.
+--
+-- USAGE:
+-- This module exposes two functions:
+--   encode(o)
+--     Returns the table / string / boolean / number / nil / json.null value as a JSON-encoded string.
+--   decode(json_string)
+--     Returns a Lua object populated with the data encoded in the JSON string json_string.
+--
+-- REQUIREMENTS:
+--   compat-5.1 if using Lua 5.0
+--
+-- CHANGELOG
+--   0.9.20 Introduction of local Lua functions for private functions (removed _ function prefix). 
+--          Fixed Lua 5.1 compatibility issues.
+--   		Introduced json.null to have null values in associative arrays.
+--          encode() performance improvement (more than 50%) through table.concat rather than ..
+--          Introduced decode ability to ignore /**/ comments in the JSON string.
+--   0.9.10 Fix to array encoding / decoding to correctly manage nil/null values in arrays.
+-----------------------------------------------------------------------------
+
+-----------------------------------------------------------------------------
+-- Imports and dependencies
+-----------------------------------------------------------------------------
+local math = require('math')
+local string = require("string")
+local table = require("table")
+
+local base = _G
+
+-----------------------------------------------------------------------------
+-- Module declaration
+-----------------------------------------------------------------------------
+module("json")
+
+-- Public functions
+
+-- Private functions
+local decode_scanArray
+local decode_scanComment
+local decode_scanConstant
+local decode_scanNumber
+local decode_scanObject
+local decode_scanString
+local decode_scanWhitespace
+local encodeString
+local isArray
+local isEncodable
+
+-----------------------------------------------------------------------------
+-- PUBLIC FUNCTIONS
+-----------------------------------------------------------------------------
+--- Encodes an arbitrary Lua object / variable.
+-- @param v The Lua object / variable to be JSON encoded.
+-- @return String containing the JSON encoding in internal Lua string format (i.e. not unicode)
+function encode (v)
+  -- Handle nil values
+  if v==nil then
+    return "null"
+  end
+  
+  local vtype = base.type(v)  
+
+  -- Handle strings
+  if vtype=='string' then    
+    return '"' .. encodeString(v) .. '"'	    -- Need to handle encoding in string
+  end
+  
+  -- Handle booleans
+  if vtype=='number' or vtype=='boolean' then
+    return base.tostring(v)
+  end
+  
+  -- Handle tables
+  if vtype=='table' then
+    local rval = {}
+    -- Consider arrays separately
+    local bArray, maxCount = isArray(v)
+    if bArray then
+      for i = 1,maxCount do
+        table.insert(rval, encode(v[i]))
+      end
+    else	-- An object, not an array
+      for i,j in base.pairs(v) do
+        if isEncodable(i) and isEncodable(j) then
+          table.insert(rval, '"' .. encodeString(i) .. '":' .. encode(j))
+        end
+      end
+    end
+    if bArray then
+      return '[' .. table.concat(rval,',') ..']'
+    else
+      return '{' .. table.concat(rval,',') .. '}'
+    end
+  end
+  
+  -- Handle null values
+  if vtype=='function' and v==null then
+    return 'null'
+  end
+  
+  base.assert(false,'encode attempt to encode unsupported type ' .. vtype .. ':' .. base.tostring(v))
+end
+
+
+--- Decodes a JSON string and returns the decoded value as a Lua data structure / value.
+-- @param s The string to scan.
+-- @param [startPos] Optional starting position where the JSON string is located. Defaults to 1.
+-- @param Lua object, number The object that was scanned, as a Lua table / string / number / boolean or nil,
+-- and the position of the first character after
+-- the scanned JSON object.
+function decode(s, startPos)
+  startPos = startPos and startPos or 1
+  startPos = decode_scanWhitespace(s,startPos)
+  base.assert(startPos<=string.len(s), 'Unterminated JSON encoded object found at position in [' .. s .. ']')
+  local curChar = string.sub(s,startPos,startPos)
+  -- Object
+  if curChar=='{' then
+    return decode_scanObject(s,startPos)
+  end
+  -- Array
+  if curChar=='[' then
+    return decode_scanArray(s,startPos)
+  end
+  -- Number
+  if string.find("+-0123456789.e", curChar, 1, true) then
+    return decode_scanNumber(s,startPos)
+  end
+  -- String
+  if curChar==[["]] or curChar==[[']] then
+    return decode_scanString(s,startPos)
+  end
+  if string.sub(s,startPos,startPos+1)=='/*' then
+    return decode(s, decode_scanComment(s,startPos))
+  end
+  -- Otherwise, it must be a constant
+  return decode_scanConstant(s,startPos)
+end
+
+--- The null function allows one to specify a null value in an associative array (which is otherwise
+-- discarded if you set the value with 'nil' in Lua. Simply set t = { first=json.null }
+function null()
+  return null -- so json.null() will also return null ;-)
+end
+-----------------------------------------------------------------------------
+-- Internal, PRIVATE functions.
+-- Following a Python-like convention, I have prefixed all these 'PRIVATE'
+-- functions with an underscore.
+-----------------------------------------------------------------------------
+
+--- Scans an array from JSON into a Lua object
+-- startPos begins at the start of the array.
+-- Returns the array and the next starting position
+-- @param s The string being scanned.
+-- @param startPos The starting position for the scan.
+-- @return table, int The scanned array as a table, and the position of the next character to scan.
+function decode_scanArray(s,startPos)
+  local array = {}	-- The return value
+  local stringLen = string.len(s)
+  base.assert(string.sub(s,startPos,startPos)=='[','decode_scanArray called but array does not start at position ' .. startPos .. ' in string:\n'..s )
+  startPos = startPos + 1
+  -- Infinite loop for array elements
+  repeat
+    startPos = decode_scanWhitespace(s,startPos)
+    base.assert(startPos<=stringLen,'JSON String ended unexpectedly scanning array.')
+    local curChar = string.sub(s,startPos,startPos)
+    if (curChar==']') then
+      return array, startPos+1
+    end
+    if (curChar==',') then
+      startPos = decode_scanWhitespace(s,startPos+1)
+    end
+    base.assert(startPos<=stringLen, 'JSON String ended unexpectedly scanning array.')
+    object, startPos = decode(s,startPos)
+    table.insert(array,object)
+  until false
+end
+
+--- Scans a comment and discards the comment.
+-- Returns the position of the next character following the comment.
+-- @param string s The JSON string to scan.
+-- @param int startPos The starting position of the comment
+function decode_scanComment(s, startPos)
+  base.assert( string.sub(s,startPos,startPos+1)=='/*', "decode_scanComment called but comment does not start at position " .. startPos)
+  local endPos = string.find(s,'*/',startPos+2)
+  base.assert(endPos~=nil, "Unterminated comment in string at " .. startPos)
+  return endPos+2  
+end
+
+--- Scans for given constants: true, false or null
+-- Returns the appropriate Lua type, and the position of the next character to read.
+-- @param s The string being scanned.
+-- @param startPos The position in the string at which to start scanning.
+-- @return object, int The object (true, false or nil) and the position at which the next character should be 
+-- scanned.
+function decode_scanConstant(s, startPos)
+  local consts = { ["true"] = true, ["false"] = false, ["null"] = nil }
+  local constNames = {"true","false","null"}
+
+  for i,k in base.pairs(constNames) do
+    --print ("[" .. string.sub(s,startPos, startPos + string.len(k) -1) .."]", k)
+    if string.sub(s,startPos, startPos + string.len(k) -1 )==k then
+      return consts[k], startPos + string.len(k)
+    end
+  end
+  base.assert(nil, 'Failed to scan constant from string ' .. s .. ' at starting position ' .. startPos)
+end
+
+--- Scans a number from the JSON encoded string.
+-- (in fact, also is able to scan numeric +- eqns, which is not
+-- in the JSON spec.)
+-- Returns the number, and the position of the next character
+-- after the number.
+-- @param s The string being scanned.
+-- @param startPos The position at which to start scanning.
+-- @return number, int The extracted number and the position of the next character to scan.
+function decode_scanNumber(s,startPos)
+  local endPos = startPos+1
+  local stringLen = string.len(s)
+  local acceptableChars = "+-0123456789.e"
+  while (string.find(acceptableChars, string.sub(s,endPos,endPos), 1, true)
+	and endPos<=stringLen
+	) do
+    endPos = endPos + 1
+  end
+  local stringValue = 'return ' .. string.sub(s,startPos, endPos-1)
+  local stringEval = base.loadstring(stringValue)
+  base.assert(stringEval, 'Failed to scan number [ ' .. stringValue .. '] in JSON string at position ' .. startPos .. ' : ' .. endPos)
+  return stringEval(), endPos
+end
+
+--- Scans a JSON object into a Lua object.
+-- startPos begins at the start of the object.
+-- Returns the object and the next starting position.
+-- @param s The string being scanned.
+-- @param startPos The starting position of the scan.
+-- @return table, int The scanned object as a table and the position of the next character to scan.
+function decode_scanObject(s,startPos)
+  local object = {}
+  local stringLen = string.len(s)
+  local key, value
+  base.assert(string.sub(s,startPos,startPos)=='{','decode_scanObject called but object does not start at position ' .. startPos .. ' in string:\n' .. s)
+  startPos = startPos + 1
+  repeat
+    startPos = decode_scanWhitespace(s,startPos)
+    base.assert(startPos<=stringLen, 'JSON string ended unexpectedly while scanning object.')
+    local curChar = string.sub(s,startPos,startPos)
+    if (curChar=='}') then
+      return object,startPos+1
+    end
+    if (curChar==',') then
+      startPos = decode_scanWhitespace(s,startPos+1)
+    end
+    base.assert(startPos<=stringLen, 'JSON string ended unexpectedly scanning object.')
+    -- Scan the key
+    key, startPos = decode(s,startPos)
+    base.assert(startPos<=stringLen, 'JSON string ended unexpectedly searching for value of key ' .. key)
+    startPos = decode_scanWhitespace(s,startPos)
+    base.assert(startPos<=stringLen, 'JSON string ended unexpectedly searching for value of key ' .. key)
+    base.assert(string.sub(s,startPos,startPos)==':','JSON object key-value assignment mal-formed at ' .. startPos)
+    startPos = decode_scanWhitespace(s,startPos+1)
+    base.assert(startPos<=stringLen, 'JSON string ended unexpectedly searching for value of key ' .. key)
+    value, startPos = decode(s,startPos)
+    object[key]=value
+  until false	-- infinite loop while key-value pairs are found
+end
+
+--- Scans a JSON string from the opening inverted comma or single quote to the
+-- end of the string.
+-- Returns the string extracted as a Lua string,
+-- and the position of the next non-string character
+-- (after the closing inverted comma or single quote).
+-- @param s The string being scanned.
+-- @param startPos The starting position of the scan.
+-- @return string, int The extracted string as a Lua string, and the next character to parse.
+function decode_scanString(s,startPos)
+  base.assert(startPos, 'decode_scanString(..) called without start position')
+  local startChar = string.sub(s,startPos,startPos)
+  base.assert(startChar==[[']] or startChar==[["]],'decode_scanString called for a non-string')
+  local escaped = false
+  local endPos = startPos + 1
+  local bEnded = false
+  local stringLen = string.len(s)
+  repeat
+    local curChar = string.sub(s,endPos,endPos)
+    -- Character escaping is only used to escape the string delimiters
+    if not escaped then	
+      if curChar==[[\]] then
+        escaped = true
+      else
+        bEnded = curChar==startChar
+      end
+    else
+      -- If we're escaped, we accept the current character come what may
+      escaped = false
+    end
+    endPos = endPos + 1
+    base.assert(endPos <= stringLen+1, "String decoding failed: unterminated string at position " .. endPos)
+  until bEnded
+  local stringValue = 'return ' .. string.sub(s, startPos, endPos-1)
+  local stringEval = base.loadstring(stringValue)
+  base.assert(stringEval, 'Failed to load string [ ' .. stringValue .. '] in JSON4Lua.decode_scanString at position ' .. startPos .. ' : ' .. endPos)
+  return stringEval(), endPos  
+end
+
+--- Scans a JSON string skipping all whitespace from the current start position.
+-- Returns the position of the first non-whitespace character, or nil if the whole end of string is reached.
+-- @param s The string being scanned
+-- @param startPos The starting position where we should begin removing whitespace.
+-- @return int The first position where non-whitespace was encountered, or string.len(s)+1 if the end of string
+-- was reached.
+function decode_scanWhitespace(s,startPos)
+  local whitespace=" \n\r\t"
+  local stringLen = string.len(s)
+  while ( string.find(whitespace, string.sub(s,startPos,startPos), 1, true)  and startPos <= stringLen) do
+    startPos = startPos + 1
+  end
+  return startPos
+end
+
+--- Encodes a string to be JSON-compatible.
+-- This just involves back-quoting inverted commas, back-quotes and newlines, I think ;-)
+-- @param s The string to return as a JSON encoded (i.e. backquoted string)
+-- @return The string appropriately escaped.
+function encodeString(s)
+  s = string.gsub(s,'\\','\\\\')
+  s = string.gsub(s,'"','\\"')
+  s = string.gsub(s,"'","\\'")
+  s = string.gsub(s,'\n','\\n')
+  s = string.gsub(s,'\t','\\t')
+  return s 
+end
+
+-- Determines whether the given Lua type is an array or a table / dictionary.
+-- We consider any table an array if it has indexes 1..n for its n items, and no
+-- other data in the table.
+-- I think this method is currently a little 'flaky', but can't think of a good way around it yet...
+-- @param t The table to evaluate as an array
+-- @return boolean, number True if the table can be represented as an array, false otherwise. If true,
+-- the second returned value is the maximum
+-- number of indexed elements in the array. 
+function isArray(t)
+  -- Next we count all the elements, ensuring that any non-indexed elements are not-encodable 
+  -- (with the possible exception of 'n')
+  local maxIndex = 0
+  for k,v in base.pairs(t) do
+    if (base.type(k)=='number' and math.floor(k)==k and 1<=k) then	-- k,v is an indexed pair
+      if (not isEncodable(v)) then return false end	-- All array elements must be encodable
+      maxIndex = math.max(maxIndex,k)
+    else
+      if (k=='n') then
+        if v ~= table.getn(t) then return false end  -- False if n does not hold the number of elements
+      else -- Else of (k=='n')
+        if isEncodable(v) then return false end
+      end  -- End of (k~='n')
+    end -- End of k,v not an indexed pair
+  end  -- End of loop across all pairs
+  return true, maxIndex
+end
+
+--- Determines whether the given Lua object / table / variable can be JSON encoded. The only
+-- types that are JSON encodable are: string, boolean, number, nil, table and json.null.
+-- In this implementation, all other types are ignored.
+-- @param o The object to examine.
+-- @return boolean True if the object should be JSON encoded, false if it should be ignored.
+function isEncodable(o)
+  local t = base.type(o)
+  return (t=='string' or t=='boolean' or t=='number' or t=='nil' or t=='table') or (t=='function' and o==null) 
+end
+

current_nodes/spaces/node.lua

@@ -0,0 +1,60 @@
+local INTERVAL = 1
+--local RAND_MAX = math.maxinteger -- FIXME
+local RAND_MAX = 10000
+
+gl.setup(NATIVE_WIDTH, NATIVE_HEIGHT)
+
+json = require "json"
+
+local font = resource.load_font("silkscreen.ttf")
+
+--util.loaders.json = function(filename)
+--    return json.decode(resource.load_file(filename))
+--end
+
+util.auto_loader(_G)
+
+
+function node.render()
+  local space = json.decode(resource.load_file("rand_valid_space.json"))
+  local status
+  local others = {}
+  local other
+
+  if space.data.state.open then
+    status = "open"
+  else
+    status = "closed"
+  end
+
+  if space.data.ext_ccc then
+    others[#others + 1] = space.data.ext_ccc
+  elseif space.lastSeen then
+    others[#others + 1] = os.date("%Y-%m-%d", space.lastSeen)
+  --elseif space.cam then
+  --'has cam'
+  end
+
+  font:write(50, 50, space.data.space, 150, 1.0, 1.0, .4, 1)
+  font:write(50, 300, status, 125, .7, 1.0, .7, 1)
+  font:write(50, 500, os.date("%d.%m %H:%m", space.lastSeen), 125, 1.0, .7, .7, 1)
+  font:write(50, 700, space.url, 50, .7, .7, .7, 1)
+  --if 0 ~= #others then
+  --  other = others[(math.random(#others)) + 1]
+  --  --other = others[1]
+  --  --font:write(200, 650, other, 150, 1.0, .7, .7, 1)
+  --  font:write(200, 650, math.random(#others), 150, 1.0, .7, .7, 1)
+  --end
+  if space.data.ext_ccc then
+    font:write(50, 850, space.data.ext_ccc, 125, 0, 1, 0, 1)
+  end
+
+
+  -- FIXME seems currently not to work
+  --local image = resource.load_image("rand_valid_space_logo.png")
+  --if image then
+  --  image:draw(0, 0, NATIVE_WIDTH, NATIVE_HEIGHT, 0.5)
+  --  --font:write(NATIVE_WIDTH-100, 850, "?", 150, 0, 1, .7, 1)
+  --end
+
+end

current_nodes/spaces/old_node.lua.bkup

@@ -0,0 +1,96 @@
+local INTERVAL = 1
+--local RAND_MAX = math.maxinteger -- FIXME
+local RAND_MAX = 10000
+
+gl.setup(NATIVE_WIDTH, NATIVE_HEIGHT)
+
+json = require "json"
+
+local font = resource.load_font("silkscreen.ttf")
+--local spaces = json.decode(resource.load_file("spaces.json"))
+
+util.loaders.json = function(filename)
+    return json.decode(resource.load_file(filename))
+end
+
+util.auto_loader(_G)
+
+function select_space(spaces)
+  local space = nil
+  while (space == nil) do
+    space = spaces[math.random(#spaces)]
+  end
+  return space
+end
+
+function next_space(spaces, idx)
+  local spaces_len = #spaces
+  local idx_tmp = idx % spaces_len
+  local space = spaces[idx_tmp]
+  while (space == nil) do
+    idx_tmp = (idx_tmp + 1) % spaces_len
+    space = spaces[idx_tmp]
+  end
+  return space, idx_tmp
+end
+
+--
+
+--spaces_gen = util.generator(function()
+--    local out = {}
+--    --for name, _ in pairs(CONTENTS) do
+--    --    if name:match(".*jpg") then
+--    --        out[#out + 1] = name
+--    --    end
+--    --end
+--    --out = select_space(spaces)
+--
+--    out = json.decode(resource.load_file("spaces.json"))
+--    --out = {"test-a", "test-b"}
+--    --out = spaces
+--    return out
+--end)
+--node.event("content_remove", spaces_gen.remove)
+
+
+util.set_interval(INTERVAL, function()
+    --local next_space_name = select_space(spaces)
+    --local next_space_name = select_space(spaces)
+    --local next_space_name = spaces_gen.next()
+    --print("now showing " .. next_space_name)
+    --current_space = type(spaces)
+    --current_space = spaces_gen
+    --current_space = next_space_name
+    test_idx = math.random(RAND_MAX)
+end)
+
+--
+
+function node.render()
+  local spaces_len
+  local space
+  local idx_next
+
+  idx_next = 3
+  space = spaces[idx_next]
+
+  --spaces_len = #spaces
+  ----space = select_space(spaces)
+  --space, idx_next = next_space(spaces, test_idx)
+
+  font:write(50, 50, "test", 150, 1.0, 1.0, .4, 1)
+  --font:write(0, 50, spaces[0].data.space, 47, .7, 1.0, .7, 1)
+  --font:write(0, 50, spaces[0].data.space, 47, .7, 1.0, .7, 1)
+  --font:write(0, 50, #spaces, 47, .7, 1.0, .7, 1)
+  --font:write(0, 50, space.data.space, 47, .7, 1.0, .7, 1)
+  --font:write(0, 50, spaces[1].data.space, 47, .7, 1.0, .7, 1)
+  --font:write(50, 400, space.data.space, 250, .7, 1.0, .7, 1)
+  --font:write(0, 50, type(current_space), 47, .7, 1.0, .7, 1)
+  --font:write(0, 50, current_space.data.space, 47, .7, 1.0, .7, 1)
+  --font:write(50, 400, test_idx, 250, .7, 1.0, .7, 1)
+  --font:write(50, 400, type(current_space), 250, .7, 1.0, .7, 1)
+
+  font:write(50, 250, idx_next, 150, .7, 1.0, .7, 1)
+  font:write(50, 450, space.data.space, 150, 1.0, .7, .7, 1)
+  font:write(50, 650, #space, 150, 1.0, .7, .7, 1)
+end

current_nodes/spaces/query_spaces

@@ -0,0 +1,110 @@
+#!/bin/sh
+
+BASEDIR=$(dirname $0)
+SPACES_JSON=$BASEDIR/spaces.json
+RAND_VALID_SPACE_LOGO_URL_FILE=$BASEDIR/rand_valid_space_logo_url.txt
+RAND_VALID_SPACE_LOGO=$BASEDIR/rand_valid_space_logo.png
+
+
+# jq '.[] | .data.space'
+# length of list (213):
+# jq '. | length'
+# jq '.[] | select(.data.state.open == true) | .data.space'
+# number of currently open spaces (62):
+# jq '[.[] | select(.data.state.open == true)] | .data.space'
+# number of valid spaces (157):
+# jq '[.[] | select(.valid == true)] | .data.space'
+# convert timestamp to date:
+# echo 1712681531 | jq 'todate'
+# random selection:
+# jq --argjson rand_i $RANDOM '$rand_i'
+# jq 'map (select (.data.state.open == true))' < spaces.json > spaces_online.json
+
+
+## random space name
+#RAND_I=$(od -vAn -N2 -tu2 < /dev/urandom)
+#jq \
+#	--argjson rand_i $RAND_I \
+#	-r \
+#'
+#  length as $array_length
+#
+#  | .[$rand_i % $array_length].data.space
+#' < $SPACES_JSON
+#
+#jq \
+#	--argjson rand_i $RAND_I \
+#	-r \
+#'
+#  length as $array_length
+#
+#  | .[$rand_i % $array_length].data.contact.email
+#' < $SPACES_JSON
+
+# whole random space
+RAND_I=$(od -vAn -N2 -tu2 < /dev/urandom)
+jq \
+	--argjson rand_i $RAND_I \
+	-r \
+'
+  length as $array_length
+
+  | .[$rand_i % $array_length]
+' < $SPACES_JSON > $BASEDIR/rand_space.json
+
+
+# random online space
+RAND_I=$(od -vAn -N2 -tu2 < /dev/urandom)
+jq \
+	--argjson rand_i $RAND_I \
+	-r \
+'
+  map (select (.data.state.open == true)) | length as $array_length
+
+  | .[$rand_i % $array_length]
+' < $SPACES_JSON > $BASEDIR/rand_online_space.json
+
+# random valid space
+RAND_I=$(od -vAn -N2 -tu2 < /dev/urandom)
+jq \
+	--argjson rand_i $RAND_I \
+	-r \
+'
+  map (select (.valid == true)) | length as $array_length
+
+  | .[$rand_i % $array_length]
+' < $SPACES_JSON > $BASEDIR/rand_valid_space.json
+
+# ... and its logo url
+jq \
+		--argjson rand_i $RAND_I \
+		-r \
+	'
+	  map (select (.valid == true)) | length as $array_length
+
+	  | .[$rand_i % $array_length].data.logo
+	' < $SPACES_JSON > $RAND_VALID_SPACE_LOGO_URL_FILE
+RAND_VALID_SPACE_LOGO_URL=$(cat $RAND_VALID_SPACE_LOGO_URL_FILE)
+if [ -z $RAND_VALID_SPACE_LOGO_URL ]; then
+	rm $RAND_VALID_SPACE_LOGO_URL_FILE
+	rm $RAND_VALID_SPACE_LOGO
+else
+	curl $RAND_VALID_SPACE_LOGO_URL > $RAND_VALID_SPACE_LOGO
+	rm $RAND_VALID_SPACE_LOGO_URL_FILE
+fi
+
+#jq \
+#	--argjson rand_i $RAND_I \
+#	-r \
+#'
+#  map (select (.data.state.open == true)) | length as $array_length
+#
+#  | .[$rand_i % $array_length].data.contact.email
+#' < $SPACES_JSON
+
+## ideas:
+# - show some data of a random space
+#   - (incl. logo)
+#   - state (open)
+#   - (statistics)
+# - statistics

current_nodes/spaces/update

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+BASEDIR=$(dirname $0)
+SPACES_JSON=$BASEDIR/spaces.json
+
+curl https://api.spaceapi.io | json_pp > $SPACES_JSON
+
+$BASEDIR/query_spaces &
+