MetzNet
/
graphvent
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
graphvent/gql.go

1202 lines
34 KiB
Go
Raw Normal View History Unescape Escape

Added base GQLThread
2023-06-25 20:20:59 -06:00
package graphvent
import (
Started to add authentication for GQL endpoint
2023-07-19 14:45:05 -06:00
"time"
"net"
Added base GQLThread
2023-06-25 20:20:59 -06:00
"net/http"
"github.com/graphql-go/graphql"
"github.com/graphql-go/graphql/language/parser"
"github.com/graphql-go/graphql/language/source"
"github.com/graphql-go/graphql/language/ast"
"context"
"encoding/json"
"io"
"reflect"
"fmt"
"sync"
"github.com/gobwas/ws"
"github.com/gobwas/ws/wsutil"
require auth for gql
2023-07-13 18:21:33 -06:00
"strings"
Started to add authentication for GQL endpoint
2023-07-19 14:45:05 -06:00
"crypto/ecdh"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
Added TLS to GQLThread
2023-07-21 01:05:24 -06:00
"crypto/tls"
Moved self-signed certificate creation to NewGQLThread
2023-07-21 01:21:53 -06:00
"crypto/x509/pkix"
"math/big"
"encoding/pem"
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
"github.com/google/uuid"
Added base GQLThread
2023-06-25 20:20:59 -06:00
)
func GraphiQLHandler() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r * http.Request) {
graphiql_string := fmt.Sprintf(`
<!--
* Copyright (c) 2021 GraphQL Contributors
* All rights reserved.
*
* This source code is licensed under the license found in the
* LICENSE file in the root directory of this source tree.
-->
<!DOCTYPE html>
<html lang="en">
<head>
<title>GraphiQL</title>
<style>
body {
height: 100%%;
margin: 0;
width: 100%%;
overflow: hidden;
}
#graphiql {
height: 100vh;
}
</style>
<!--
This GraphiQL example depends on Promise and fetch, which are available in
modern browsers, but can be "polyfilled" for older browsers.
GraphiQL itself depends on React DOM.
If you do not want to rely on a CDN, you can host these files locally or
include them directly in your favored resource bundler.
-->
<script
crossorigin
src="https://unpkg.com/react@18/umd/react.development.js"
></script>
<script
crossorigin
src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"
></script>
<!--
These two files can be found in the npm module, however you may wish to
copy them directly into your environment, or perhaps include them in your
favored resource bundler.
-->
<link rel="stylesheet" href="https://unpkg.com/graphiql/graphiql.min.css" />
</head>
<body>
<div id="graphiql">Loading...</div>
<script
src="https://unpkg.com/graphiql/graphiql.min.js"
type="application/javascript"
></script>
<script>
const root = ReactDOM.createRoot(document.getElementById('graphiql'));
root.render(
React.createElement(GraphiQL, {
fetcher: GraphiQL.createFetcher({
url: '/gql',
}),
defaultEditorToolsVisibility: true,
}),
);
</script>
</body>
</html>
`)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.WriteHeader(http.StatusOK)
io.WriteString(w, graphiql_string)
}
}
GQLUser improvement
2023-07-20 00:24:22 -06:00
type GQLPayload struct {
Added base GQLThread
2023-06-25 20:20:59 -06:00
OperationName string `json:"operationName,omitempty"`
Query string `json:"query,omitempty"`
Variables map[string]interface{} `json:"variables,omitempty"`
Extensions map[string]interface{} `json:"extensions,omitempty"`
Data string `json:"data,omitempty"`
}
type GQLWSMsg struct {
ID string `json:"id,omitempty"`
Type string `json:"type"`
GQLUser improvement
2023-07-20 00:24:22 -06:00
Payload GQLPayload `json:"payload,omitempty"`
Added base GQLThread
2023-06-25 20:20:59 -06:00
}
func enableCORS(w *http.ResponseWriter) {
(*w).Header().Set("Access-Control-Allow-Origin", "*")
(*w).Header().Set("Access-Control-Allow-Credentials", "true")
(*w).Header().Set("Access-Control-Allow-Headers", "*")
(*w).Header().Set("Access-Control-Allow-Methods", "*")
}
require auth for gql
2023-07-13 18:21:33 -06:00
type GQLUnauthorized string
func (e GQLUnauthorized) Is(target error) bool {
error_type := reflect.TypeOf(GQLUnauthorized(""))
target_type := reflect.TypeOf(target)
return error_type == target_type
}
func (e GQLUnauthorized) Error() string {
return fmt.Sprintf("GQL_UNAUTHORIZED_ERROR: %s", string(e))
}
Return error for no auth
2023-07-13 18:28:02 -06:00
func (e GQLUnauthorized) MarshalJSON() ([]byte, error) {
return json.MarshalIndent(&struct{
Error string `json:"error"`
}{
Error: string(e),
}, "", " ")
}
require auth for gql
2023-07-13 18:21:33 -06:00
func checkForAuthHeader(header http.Header) (string, bool) {
auths, ok := header["Authorization"]
if ok == false {
return "", false
}
for _, auth := range(auths) {
parts := strings.SplitN(auth, " ", 2)
if len(parts) != 2 {
continue
}
if parts[0] == "TM" {
return parts[1], true
}
}
return "", false
}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// Context passed to each resolve execution
Added GetResolveContext
2023-07-21 18:51:42 -06:00
type ResolveContext struct {
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// ID generated for the context so the gql extension can route data to it
ID uuid.UUID
// Channel for the gql extension to route data to this context
Chan chan *ReadResultSignal
// Graph Context this resolver is running under
Added GetResolveContext
2023-07-21 18:51:42 -06:00
Context *Context
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// GQL Extension context this resolver is running under
Added gql to the rework
2023-07-26 00:18:11 -06:00
GQLContext *GQLExtContext
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// Pointer to the node that's currently processing this request
Added gql to the rework
2023-07-26 00:18:11 -06:00
Server *Node
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// The state data for the node processing this request
Added gql to the rework
2023-07-26 00:18:11 -06:00
Ext *GQLExt
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// ID of the user that made this request
// TODO: figure out auth
Moved ecdh to it's own extension
2023-07-29 00:28:44 -06:00
User NodeID
Added GetResolveContext
2023-07-21 18:51:42 -06:00
}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
const GQL_RESOLVER_CHAN_SIZE = 10
Added gql to the rework
2023-07-26 00:18:11 -06:00
func NewResolveContext(ctx *Context, server *Node, gql_ext *GQLExt, r *http.Request) (*ResolveContext, error) {
Moved test 'WaitForX' functions to a generic function in signal.go that can be used to wait for arbitrary signals
2023-07-28 19:32:27 -06:00
username, _, ok := r.BasicAuth()
GQLUser improvement
2023-07-20 00:24:22 -06:00
if ok == false {
return nil, fmt.Errorf("GQL_REQUEST_ERR: no auth header included in request header")
}
auth_id, err := ParseID(username)
if err != nil {
return nil, fmt.Errorf("GQL_REQUEST_ERR: failed to parse ID from auth username: %s", username)
}
Added GetResolveContext
2023-07-21 18:51:42 -06:00
return &ResolveContext{
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
Ext: gql_ext,
ID: uuid.New(),
Chan: make(chan *ReadResultSignal, GQL_RESOLVER_CHAN_SIZE),
Added GetResolveContext
2023-07-21 18:51:42 -06:00
Context: ctx,
Moved Hash function to single implementation
2023-07-27 23:26:58 -06:00
GQLContext: ctx.Extensions[Hash(GQLExtType)].Data.(*GQLExtContext),
Added GetResolveContext
2023-07-21 18:51:42 -06:00
Server: server,
Moved ecdh to it's own extension
2023-07-29 00:28:44 -06:00
User: auth_id,
Added GetResolveContext
2023-07-21 18:51:42 -06:00
}, nil
GQLUser improvement
2023-07-20 00:24:22 -06:00
}
Added gql to the rework
2023-07-26 00:18:11 -06:00
func GQLHandler(ctx *Context, server *Node, gql_ext *GQLExt) func(http.ResponseWriter, *http.Request) {
Added base GQLThread
2023-06-25 20:20:59 -06:00
return func(w http.ResponseWriter, r * http.Request) {
ctx.Log.Logf("gql", "GQL REQUEST: %s", r.RemoteAddr)
enableCORS(&w)
header_map := map[string]interface{}{}
for header, value := range(r.Header) {
header_map[header] = value
}
ctx.Log.Logm("gql", header_map, "REQUEST_HEADERS")
Added KDF for shared secret to shared ecdsa key, and added signature to AuthRespJSON
2023-07-19 21:28:48 -06:00
Added gql to the rework
2023-07-26 00:18:11 -06:00
resolve_context, err := NewResolveContext(ctx, server, gql_ext, r)
Added KDF for shared secret to shared ecdsa key, and added signature to AuthRespJSON
2023-07-19 21:28:48 -06:00
if err != nil {
GQLUser improvement
2023-07-20 00:24:22 -06:00
ctx.Log.Logf("gql", "GQL_AUTH_ERR: %s", err)
json.NewEncoder(w).Encode(GQLUnauthorized(fmt.Sprintf("%s", err)))
Added KDF for shared secret to shared ecdsa key, and added signature to AuthRespJSON
2023-07-19 21:28:48 -06:00
return
}
Added GetResolveContext
2023-07-21 18:51:42 -06:00
req_ctx := context.Background()
Added gql to the rework
2023-07-26 00:18:11 -06:00
req_ctx = context.WithValue(req_ctx, "resolve", resolve_context)
Added base GQLThread
2023-06-25 20:20:59 -06:00
str, err := io.ReadAll(r.Body)
if err != nil {
GQLUser improvement
2023-07-20 00:24:22 -06:00
ctx.Log.Logf("gql", "GQL_READ_ERR: %s", err)
json.NewEncoder(w).Encode(fmt.Sprintf("%e", err))
Added base GQLThread
2023-06-25 20:20:59 -06:00
return
require auth for gql
2023-07-13 18:21:33 -06:00
}
GQLUser improvement
2023-07-20 00:24:22 -06:00
query := GQLPayload{}
Added base GQLThread
2023-06-25 20:20:59 -06:00
json.Unmarshal(str, &query)
Moved Hash function to single implementation
2023-07-27 23:26:58 -06:00
gql_context := ctx.Extensions[Hash(GQLExtType)].Data.(*GQLExtContext)
Added gql to the rework
2023-07-26 00:18:11 -06:00
Added base GQLThread
2023-06-25 20:20:59 -06:00
params := graphql.Params{
Added gql to the rework
2023-07-26 00:18:11 -06:00
Schema: gql_context.Schema,
require auth for gql
2023-07-13 18:21:33 -06:00
Context: req_ctx,
Added base GQLThread
2023-06-25 20:20:59 -06:00
RequestString: query.Query,
}
if query.OperationName != "" {
params.OperationName = query.OperationName
}
if len(query.Variables) > 0 {
params.VariableValues = query.Variables
}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
gql_ext.resolver_chans_lock.Lock()
gql_ext.resolver_chans[resolve_context.ID] = resolve_context.Chan
gql_ext.resolver_chans_lock.Unlock()
Added base GQLThread
2023-06-25 20:20:59 -06:00
result := graphql.Do(params)
if len(result.Errors) > 0 {
extra_fields := map[string]interface{}{}
extra_fields["body"] = string(str)
extra_fields["headers"] = r.Header
ctx.Log.Logm("gql", extra_fields, "wrong result, unexpected errors: %v", result.Errors)
}
json.NewEncoder(w).Encode(result)
}
}
func sendOneResultAndClose(res *graphql.Result) chan *graphql.Result {
resultChannel := make(chan *graphql.Result)
go func() {
resultChannel <- res
close(resultChannel)
}()
return resultChannel
}
func getOperationTypeOfReq(p graphql.Params) string{
source := source.NewSource(&source.Source{
Body: []byte(p.RequestString),
Name: "GraphQL request",
})
AST, err := parser.Parse(parser.ParseParams{Source: source})
if err != nil {
return ""
}
for _, node := range AST.Definitions {
if operationDef, ok := node.(*ast.OperationDefinition); ok {
name := ""
if operationDef.Name != nil {
name = operationDef.Name.Value
}
if name == p.OperationName || p.OperationName == "" {
return operationDef.Operation
}
}
}
return ""
}
Updated gql.go
2023-07-09 19:33:18 -06:00
func GQLWSDo(ctx * Context, p graphql.Params) chan *graphql.Result {
Added base GQLThread
2023-06-25 20:20:59 -06:00
operation := getOperationTypeOfReq(p)
ctx.Log.Logf("gqlws", "GQLWSDO_OPERATION: %s %+v", operation, p.RequestString)
if operation == ast.OperationTypeSubscription {
return graphql.Subscribe(p)
}
res := graphql.Do(p)
return sendOneResultAndClose(res)
}
Added gql to the rework
2023-07-26 00:18:11 -06:00
func GQLWSHandler(ctx * Context, server *Node, gql_ext *GQLExt) func(http.ResponseWriter, *http.Request) {
Added base GQLThread
2023-06-25 20:20:59 -06:00
return func(w http.ResponseWriter, r * http.Request) {
ctx.Log.Logf("gqlws_new", "HANDLING %s",r.RemoteAddr)
Fixed internal signalling for threads, and update signal type in gql
2023-06-25 21:00:00 -06:00
enableCORS(&w)
Added base GQLThread
2023-06-25 20:20:59 -06:00
header_map := map[string]interface{}{}
for header, value := range(r.Header) {
header_map[header] = value
}
gql.go
2023-07-13 18:23:57 -06:00
Added base GQLThread
2023-06-25 20:20:59 -06:00
ctx.Log.Logm("gql", header_map, "REQUEST_HEADERS")
Added gql to the rework
2023-07-26 00:18:11 -06:00
resolve_context, err := NewResolveContext(ctx, server, gql_ext, r)
Added KDF for shared secret to shared ecdsa key, and added signature to AuthRespJSON
2023-07-19 21:28:48 -06:00
if err != nil {
GQLUser improvement
2023-07-20 00:24:22 -06:00
ctx.Log.Logf("gql", "GQL_AUTH_ERR: %s", err)
Added KDF for shared secret to shared ecdsa key, and added signature to AuthRespJSON
2023-07-19 21:28:48 -06:00
return
}
Added GetResolveContext
2023-07-21 18:51:42 -06:00
req_ctx := context.Background()
req_ctx = context.WithValue(req_ctx, "resolve", resolve_context)
gql.go
2023-07-13 18:23:57 -06:00
Added base GQLThread
2023-06-25 20:20:59 -06:00
u := ws.HTTPUpgrader{
Protocol: func(protocol string) bool {
ctx.Log.Logf("gqlws", "UPGRADE_PROTOCOL: %s", string(protocol))
Fixed internal signalling for threads, and update signal type in gql
2023-06-25 21:00:00 -06:00
if string(protocol) == "graphql-transport-ws" || string(protocol) == "graphql-ws" {
return true
}
return false
Added base GQLThread
2023-06-25 20:20:59 -06:00
},
}
conn, _, _, err := u.Upgrade(r, w)
if err == nil {
defer conn.Close()
conn_state := "init"
for {
msg_raw, op, err := wsutil.ReadClientData(conn)
ctx.Log.Logf("gqlws_hb", "MSG: %s\nOP: 0x%02x\nERR: %+v\n", string(msg_raw), op, err)
msg := GQLWSMsg{}
json.Unmarshal(msg_raw, &msg)
if err != nil {
ctx.Log.Logf("gqlws", "WS_CLIENT_ERROR")
break
}
if msg.Type == "connection_init" {
if conn_state != "init" {
ctx.Log.Logf("gqlws", "WS_CLIENT_ERROR: INIT WHILE IN %s", conn_state)
break
}
conn_state = "ready"
err = wsutil.WriteServerMessage(conn, 1, []byte("{\"type\": \"connection_ack\"}"))
if err != nil {
ctx.Log.Logf("gqlws", "WS_SERVER_ERROR: FAILED TO SEND connection_ack")
break
}
} else if msg.Type == "ping" {
ctx.Log.Logf("gqlws_hb", "PING FROM %s", r.RemoteAddr)
err = wsutil.WriteServerMessage(conn, 1, []byte("{\"type\": \"pong\"}"))
if err != nil {
ctx.Log.Logf("gqlws", "WS_SERVER_ERROR: FAILED TO SEND PONG")
}
} else if msg.Type == "subscribe" {
ctx.Log.Logf("gqlws", "SUBSCRIBE: %+v", msg.Payload)
Moved Hash function to single implementation
2023-07-27 23:26:58 -06:00
gql_context := ctx.Extensions[Hash(GQLExtType)].Data.(*GQLExtContext)
Added base GQLThread
2023-06-25 20:20:59 -06:00
params := graphql.Params{
Added gql to the rework
2023-07-26 00:18:11 -06:00
Schema: gql_context.Schema,
Added KDF for shared secret to shared ecdsa key, and added signature to AuthRespJSON
2023-07-19 21:28:48 -06:00
Context: req_ctx,
Added base GQLThread
2023-06-25 20:20:59 -06:00
RequestString: msg.Payload.Query,
}
if msg.Payload.OperationName != "" {
params.OperationName = msg.Payload.OperationName
}
if len(msg.Payload.Variables) > 0 {
params.VariableValues = msg.Payload.Variables
}
res_chan := GQLWSDo(ctx, params)
GQLWS Logging
2023-07-03 19:13:29 -06:00
if res_chan == nil {
ctx.Log.Logf("gqlws", "res_chan is nil")
} else {
ctx.Log.Logf("gqlws", "res_chan: %+v", res_chan)
}
Added base GQLThread
2023-06-25 20:20:59 -06:00
go func(res_chan chan *graphql.Result) {
for {
next, ok := <-res_chan
if ok == false {
ctx.Log.Logf("gqlws", "response channel was closed")
return
}
if next == nil {
ctx.Log.Logf("gqlws", "NIL_ON_CHANNEL")
return
}
if len(next.Errors) > 0 {
extra_fields := map[string]interface{}{}
extra_fields["query"] = string(msg.Payload.Query)
ctx.Log.Logm("gqlws", extra_fields, "ERROR: wrong result, unexpected errors: %+v", next.Errors)
continue
}
ctx.Log.Logf("gqlws", "DATA: %+v", next.Data)
data, err := json.Marshal(next.Data)
if err != nil {
ctx.Log.Logf("gqlws", "ERROR: %+v", err)
continue
}
msg, err := json.Marshal(GQLWSMsg{
ID: msg.ID,
Type: "next",
GQLUser improvement
2023-07-20 00:24:22 -06:00
Payload: GQLPayload{
Added base GQLThread
2023-06-25 20:20:59 -06:00
Data: string(data),
},
})
if err != nil {
ctx.Log.Logf("gqlws", "ERROR: %+v", err)
continue
}
err = wsutil.WriteServerMessage(conn, 1, msg)
if err != nil {
ctx.Log.Logf("gqlws", "ERROR: %+v", err)
continue
}
}
}(res_chan)
} else {
}
}
return
} else {
panic("Failed to upgrade websocket")
}
}
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
type Interface struct {
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
Interface *graphql.Interface
Default *graphql.Object
List *graphql.List
Extensions []ExtType
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
type Type struct {
Simplified gql node/interface creation with helper functions
2023-07-26 23:57:50 -06:00
Type *graphql.Object
List *graphql.List
}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
type Field struct {
Ext ExtType
Name string
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
Field *graphql.Field
Moved ecdh to it's own extension
2023-07-29 00:28:44 -06:00
}
Added gql to the rework
2023-07-26 00:18:11 -06:00
// GQL Specific Context information
type GQLExtContext struct {
// Generated GQL schema
Schema graphql.Schema
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
// Custom graphql types, mapped to NodeTypes
NodeTypes map[NodeType]*graphql.Object
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
Interfaces map[string]*Interface
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
Fields map[string]Field
Added gql to the rework
2023-07-26 00:18:11 -06:00
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
// Schema parameters
Types []graphql.Type
Added gql to the rework
2023-07-26 00:18:11 -06:00
Query *graphql.Object
Mutation *graphql.Object
Subscription *graphql.Object
}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
func (ctx *GQLExtContext) GetACLFields(obj_name string, names []string) (map[ExtType][]string, error) {
ext_fields := map[ExtType][]string{}
for _, name := range(names) {
switch name {
case "ID":
case "TypeHash":
default:
field, exists := ctx.Fields[name]
if exists == false {
return nil, fmt.Errorf("%s is not a know field in GQLContext, cannot resolve", name)
}
ext, exists := ext_fields[field.Ext]
if exists == false {
ext = []string{}
}
ext = append(ext, field.Name)
ext_fields[field.Ext] = ext
}
}
return ext_fields, nil
}
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
func BuildSchema(ctx *GQLExtContext) (graphql.Schema, error) {
schemaConfig := graphql.SchemaConfig{
Types: ctx.Types,
Query: ctx.Query,
Mutation: ctx.Mutation,
Subscription: ctx.Subscription,
}
return graphql.NewSchema(schemaConfig)
}
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
func RegisterField[T any](ctx *GQLExtContext, gql_type graphql.Type, gql_name string, ext_type ExtType, acl_name string, resolve_fn func(graphql.ResolveParams, T)(interface{}, error)) error {
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
if ctx == nil {
return fmt.Errorf("ctx is nil")
}
if resolve_fn == nil {
return fmt.Errorf("resolve_fn cannot be nil")
}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
_, exists := ctx.Fields[gql_name]
if exists == true {
return fmt.Errorf("%s is already a field in the context, cannot add again", gql_name)
}
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
resolver := func(p graphql.ResolveParams)(interface{}, error) {
return ResolveNodeResult(p, func(p graphql.ResolveParams, result NodeResult) (interface{}, error) {
ext, exists := result.Result.Extensions[ext_type]
if exists == false {
return nil, fmt.Errorf("%s is not in the extensions of the result", ext_type)
}
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
val_if, exists := ext[acl_name]
if exists == false {
return nil, fmt.Errorf("%s is not in the fields of %s in the result", acl_name, ext_type)
}
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
var zero T
val, ok := val_if.(T)
if ok == false {
return nil, fmt.Errorf("%s.%s is not %s", ext_type, acl_name, reflect.TypeOf(zero))
}
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
return resolve_fn(p, val)
})
}
ctx.Fields[gql_name] = Field{ext_type, acl_name, &graphql.Field{
Type: gql_type,
Resolve: resolver,
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
}}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
return nil
}
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
func GQLInterfaces(ctx *GQLExtContext, interface_names []string) ([]*graphql.Interface, error) {
ret := make([]*graphql.Interface, len(interface_names))
for i, in := range(interface_names) {
ctx_interface, exists := ctx.Interfaces[in]
if exists == false {
return nil, fmt.Errorf("%s is not in GQLExtContext.Interfaces", in)
}
ret[i] = ctx_interface.Interface
}
return ret, nil
}
func GQLFields(ctx *GQLExtContext, field_names []string) (graphql.Fields, []ExtType, error) {
fields := graphql.Fields{
"ID": &graphql.Field{
Type: graphql.String,
Resolve: ResolveNodeID,
},
"TypeHash": &graphql.Field{
Type: graphql.String,
Resolve: ResolveNodeTypeHash,
},
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
}
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
exts := map[ExtType]ExtType{}
ext_list := []ExtType{}
for _, name := range(field_names) {
field, exists := ctx.Fields[name]
if exists == false {
return nil, nil, fmt.Errorf("%s is not in GQLExtContext.Fields", name)
}
fields[name] = field.Field
_, exists = exts[field.Ext]
if exists == false {
ext_list = append(ext_list, field.Ext)
exts[field.Ext] = field.Ext
}
}
return fields, ext_list, nil
}
type NodeResult struct {
ID NodeID
Result *ReadResultSignal
}
type ListField struct {
ACLName string
Extension ExtType
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
ResolveFn func(graphql.ResolveParams, interface{}) ([]NodeID, error)
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
}
type SelfField struct {
ACLName string
Extension ExtType
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
ResolveFn func(graphql.ResolveParams, interface{}) (NodeID, error)
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
}
func (ctx *GQLExtContext) RegisterInterface(name string, default_name string, interfaces []string, fields []string, self_fields map[string]SelfField, list_fields map[string]ListField) error {
if interfaces == nil {
return fmt.Errorf("interfaces is nil")
}
if fields == nil {
return fmt.Errorf("fields is nil")
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
}
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
_, exists := ctx.Interfaces[name]
if exists == true {
return fmt.Errorf("%s is already an interface in ctx", name)
}
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
node_interfaces, err := GQLInterfaces(ctx, interfaces)
if err != nil {
return err
}
node_fields, node_exts, err := GQLFields(ctx, fields)
if err != nil {
return err
}
ctx_interface := Interface{}
ctx_interface.Interface = graphql.NewInterface(graphql.InterfaceConfig{
Name: name,
ResolveType: NodeInterfaceResolveType(node_exts, &ctx_interface.Default),
Fields: node_fields,
})
ctx_interface.List = graphql.NewList(ctx_interface.Interface)
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
for field_name, field := range(self_fields) {
self_field := field
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
err := RegisterField(ctx, ctx_interface.Interface, field_name, self_field.Extension, self_field.ACLName,
func(p graphql.ResolveParams, val interface{})(interface{}, error) {
ctx, err := PrepResolve(p)
if err != nil {
return nil, err
}
var zero NodeID
id, err := self_field.ResolveFn(p, val)
if err != nil {
return zero, err
}
nodes, err := ResolveNodes(ctx, p, []NodeID{id})
if err != nil {
return nil, err
} else if len(nodes) != 1 {
return nil, fmt.Errorf("wrong length of nodes returned")
}
return nodes[0], nil
})
if err != nil {
return err
}
ctx_interface.Interface.AddFieldConfig(field_name, ctx.Fields[field_name].Field)
node_fields[field_name] = ctx.Fields[field_name].Field
}
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
for field_name, field := range(list_fields) {
list_field := field
resolve_fn := func(p graphql.ResolveParams, val interface{})(interface{}, error) {
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
ctx, err := PrepResolve(p)
if err != nil {
return nil, err
}
var zero NodeID
ids, err := list_field.ResolveFn(p, val)
if err != nil {
return zero, err
}
nodes, err := ResolveNodes(ctx, p, ids)
if err != nil {
return nil, err
} else if len(nodes) != len(ids) {
return nil, fmt.Errorf("wrong length of nodes returned")
}
return nodes, nil
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
}
err := RegisterField(ctx, ctx_interface.List, field_name, list_field.Extension, list_field.ACLName, resolve_fn)
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
if err != nil {
return err
}
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
ctx_interface.Interface.AddFieldConfig(field_name, ctx.Fields[field_name].Field)
node_fields[field_name] = ctx.Fields[field_name].Field
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
}
ctx_interface.Default = graphql.NewObject(graphql.ObjectConfig{
Name: default_name,
Interfaces: append(node_interfaces, ctx_interface.Interface),
IsTypeOf: NodeInterfaceDefaultIsType(node_exts),
Fields: node_fields,
})
ctx.Interfaces[name] = &ctx_interface
ctx.Types = append(ctx.Types, ctx_interface.Default)
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
return nil
}
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
func (ctx *GQLExtContext) RegisterNodeType(node_type NodeType, name string, interface_names []string, field_names []string) error {
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
if field_names == nil {
return fmt.Errorf("fields is nil")
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
}
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
_, exists := ctx.NodeTypes[node_type]
if exists == true {
return fmt.Errorf("%s already in GQLExtContext.NodeTypes", node_type)
}
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
node_interfaces, err := GQLInterfaces(ctx, interface_names)
if err != nil {
return err
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
}
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
gql_fields, _, err := GQLFields(ctx, field_names)
if err != nil {
return err
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
}
gql_type := graphql.NewObject(graphql.ObjectConfig{
Name: name,
Interfaces: node_interfaces,
IsTypeOf: func(p graphql.IsTypeOfParams) bool {
node, ok := p.Value.(NodeResult)
if ok == false {
return false
}
return node.Result.NodeType == node_type
},
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
Fields: gql_fields,
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
})
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
ctx.NodeTypes[node_type] = gql_type
ctx.Types = append(ctx.Types, gql_type)
return nil
}
Added gql to the rework
2023-07-26 00:18:11 -06:00
func NewGQLExtContext() *GQLExtContext {
query := graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.Fields{},
})
context := GQLExtContext{
Schema: graphql.Schema{},
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
Types: []graphql.Type{},
Added gql to the rework
2023-07-26 00:18:11 -06:00
Query: query,
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
Mutation: nil,
Subscription: nil,
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
NodeTypes: map[NodeType]*graphql.Object{},
Added more sane methods to register GQL fields, need to do the same for itnerfaces and their defaults
2023-07-29 17:23:25 -06:00
Interfaces: map[string]*Interface{},
Add tests for gql server type in gql
2023-07-29 16:34:21 -06:00
Fields: map[string]Field{},
Added gql to the rework
2023-07-26 00:18:11 -06:00
}
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
var err error
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
err = context.RegisterInterface("Node", "DefaultNode", []string{}, []string{}, map[string]SelfField{}, map[string]ListField{})
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
if err != nil {
panic(err)
}
Updated test with group ext gql
2023-07-29 23:24:48 -06:00
err = RegisterField(&context, context.Interfaces["Node"].List, "Members", GroupExtType, "members",
func(p graphql.ResolveParams, val map[NodeID]string)(interface{}, error) {
ctx, err := PrepResolve(p)
if err != nil {
return nil, err
}
node_list := make([]NodeID, len(val))
i := 0
for id, _ := range(val) {
node_list[i] = id
i += 1
}
nodes, err := ResolveNodes(ctx, p, node_list)
if err != nil {
return nil, err
}
return nodes, nil
})
if err != nil {
panic(err)
}
err = context.RegisterInterface("Group", "DefaultGroup", []string{"Node"}, []string{"Members"}, map[string]SelfField{}, map[string]ListField{})
if err != nil {
panic(err)
}
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
err = context.RegisterInterface("Lockable", "DefaultLockable", []string{"Node"}, []string{}, map[string]SelfField{
"Owner": SelfField{
"owner",
LockableExtType,
func(p graphql.ResolveParams, val interface{}) (NodeID, error) {
var zero NodeID
id_str, ok := val.(string)
if ok == false {
return zero, fmt.Errorf("can't parse %+v as string", val)
}
id, err := ParseID(id_str)
if err != nil {
return zero, err
}
return id, nil
},
},
}, map[string]ListField{
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
"Requirements": ListField{
"requirements",
LockableExtType,
func(p graphql.ResolveParams, val interface{}) ([]NodeID, error) {
*
2023-07-30 10:09:04 -06:00
id_strs, ok := val.(LinkMap)
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
if ok == false {
return nil, fmt.Errorf("can't parse requirements %+v as string, %s", val, reflect.TypeOf(val))
}
ids := make([]NodeID, len(id_strs))
i := 0
*
2023-07-30 10:09:04 -06:00
for id, state := range(id_strs) {
if state.Link == "linked" {
ids[i] = id
i++
}
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
}
return ids, nil
},
},
"Dependencies": ListField{
"dependencies",
LockableExtType,
func(p graphql.ResolveParams, val interface{}) ([]NodeID, error) {
*
2023-07-30 10:09:04 -06:00
id_strs, ok := val.(LinkMap)
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
if ok == false {
return nil, fmt.Errorf("can't parse dependencies %+v as string, %s", val, reflect.TypeOf(val))
}
ids := make([]NodeID, len(id_strs))
i := 0
*
2023-07-30 10:09:04 -06:00
for id, state := range(id_strs) {
if state.Link == "linked" {
ids[i] = id
i++
}
Added tests for lockable gql fields
2023-07-29 22:16:54 -06:00
}
return ids, nil
},
},
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
})
if err != nil {
panic(err)
}
err = RegisterField(&context, graphql.String, "Listen", GQLExtType, "listen", func(p graphql.ResolveParams, listen string) (interface{}, error) {
return listen, nil
})
if err != nil {
panic(err)
}
Updated test with group ext gql
2023-07-29 23:24:48 -06:00
err = context.RegisterNodeType(GQLNodeType, "GQLServer", []string{"Node", "Lockable", "Group"}, []string{"Listen", "Owner", "Requirements", "Dependencies", "Members"})
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
if err != nil {
panic(err)
}
Added Self query to gql
2023-07-31 17:15:52 -06:00
context.Query.AddFieldConfig("Self", &graphql.Field{
Type: context.Interfaces["Node"].Interface,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
ctx, err := PrepResolve(p)
if err != nil {
return nil, err
}
nodes, err := ResolveNodes(ctx, p, []NodeID{ctx.Server.ID})
if err != nil {
return nil, err
} else if len(nodes) != 1 {
return nil, fmt.Errorf("wrong length of resolved nodes returned")
}
return nodes[0], nil
},
})
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
context.Query.AddFieldConfig("Node", &graphql.Field{
Type: context.Interfaces["Node"].Interface,
Args: graphql.FieldConfigArgument{
"id": &graphql.ArgumentConfig{
Type: graphql.String,
},
},
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
ctx, err := PrepResolve(p)
if err != nil {
return nil, err
}
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
id, err := ExtractID(p, "id")
if err != nil {
return nil, err
}
nodes, err := ResolveNodes(ctx, p, []NodeID{id})
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
if err != nil {
return nil, err
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
} else if len(nodes) != 1 {
return nil, fmt.Errorf("wrong length of resolved nodes returned")
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
}
Think I got the interface registering figured out, need to test it out with self-referrential fields(list and single) from LockableExt
2023-07-29 19:16:33 -06:00
return nodes[0], nil
Did most of the work to move node interface creation to GQLExtContext
2023-07-29 18:27:52 -06:00
},
})
Added default schema back without crashing
2023-07-26 20:26:41 -06:00
schema, err := BuildSchema(&context)
if err != nil {
panic(err)
}
context.Schema = schema
Added gql to the rework
2023-07-26 00:18:11 -06:00
return &context
}
type GQLExt struct {
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
tcp_listener net.Listener `json:"-"`
http_server *http.Server `json:"-"`
http_done sync.WaitGroup `json:"-"`
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// map of read request IDs to gql request ID
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
resolver_reads map[uuid.UUID]uuid.UUID `json:"-"`
resolver_reads_lock sync.RWMutex `json:"-"`
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// map of gql request ID to active channel
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
resolver_chans map[uuid.UUID]chan *ReadResultSignal `json:"-"`
resolver_chans_lock sync.RWMutex `json:"-"`
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
State string `json:"state"`
tls_key []byte `json:"tls_key"`
tls_cert []byte `json:"tls_cert"`
Listen string `json:"listen"`
Tests compile and run
2023-07-24 16:04:56 -06:00
}
Added read signal, and modified policies to use non-pointer receivers
2023-07-28 11:21:18 -06:00
func (ext *GQLExt) Field(name string) interface{} {
return ResolveFields(ext, name, map[string]func(*GQLExt)interface{}{
"listen": func(ext *GQLExt) interface{} {
return ext.Listen
},
})
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
func (ext *GQLExt) Process(ctx *Context, source NodeID, node *Node, signal Signal) {
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
// Process ReadResultSignalType by forwarding it to the waiting resolver
if signal.Type() == ReadResultSignalType {
sig := signal.(ReadResultSignal)
ext.resolver_reads_lock.RLock()
resolver_id, exists := ext.resolver_reads[sig.UUID]
ext.resolver_reads_lock.RUnlock()
if exists == true {
ext.resolver_reads_lock.Lock()
delete(ext.resolver_reads, sig.UUID)
ext.resolver_reads_lock.Unlock()
ext.resolver_chans_lock.RLock()
resolver_chan, exists := ext.resolver_chans[resolver_id]
ext.resolver_chans_lock.RUnlock()
if exists == true {
select {
case resolver_chan <- &sig:
ctx.Log.Logf("gql", "Forwarded to resolver %s, %+v", resolver_id, sig)
default:
ctx.Log.Logf("gql", "Resolver %s channel overflow %+v", resolver_id, sig)
ext.resolver_chans_lock.Lock()
delete(ext.resolver_chans, resolver_id)
ext.resolver_chans_lock.Unlock()
}
} else {
ctx.Log.Logf("gql", "Received message for waiting resolver %s which doesn't exist - %+v", resolver_id, sig)
}
} else {
ctx.Log.Logf("gql", "Received read result that wasn't expected - %+v", sig)
}
} else if signal.Type() == GQLStateSignalType {
Renamed signals and added ErrorSignal
2023-07-30 23:42:47 -06:00
sig := signal.(StringSignal)
switch sig.Str {
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
case "start_server":
Added start signal, and used it to restore gql server if was previously running
2023-07-31 16:25:18 -06:00
if ext.State == "stopped" {
err := ext.StartGQLServer(ctx, node)
if err == nil {
ext.State = "running"
ctx.Send(node.ID, source, StringSignal{NewDirectSignal(GQLStateSignalType), "server_started"})
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
}
case "stop_server":
Added start signal, and used it to restore gql server if was previously running
2023-07-31 16:25:18 -06:00
if ext.State == "running" {
err := ext.StopGQLServer()
if err == nil {
ext.State = "stopped"
ctx.Send(node.ID, source, StringSignal{NewDirectSignal(GQLStateSignalType), "server_stopped"})
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
}
default:
Renamed signals and added ErrorSignal
2023-07-30 23:42:47 -06:00
ctx.Log.Logf("gql", "unknown gql state %s", sig.Str)
Tests compile and run
2023-07-24 16:04:56 -06:00
}
Added start signal, and used it to restore gql server if was previously running
2023-07-31 16:25:18 -06:00
} else if signal.Type() == StartSignalType {
Added logging to gql process
2023-07-31 16:32:57 -06:00
ctx.Log.Logf("gql", "starting with state: %s", ext.State)
Added start signal, and used it to restore gql server if was previously running
2023-07-31 16:25:18 -06:00
switch ext.State {
case "running":
err := ext.StartGQLServer(ctx, node)
if err == nil {
ctx.Send(node.ID, source, StringSignal{NewDirectSignal(GQLStateSignalType), "server_started"})
}
case "stopped":
default:
ctx.Log.Logf("gql", "unknown state to restore from: %s", ext.State)
}
Tests compile and run
2023-07-24 16:04:56 -06:00
}
Add ChildGo to conveniently start children
2023-06-26 21:20:04 -06:00
}
Added gql to the rework
2023-07-26 00:18:11 -06:00
func (ext *GQLExt) Type() ExtType {
return GQLExtType
Added NodeWithUsers interface to encompass any nodes that have a Users map
2023-07-25 00:27:39 -06:00
}
Added gql to the rework
2023-07-26 00:18:11 -06:00
func (ext *GQLExt) Serialize() ([]byte, error) {
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
return json.MarshalIndent(ext, "", " ")
Added gql to the rework
2023-07-26 00:18:11 -06:00
}
Started to add authentication for GQL endpoint
2023-07-19 14:45:05 -06:00
var ecdsa_curves = map[uint8]elliptic.Curve{
0: elliptic.P256(),
}
var ecdsa_curve_ids = map[elliptic.Curve]uint8{
elliptic.P256(): 0,
}
var ecdh_curves = map[uint8]ecdh.Curve{
0: ecdh.P256(),
}
var ecdh_curve_ids = map[ecdh.Curve]uint8{
ecdh.P256(): 0,
Moved GQL context information out of node runtime state and into context
2023-07-01 13:03:28 -06:00
}
Added gql to the rework
2023-07-26 00:18:11 -06:00
func LoadGQLExt(ctx *Context, data []byte) (Extension, error) {
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
var ext GQLExt
err := json.Unmarshal(data, &ext)
Started to add authentication for GQL endpoint
2023-07-19 14:45:05 -06:00
if err != nil {
Added gql to the rework
2023-07-26 00:18:11 -06:00
return nil, err
Updated gql.go
2023-07-09 19:33:18 -06:00
}
Moved GQL context information out of node runtime state and into context
2023-07-01 13:03:28 -06:00
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
return NewGQLExt(ctx, ext.Listen, ext.tls_cert, ext.tls_key, ext.State)
Added gql to the rework
2023-07-26 00:18:11 -06:00
}
Fixed typo in thread loading that resulted in the parent being loaded as an owner instead
2023-07-03 13:14:48 -06:00
Added State to GQLExt, TODO: add a start signal that gets sent to a node when it's loop is started so it's extensions can perform activation sequences
2023-07-30 23:59:04 -06:00
func NewGQLExt(ctx *Context, listen string, tls_cert []byte, tls_key []byte, state string) (*GQLExt, error) {
Moved self-signed certificate creation to NewGQLThread
2023-07-21 01:21:53 -06:00
if tls_cert == nil || tls_key == nil {
Moved ecdh to it's own extension
2023-07-29 00:28:44 -06:00
ssl_key, err := ecdsa.GenerateKey(ctx.ECDSA, rand.Reader)
Moved self-signed certificate creation to NewGQLThread
2023-07-21 01:21:53 -06:00
if err != nil {
gql changes
2023-07-29 00:40:18 -06:00
return nil, err
Moved self-signed certificate creation to NewGQLThread
2023-07-21 01:21:53 -06:00
}
ssl_key_bytes, err := x509.MarshalECPrivateKey(ssl_key)
if err != nil {
gql changes
2023-07-29 00:40:18 -06:00
return nil, err
Moved self-signed certificate creation to NewGQLThread
2023-07-21 01:21:53 -06:00
}
ssl_key_pem := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: ssl_key_bytes})
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, _ := rand.Int(rand.Reader, serialNumberLimit)
notBefore := time.Now()
notAfter := notBefore.Add(365*24*time.Hour)
template := x509.Certificate{
SerialNumber: serialNumber,
Subject: pkix.Name{
Organization: []string{"mekkanized"},
},
NotBefore: notBefore,
NotAfter: notAfter,
KeyUsage: x509.KeyUsageDigitalSignature,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
BasicConstraintsValid: true,
}
ssl_cert, err := x509.CreateCertificate(rand.Reader, &template, &template, &ssl_key.PublicKey, ssl_key)
if err != nil {
gql changes
2023-07-29 00:40:18 -06:00
return nil, err
Moved self-signed certificate creation to NewGQLThread
2023-07-21 01:21:53 -06:00
}
ssl_cert_pem := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: ssl_cert})
tls_cert = ssl_cert_pem
tls_key = ssl_key_pem
}
Started adding back gql tests
2023-07-26 11:56:10 -06:00
return &GQLExt{
Added start signal, and used it to restore gql server if was previously running
2023-07-31 16:25:18 -06:00
State: state,
Added base GQLThread
2023-06-25 20:20:59 -06:00
Listen: listen,
Added back GQL functionality, TODO pool channels for resolve executions instead of creating new ones and GCing them every time
2023-07-29 16:00:01 -06:00
resolver_reads: map[uuid.UUID]uuid.UUID{},
resolver_chans: map[uuid.UUID]chan *ReadResultSignal{},
Moved self-signed certificate creation to NewGQLThread
2023-07-21 01:21:53 -06:00
tls_cert: tls_cert,
tls_key: tls_key,
gql changes
2023-07-29 00:40:18 -06:00
}, nil
Added base GQLThread
2023-06-25 20:20:59 -06:00
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
func (ext *GQLExt) StartGQLServer(ctx *Context, node *Node) error {
if ext.tcp_listener != nil || ext.http_server != nil {
return fmt.Errorf("listener or server is still running, stop them first")
}
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
mux := http.NewServeMux()
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
mux.HandleFunc("/gql", GQLHandler(ctx, node, ext))
mux.HandleFunc("/gqlws", GQLWSHandler(ctx, node, ext))
Moved GQL context information out of node runtime state and into context
2023-07-01 13:03:28 -06:00
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
// Server a graphiql interface(TODO make configurable whether to start this)
mux.HandleFunc("/graphiql", GraphiQLHandler())
Moved GQL context information out of node runtime state and into context
2023-07-01 13:03:28 -06:00
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
// Server the ./site directory to /site (TODO make configurable with better defaults)
fs := http.FileServer(http.Dir("./site"))
mux.Handle("/site/", http.StripPrefix("/site", fs))
Added TLS to GQLThread
2023-07-21 01:05:24 -06:00
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
http_server := &http.Server{
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
Addr: ext.Listen,
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
Handler: mux,
}
Added TLS to GQLThread
2023-07-21 01:05:24 -06:00
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
l, err := net.Listen("tcp", http_server.Addr)
if err != nil {
return fmt.Errorf("Failed to start listener for server on %s", http_server.Addr)
}
Started to add authentication for GQL endpoint
2023-07-19 14:45:05 -06:00
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
cert, err := tls.X509KeyPair(ext.tls_cert, ext.tls_key)
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
if err != nil {
return err
}
Add ChildGo to conveniently start children
2023-06-26 21:20:04 -06:00
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
config := tls.Config{
Certificates: []tls.Certificate{cert},
NextProtos: []string{"http/1.1"},
}
Started to add authentication for GQL endpoint
2023-07-19 14:45:05 -06:00
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
listener := tls.NewListener(l, &config)
start maniacal rewrite, main goal is to combine node and lockable to remove any sync mutex deadlocks. Another goal is to make read contexts get copies of the state to ensure they don't modify and no lock is required to ensure no value changes, and write contexts use the lockable locks instead of mutex
2023-07-22 20:21:17 -06:00
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
ext.http_done.Add(1)
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
go func(qql_ext *GQLExt) {
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
defer ext.http_done.Done()
start maniacal rewrite, main goal is to combine node and lockable to remove any sync mutex deadlocks. Another goal is to make read contexts get copies of the state to ensure they don't modify and no lock is required to ensure no value changes, and write contexts use the lockable locks instead of mutex
2023-07-22 20:21:17 -06:00
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
err := http_server.Serve(listener)
if err != http.ErrServerClosed {
panic(fmt.Sprintf("Failed to start gql server: %s", err))
start maniacal rewrite, main goal is to combine node and lockable to remove any sync mutex deadlocks. Another goal is to make read contexts get copies of the state to ensure they don't modify and no lock is required to ensure no value changes, and write contexts use the lockable locks instead of mutex
2023-07-22 20:21:17 -06:00
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
}(ext)
start maniacal rewrite, main goal is to combine node and lockable to remove any sync mutex deadlocks. Another goal is to make read contexts get copies of the state to ensure they don't modify and no lock is required to ensure no value changes, and write contexts use the lockable locks instead of mutex
2023-07-22 20:21:17 -06:00
Added gql to the rework
2023-07-26 00:18:11 -06:00
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
ext.tcp_listener = listener
ext.http_server = http_server
Switched from thread being the callback engine to node being the callback engine
2023-07-27 15:27:14 -06:00
return nil
Added base GQLThread
2023-06-25 20:20:59 -06:00
}
Renamed GQL functions to remove GQL
2023-07-29 11:03:41 -06:00
func (ext *GQLExt) StopGQLServer() error {
if ext.tcp_listener == nil || ext.http_server == nil {
return fmt.Errorf("already shutdown, cannot shut down again" )
}
ext.http_server.Shutdown(context.TODO())
ext.http_done.Wait()
ext.tcp_listener = nil
ext.http_server = nil
return nil
Added base GQLThread
2023-06-25 20:20:59 -06:00
}