Coverage report: /development/source/library/org/datagraph/spocq-shard/src/spocq-server/ldf.lisp

Kind	Covered	All	%
expression	103	144	71.5
branch	4	8	50.0

Key

Not instrumented

Conditionalized out

Executed

Not executed

Both branches taken

One branch taken

Neither branch taken

1

 ;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: org.datagraph.spocq.server.implementation; -*-

2

3

4

(in-package :org.datagraph.spocq.server.implementation)

5

6

(:documentation "linked data fragment protocol"

7

8

"This file is the http layer for a linked data fragments server.

9

It defines a resource function which delegates to the ldf implementation for specific url patterns

10

")

11

12

;;; (load "/development/source/library/org/datagraph/spocq/src/server/ldf.lisp")

13

14

15

(eval-when (:compile-toplevel :load-toplevel :execute)

16

(defclass ldf-resource-function (http:resource-function)

17

((http.i::default-accept-header

18

:initform "application/n-quads;profile=http://www.hydra-cg.com/spec/latest/linked-data-fragments/"

19

:allocation :class))

20

(:metaclass c2mop:funcallable-standard-class)

21

(:documentation "A specialized resourc function for linked data fragments

22

          which sets 'application/n-quads;profile=http://www.hydra-cg.com/spec/latest/linked-data-fragments/'

23

as the default response media type")))

24

25

(http:def-resource-function linked-data-fragment-server (resource-id request response)

26

(:generic-function-class ldf-resource-function)

27

(:log )

28

29

(:auth http:authenticate-request-password)

30

(:auth http:authenticate-request-token)

31

(:auth http:authenticate-request-session)

32

(:auth http:authenticate-request-location)

33

34

(:auth http:authorize-request)

35

36

(:encode :default mime:application/n-quads)

37

(:encode mime:application/n-triples)

38

(:encode mime:application/ld+json)

39

(:encode mime:application/rdf+json)

40

(:encode mime:application/rdf+xml)

41

42

(:get ((resource |/:account/:repository/ldf|) request response request-type response-type)

43

;; first perform the ldf query

44

(setf (http:response-header response :access-control-allow-origin) "*")

45

(setf (http:response-header response :access-control-allow-credentials) "*")

46

         (setf (http:response-header response :access-control-allow-headers) "Authorization, Content-Type, X-Requested-With")

47

         (setf (http:response-content-type-header response) (string-downcase (type-of mime:application/n-quads)))

48

(ldf-query resource request response request-type response-type)

49

;(ldf-query resource request *trace-output* request-type response-type)

50

nil

51

)

52

53

(:get ((resource |/:account/:repository/tpf|) request response request-type response-type)

54

;; first perform the ldf query

55

(setf (http:response-header response :access-control-allow-origin) "*")

56

(setf (http:response-header response :access-control-allow-credentials) "*")

57

         (setf (http:response-header response :access-control-allow-headers) "Authorization, Content-Type, X-Requested-With")

58

         (setf (http:response-content-type-header response) (string-downcase (type-of mime:application/n-quads)))

59

(ldf-query resource request response request-type response-type)

60

;(ldf-query resource request *trace-output* request-type response-type)

61

nil

62

)

63

64

#+(or)

65

(:encode ((resource t) (request t) (response t) request-type (response-type mime:application/ldf))

66

;; augment the response with the metadata

67

(let* ((metadata (spocq.i::compute-ldf-metadata-solutions (resource-repository resource)

68

                                                                (resource-identifier resource)))

69

(field (cons '(?::|s| ?::|p| ?::|o| ?::|c|) metadata))

70

(destination (http:response-content-stream response)))

71

#+(or)

72

(print (compute-applicable-methods #'spocq.i::send-response-message

73

                                            (list t field destination response-type)))

74

(spocq.i::send-response-message :|response| field destination response-type)

75

(call-next-method)

76

(print "ldp complete" *trace-output*)))

77

)

78

79

#+(or)

80

(defmethod DE.SETF.HTTP:ENCODE-RESPONSE :before (query response type)

81

(print (compute-applicable-methods #'DE.SETF.HTTP:ENCODE-RESPONSE (list query response type))))

82

83

84

85

 (defmethod spocq.i::send-response-message ((operation t) (field t) (destination t) (response-type mime:application/ldf+n-quads))

86

(let ((metadata (spocq.i::compute-ldf-metadata-solutions spocq.i::*repository* spocq.i::*task*)))

87

(unless (eq response-type mime:application/n-quads)

88

(spocq.i::send-response-message operation metadata destination mime:application/n-quads))

89

)

90

(call-next-method))

91

92

;;; preceed the actual content with the metadata

93

 (defmethod spocq.i::send-response-message ((operation t) (field spocq.i::ldf-query) (destination t) (response-type t))

94

;; alternatively, a union at the generator level

95

(let ((metadata (spocq.i::compute-ldf-metadata-solutions spocq.i::*repository* spocq.i::*task*)))

96

(spocq.i::send-response-message operation metadata destination response-type)

97

(call-next-method)))

98

99

100

(defgeneric ldf-query (resource request response request-type response-type)

101

   (:method ((resource http:resource) (request http:request) (response http:response) request-type response-type)

102

(ldf-query resource request (http:response-content-stream response) request-type response-type))

103

(:method ((resource http:resource) (request http:request) (destination stream) request-type response-type)

104

     "Extract the constraint and paging arguments from the request and marshall them to pipe the query to the destination."

105

(declare (ignore request-type))

106

(let* ((repository (resource-repository resource))

107

(repository-id (dydra:repository-id repository))

108

(configuration-list (request-configuration-list request))

109

(parsed-configuration-list (parse-http-configuration configuration-list))

110

(selector-and-controls (handler-case (loop for (name . value) in configuration-list

111

                                                   when (member name '(s p o c graph page) :test #'string-equal)

112

                                                   collect (cons-symbol :keyword name)

113

                                                   and collect (when (plusp (length value))

114

                                                                 (case (char value 0)

115

                                                                   (#\? nil) ; variable is suppressed

116

                                                                   (#\" (spocq.i::parse-term value))

117

                                                                   (#\_ (spocq.i::parse-term value))

118

                                                                   (t (spocq.i::intern-iri value)))))

119

                                     (error (c) (http:bad-request "Error parsing selector: ~a: ~s" c configuration-list)))))

120

(setq dydra:*run-state* :initialize)

121

(with-http-configuration (list* :repository-id repository-id

122

:task-id (dydra:make-task-id)

123

parsed-configuration-list)

124

(when (find repository-id spocq.i::*disabled-repositories* :test #'string-equal)

125

(http:bad-request "The repository has been disabled: ~s." repository-id))

126

(setq spocq.i::*run-state* :process)

127

(destructuring-bind (&key s p o graph (c graph) page) selector-and-controls

128

(let ((spocq.i::*repository* repository)

129

(spocq.i::*repository-id* repository-id))

130

;; execute just the spoc aspect of the query.

131

;; leave the metadata for the encoding step

132

;; (print (http:request-agent request))

133

(let ((result (spocq.i::pipe-spoc-query repository destination

134

                                                     :agent (http:request-agent request)

135

                                                     :response-content-type response-type

136

                                                     :s s :p p :o o :from c

137

:page page

138

                                                     :task-id (spocq.i::make-task-id))))

139

(etypecase result

140

(spocq.i:query result)

141

(condition (signal result))))))))))

142

143

;;; (trace spocq.i::pipe-spoc-query spocq.i::send-response-message spocq.si::linked-data-fragment-server)

144

;;; (format nil "~{ ~x ~}" (map 'list #'char-code " <>\""))

145

 ;;; curl -v -H "Accept: application/n-quads" -X GET 'http://localhost:8101/openrdf-sesame/mem-rdf-public/ldf?s=%3chttp://example.com/default-subject%3e'

146

 ;;; curl -v -H "Accept: application/n-quads" -X GET 'http://localhost:8101/openrdf-sesame/mem-rdf-public/ldf?s=%3chttp://example.com/named-subject%3e'

147

 ;;; curl -v -H "Accept: application/n-quads" -X GET 'http://localhost:8101/openrdf-sesame/mem-rdf-public/ldf?p=%3chttp://example.com/named-predicate%3e'

148

 ;;; curl -v -H "Accept: application/n-quads" -X GET 'http://localhost:8101/openrdf-sesame/mem-rdf-public/ldf?o=%22named%20object%22'