routegrpc: move to new API definitions

routerpc/routegrpc/route.pb.gw.go

@@ -27,29 +27,8 @@ var _ io.Reader
 var _ = runtime.String
 var _ = utilities.NewDoubleArray
 
-var (
+func request_Routes_Get_0(ctx context.Context, marshaler runtime.Marshaler, client RoutesClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	filter_Hosts_AddHost_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+	var protoReq GetRouteRequest
-)
-
-func request_Hosts_AddHost_0(ctx context.Context, marshaler runtime.Marshaler, client HostsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq AddHostRequest
-	var metadata runtime.ServerMetadata
-
-	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Hosts_AddHost_0); err != nil {
-		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
-	}
-
-	msg, err := client.AddHost(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-var (
-	filter_Hosts_RemoveHost_0 = &utilities.DoubleArray{Encoding: map[string]int{"host": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
-)
-
-func request_Hosts_RemoveHost_0(ctx context.Context, marshaler runtime.Marshaler, client HostsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq RemoveHostRequest
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -70,21 +49,43 @@ func request_Hosts_RemoveHost_0(ctx context.Context, marshaler runtime.Marshaler
 		return nil, metadata, err
 	}
 
-	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Hosts_RemoveHost_0); err != nil {
+	msg, err := client.Get(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
+	return msg, metadata, err
-	}
 
-	msg, err := client.RemoveHost(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+}
+
+func request_Routes_GetAll_0(ctx context.Context, marshaler runtime.Marshaler, client RoutesClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq Nil
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.GetAll(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
 var (
-	filter_Hosts_GetHost_0 = &utilities.DoubleArray{Encoding: map[string]int{"host": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+	filter_Routes_Put_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
 
-func request_Hosts_GetHost_0(ctx context.Context, marshaler runtime.Marshaler, client HostsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+func request_Routes_Put_0(ctx context.Context, marshaler runtime.Marshaler, client RoutesClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq GetHostRequest
+	var protoReq Route
+	var metadata runtime.ServerMetadata
+
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Routes_Put_0); err != nil {
+		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.Put(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Routes_Delete_0 = &utilities.DoubleArray{Encoding: map[string]int{"host": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
+func request_Routes_Delete_0(ctx context.Context, marshaler runtime.Marshaler, client RoutesClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq Route
 	var metadata runtime.ServerMetadata
 
 	var (
@@ -105,52 +106,95 @@ func request_Hosts_GetHost_0(ctx context.Context, marshaler runtime.Marshaler, c
 		return nil, metadata, err
 	}
 
-	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Hosts_GetHost_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Routes_Delete_0); err != nil {
 		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := client.GetHost(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.Delete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
 var (
-	filter_Tokens_CreateInitialToken_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+	filter_Tokens_Get_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
 
-func request_Tokens_CreateInitialToken_0(ctx context.Context, marshaler runtime.Marshaler, client TokensClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+func request_Tokens_Get_0(ctx context.Context, marshaler runtime.Marshaler, client TokensClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq CreateInitialTokenRequest
+	var protoReq GetTokenRequest
 	var metadata runtime.ServerMetadata
 
-	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Tokens_CreateInitialToken_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Tokens_Get_0); err != nil {
 		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := client.CreateInitialToken(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.Get(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func request_Tokens_GetAll_0(ctx context.Context, marshaler runtime.Marshaler, client TokensClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq Nil
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.GetAll(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
 var (
-	filter_Users_Login_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+	filter_Tokens_Put_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
 
-func request_Users_Login_0(ctx context.Context, marshaler runtime.Marshaler, client UsersClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+func request_Tokens_Put_0(ctx context.Context, marshaler runtime.Marshaler, client TokensClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq LoginRequest
+	var protoReq Token
 	var metadata runtime.ServerMetadata
 
-	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Users_Login_0); err != nil {
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Tokens_Put_0); err != nil {
 		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
 	}
 
-	msg, err := client.Login(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	msg, err := client.Put(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
 	return msg, metadata, err
 
 }
 
-// RegisterHostsHandlerFromEndpoint is same as RegisterHostsHandler but
+var (
+	filter_Tokens_Delete_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Tokens_Delete_0(ctx context.Context, marshaler runtime.Marshaler, client TokensClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq Token
+	var metadata runtime.ServerMetadata
+
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Tokens_Delete_0); err != nil {
+		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.Delete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+var (
+	filter_Tokens_Deactivate_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Tokens_Deactivate_0(ctx context.Context, marshaler runtime.Marshaler, client TokensClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq Token
+	var metadata runtime.ServerMetadata
+
+	if err := runtime.PopulateQueryParameters(&protoReq, req.URL.Query(), filter_Tokens_Deactivate_0); err != nil {
+		return nil, metadata, grpc.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.Deactivate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+// RegisterRoutesHandlerFromEndpoint is same as RegisterRoutesHandler but
 // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
-func RegisterHostsHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
+func RegisterRoutesHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
 	conn, err := grpc.Dial(endpoint, opts...)
 	if err != nil {
 		return err
@@ -170,15 +214,15 @@ func RegisterHostsHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux
 		}()
 	}()
 
-	return RegisterHostsHandler(ctx, mux, conn)
+	return RegisterRoutesHandler(ctx, mux, conn)
 }
 
-// RegisterHostsHandler registers the http handlers for service Hosts to "mux".
+// RegisterRoutesHandler registers the http handlers for service Routes to "mux".
 // The handlers forward requests to the grpc endpoint over "conn".
-func RegisterHostsHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
+func RegisterRoutesHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
-	client := NewHostsClient(conn)
+	client := NewRoutesClient(conn)
 
-	mux.Handle("POST", pattern_Hosts_AddHost_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Routes_Get_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(ctx)
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
@@ -195,18 +239,18 @@ func RegisterHostsHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 		}
-		resp, md, err := request_Hosts_AddHost_0(rctx, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_Routes_Get_0(rctx, inboundMarshaler, client, req, pathParams)
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_Hosts_AddHost_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Routes_Get_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("DELETE", pattern_Hosts_RemoveHost_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Routes_GetAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(ctx)
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
@@ -223,18 +267,18 @@ func RegisterHostsHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 		}
-		resp, md, err := request_Hosts_RemoveHost_0(rctx, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_Routes_GetAll_0(rctx, inboundMarshaler, client, req, pathParams)
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_Hosts_RemoveHost_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Routes_GetAll_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	mux.Handle("GET", pattern_Hosts_GetHost_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("POST", pattern_Routes_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(ctx)
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
@@ -251,14 +295,42 @@ func RegisterHostsHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 		}
-		resp, md, err := request_Hosts_GetHost_0(rctx, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_Routes_Put_0(rctx, inboundMarshaler, client, req, pathParams)
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_Hosts_GetHost_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Routes_Put_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("DELETE", pattern_Routes_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		if cn, ok := w.(http.CloseNotifier); ok {
+			go func(done <-chan struct{}, closed <-chan bool) {
+				select {
+				case <-done:
+				case <-closed:
+					cancel()
+				}
+			}(ctx.Done(), cn.CloseNotify())
+		}
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, req)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+		}
+		resp, md, err := request_Routes_Delete_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Routes_Delete_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -266,19 +338,23 @@ func RegisterHostsHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 }
 
 var (
-	pattern_Hosts_AddHost_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "hosts", "create"}, ""))
+	pattern_Routes_Get_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "routes", "host"}, ""))
 
-	pattern_Hosts_RemoveHost_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "hosts", "host"}, ""))
+	pattern_Routes_GetAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "routes"}, ""))
 
-	pattern_Hosts_GetHost_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "hosts", "host"}, ""))
+	pattern_Routes_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "routes"}, ""))
+
+	pattern_Routes_Delete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1", "routes", "host"}, ""))
 )
 
 var (
-	forward_Hosts_AddHost_0 = runtime.ForwardResponseMessage
+	forward_Routes_Get_0 = runtime.ForwardResponseMessage
 
-	forward_Hosts_RemoveHost_0 = runtime.ForwardResponseMessage
+	forward_Routes_GetAll_0 = runtime.ForwardResponseMessage
 
-	forward_Hosts_GetHost_0 = runtime.ForwardResponseMessage
+	forward_Routes_Put_0 = runtime.ForwardResponseMessage
+
+	forward_Routes_Delete_0 = runtime.ForwardResponseMessage
 )
 
 // RegisterTokensHandlerFromEndpoint is same as RegisterTokensHandler but
@@ -311,7 +387,7 @@ func RegisterTokensHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMu
 func RegisterTokensHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
 	client := NewTokensClient(conn)
 
-	mux.Handle("POST", pattern_Tokens_CreateInitialToken_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+	mux.Handle("GET", pattern_Tokens_Get_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(ctx)
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
@@ -328,59 +404,18 @@ func RegisterTokensHandler(ctx context.Context, mux *runtime.ServeMux, conn *grp
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 		}
-		resp, md, err := request_Tokens_CreateInitialToken_0(rctx, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_Tokens_Get_0(rctx, inboundMarshaler, client, req, pathParams)
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_Tokens_CreateInitialToken_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Tokens_Get_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
-	return nil
+	mux.Handle("GET", pattern_Tokens_GetAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-}
-
-var (
-	pattern_Tokens_CreateInitialToken_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "tokens", "createInitialToken"}, ""))
-)
-
-var (
-	forward_Tokens_CreateInitialToken_0 = runtime.ForwardResponseMessage
-)
-
-// RegisterUsersHandlerFromEndpoint is same as RegisterUsersHandler but
-// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
-func RegisterUsersHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
-	conn, err := grpc.Dial(endpoint, opts...)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err != nil {
-			if cerr := conn.Close(); cerr != nil {
-				grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
-			}
-			return
-		}
-		go func() {
-			<-ctx.Done()
-			if cerr := conn.Close(); cerr != nil {
-				grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
-			}
-		}()
-	}()
-
-	return RegisterUsersHandler(ctx, mux, conn)
-}
-
-// RegisterUsersHandler registers the http handlers for service Users to "mux".
-// The handlers forward requests to the grpc endpoint over "conn".
-func RegisterUsersHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
-	client := NewUsersClient(conn)
-
-	mux.Handle("POST", pattern_Users_Login_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(ctx)
 		defer cancel()
 		if cn, ok := w.(http.CloseNotifier); ok {
@@ -397,14 +432,98 @@ func RegisterUsersHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 		}
-		resp, md, err := request_Users_Login_0(rctx, inboundMarshaler, client, req, pathParams)
+		resp, md, err := request_Tokens_GetAll_0(rctx, inboundMarshaler, client, req, pathParams)
 		ctx = runtime.NewServerMetadataContext(ctx, md)
 		if err != nil {
 			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
 			return
 		}
 
-		forward_Users_Login_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+		forward_Tokens_GetAll_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("POST", pattern_Tokens_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		if cn, ok := w.(http.CloseNotifier); ok {
+			go func(done <-chan struct{}, closed <-chan bool) {
+				select {
+				case <-done:
+				case <-closed:
+					cancel()
+				}
+			}(ctx.Done(), cn.CloseNotify())
+		}
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, req)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+		}
+		resp, md, err := request_Tokens_Put_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Tokens_Put_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("DELETE", pattern_Tokens_Delete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		if cn, ok := w.(http.CloseNotifier); ok {
+			go func(done <-chan struct{}, closed <-chan bool) {
+				select {
+				case <-done:
+				case <-closed:
+					cancel()
+				}
+			}(ctx.Done(), cn.CloseNotify())
+		}
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, req)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+		}
+		resp, md, err := request_Tokens_Delete_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Tokens_Delete_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("POST", pattern_Tokens_Deactivate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		if cn, ok := w.(http.CloseNotifier); ok {
+			go func(done <-chan struct{}, closed <-chan bool) {
+				select {
+				case <-done:
+				case <-closed:
+					cancel()
+				}
+			}(ctx.Done(), cn.CloseNotify())
+		}
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, req)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+		}
+		resp, md, err := request_Tokens_Deactivate_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Tokens_Deactivate_0(ctx, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 
 	})
 
@@ -412,9 +531,25 @@ func RegisterUsersHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 }
 
 var (
-	pattern_Users_Login_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "users", "login"}, ""))
+	pattern_Tokens_Get_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "tokens", "one"}, ""))
+
+	pattern_Tokens_GetAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "tokens"}, ""))
+
+	pattern_Tokens_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "tokens"}, ""))
+
+	pattern_Tokens_Delete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "tokens"}, ""))
+
+	pattern_Tokens_Deactivate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "tokens", "deactivate"}, ""))
 )
 
 var (
-	forward_Users_Login_0 = runtime.ForwardResponseMessage
+	forward_Tokens_Get_0 = runtime.ForwardResponseMessage
+
+	forward_Tokens_GetAll_0 = runtime.ForwardResponseMessage
+
+	forward_Tokens_Put_0 = runtime.ForwardResponseMessage
+
+	forward_Tokens_Delete_0 = runtime.ForwardResponseMessage
+
+	forward_Tokens_Deactivate_0 = runtime.ForwardResponseMessage
 )

routerpc/routegrpc/route.proto

@@ -2,103 +2,100 @@ syntax = "proto3";
 
 // option go_package = "git.xeserv.us/xena/route/routerpc/routegrpc;routegrpc";
 
+package route;
+
 import "google/api/annotations.proto";
 
-message BaseAPICall {
+message Nil {}
-  string token = 1;
-}
 
-service Hosts {
+service Routes {
-  rpc AddHost(AddHostRequest) returns (AddHostResponse) {
+  rpc Get(GetRouteRequest) returns (Route) {
     option (google.api.http) = {
-      post: "/v1/hosts/create"
+      get: "/v1/routes/{host}"
     };
   }
-  rpc RemoveHost(RemoveHostRequest) returns (RemoveHostResponse) {
+
+  rpc GetAll(Nil) returns (GetAllRoutesResponse) {
     option (google.api.http) = {
-      delete: "/v1/hosts/{host}"
+      get: "/v1/routes"
     };
   }
-  rpc GetHost(GetHostRequest) returns (GetHostResponse) {
+
+  rpc Put(Route) returns (IDResponse) {
     option (google.api.http) = {
-      get: "/v1/hosts/{host}"
+      post: "/v1/routes"
+    };
+  }
+
+  rpc Delete(Route) returns (IDResponse) {
+    option (google.api.http) = {
+      delete: "/v1/routes/{host}"
     };
   }
 }
 
-message Host {
+message GetRouteRequest {
+  string host = 1;
+}
+
+message Route {
   string id = 1;
-  string hostname = 2;
+  string creator = 2;
-  string onionHostname = 3;
+  string host = 3;
-  string token = 4;
-  bytes onionKey = 5;
-  int32 kind = 6;
-  string port = 7;
 }
 
-message AddHostRequest {
+message GetAllRoutesResponse {
-  BaseAPICall base = 1;
+  repeated Route routes = 1;
-  string hostname = 2;
-  bytes onionKey = 3;
 }
 
-message AddHostResponse {
+message IDResponse {
   string id = 1;
-  string token = 2;
-  string hostname = 3;
-  string onionHostname = 4;
-}
-
-message RemoveHostRequest {
-  BaseAPICall base = 1;
-  string host = 2;
-}
-
-message RemoveHostResponse {
-  bool success = 1;
-}
-
-message GetHostRequest {
-  BaseAPICall base = 1;
-  string host = 2;
-  string onionHost = 3;
-  string id = 4;
-}
-
-message GetHostResponse {
-  Host host = 1;
 }
 
 service Tokens {
-  rpc CreateInitialToken(CreateInitialTokenRequest) returns (CreateInitialTokenResponse) {
+  rpc Get(GetTokenRequest) returns (Token) {
     option (google.api.http) = {
-      post: "/v1/tokens/createInitialToken"
+      get: "/v1/tokens/one"
+    };
+  }
+
+  rpc GetAll(Nil) returns (TokenSet) {
+    option (google.api.http) = {
+      get: "/v1/tokens"
+    };
+  }
+
+  rpc Put(Token) returns (IDResponse) {
+    option (google.api.http) = {
+      post: "/v1/tokens"
+    };
+  }
+
+  rpc Delete(Token) returns (Nil) {
+    option (google.api.http) = {
+      delete: "/v1/tokens"
+    };
+  }
+
+  rpc Deactivate(Token) returns (Nil) {
+    option (google.api.http) = {
+      post: "/v1/tokens/deactivate"
     };
   }
 }
 
-message CreateInitialTokenRequest {
+message Token {
-  string username = 1;
+  string id = 1;
+  string body = 2;
+  repeated string scopes = 3;
+  bool active = 4;
 }
 
-message CreateInitialTokenResponse {
+message TokenSet {
+  repeated Token tokens = 1;
+}
+
+message GetTokenRequest {
   string token = 1;
-  string tokenid = 2;
+  string id = 2;
-}
-
-service Users {
-  rpc Login(LoginRequest) returns (LoginResponse) {
-    option (google.api.http) = {
-      post: "/v1/users/login"
-    };
-  }
-}
-
-message LoginRequest {
-  string oauth2provider = 1;
-}
-
-message LoginResponse {
-  string token = 1;
-  string uid = 2;
 }

routerpc/routegrpc/route.swagger.json

@@ -15,30 +15,44 @@
     "application/json"
   ],
   "paths": {
-    "/v1/hosts/create": {
+    "/v1/routes": {
-      "post": {
+      "get": {
-        "operationId": "AddHost",
+        "operationId": "GetAll",
         "responses": {
           "200": {
             "description": "",
             "schema": {
-              "$ref": "#/definitions/AddHostResponse"
+              "$ref": "#/definitions/routeGetAllRoutesResponse"
             }
           }
         },
         "tags": [
-          "Hosts"
+          "Routes"
         ]
-      }
+      },
-    },
+      "post": {
-    "/v1/hosts/{host}": {
+        "operationId": "Put",
-      "get": {
-        "operationId": "GetHost",
         "responses": {
           "200": {
             "description": "",
             "schema": {
-              "$ref": "#/definitions/GetHostResponse"
+              "$ref": "#/definitions/routeIDResponse"
+            }
+          }
+        },
+        "tags": [
+          "Routes"
+        ]
+      }
+    },
+    "/v1/routes/{host}": {
+      "get": {
+        "operationId": "Get",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "$ref": "#/definitions/routeRoute"
             }
           }
         },
@@ -48,15 +62,109 @@
             "in": "path",
             "required": true,
             "type": "string"
-          },
+          }
+        ],
+        "tags": [
+          "Routes"
+        ]
+      },
+      "delete": {
+        "operationId": "Delete",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "$ref": "#/definitions/routeIDResponse"
+            }
+          }
+        },
+        "parameters": [
           {
-            "name": "base.token",
+            "name": "host",
-            "in": "query",
+            "in": "path",
-            "required": false,
+            "required": true,
             "type": "string"
-          },
+          }
+        ],
+        "tags": [
+          "Routes"
+        ]
+      }
+    },
+    "/v1/tokens": {
+      "get": {
+        "operationId": "GetAll",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "$ref": "#/definitions/routeTokenSet"
+            }
+          }
+        },
+        "tags": [
+          "Tokens"
+        ]
+      },
+      "delete": {
+        "operationId": "Delete",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "$ref": "#/definitions/routeNil"
+            }
+          }
+        },
+        "tags": [
+          "Tokens"
+        ]
+      },
+      "post": {
+        "operationId": "Put",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "$ref": "#/definitions/routeIDResponse"
+            }
+          }
+        },
+        "tags": [
+          "Tokens"
+        ]
+      }
+    },
+    "/v1/tokens/deactivate": {
+      "post": {
+        "operationId": "Deactivate",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "$ref": "#/definitions/routeNil"
+            }
+          }
+        },
+        "tags": [
+          "Tokens"
+        ]
+      }
+    },
+    "/v1/tokens/one": {
+      "get": {
+        "operationId": "Get",
+        "responses": {
+          "200": {
+            "description": "",
+            "schema": {
+              "$ref": "#/definitions/routeToken"
+            }
+          }
+        },
+        "parameters": [
           {
-            "name": "onionHost",
+            "name": "token",
             "in": "query",
             "required": false,
             "type": "string"
@@ -68,136 +176,36 @@
             "type": "string"
           }
         ],
-        "tags": [
-          "Hosts"
-        ]
-      },
-      "delete": {
-        "operationId": "RemoveHost",
-        "responses": {
-          "200": {
-            "description": "",
-            "schema": {
-              "$ref": "#/definitions/RemoveHostResponse"
-            }
-          }
-        },
-        "parameters": [
-          {
-            "name": "host",
-            "in": "path",
-            "required": true,
-            "type": "string"
-          }
-        ],
-        "tags": [
-          "Hosts"
-        ]
-      }
-    },
-    "/v1/tokens/createInitialToken": {
-      "post": {
-        "operationId": "CreateInitialToken",
-        "responses": {
-          "200": {
-            "description": "",
-            "schema": {
-              "$ref": "#/definitions/CreateInitialTokenResponse"
-            }
-          }
-        },
         "tags": [
           "Tokens"
         ]
       }
-    },
-    "/v1/users/login": {
-      "post": {
-        "operationId": "Login",
-        "responses": {
-          "200": {
-            "description": "",
-            "schema": {
-              "$ref": "#/definitions/LoginResponse"
-            }
-          }
-        },
-        "tags": [
-          "Users"
-        ]
-      }
     }
   },
   "definitions": {
-    "AddHostRequest": {
+    "routeGetAllRoutesResponse": {
       "type": "object",
       "properties": {
-        "base": {
+        "routes": {
-          "$ref": "#/definitions/BaseAPICall"
+          "type": "array",
-        },
+          "items": {
-        "hostname": {
+            "$ref": "#/definitions/routeRoute"
-          "type": "string"
+          }
-        },
-        "onionKey": {
-          "type": "string",
-          "format": "byte"
         }
       }
     },
-    "AddHostResponse": {
+    "routeGetRouteRequest": {
       "type": "object",
       "properties": {
-        "id": {
-          "type": "string"
-        },
-        "token": {
-          "type": "string"
-        },
-        "hostname": {
-          "type": "string"
-        },
-        "onionHostname": {
-          "type": "string"
-        }
-      }
-    },
-    "BaseAPICall": {
-      "type": "object",
-      "properties": {
-        "token": {
-          "type": "string"
-        }
-      }
-    },
-    "CreateInitialTokenRequest": {
-      "type": "object",
-      "properties": {
-        "username": {
-          "type": "string"
-        }
-      }
-    },
-    "CreateInitialTokenResponse": {
-      "type": "object",
-      "properties": {
-        "token": {
-          "type": "string"
-        },
-        "tokenid": {
-          "type": "string"
-        }
-      }
-    },
-    "GetHostRequest": {
-      "type": "object",
-      "properties": {
-        "base": {
-          "$ref": "#/definitions/BaseAPICall"
-        },
         "host": {
           "type": "string"
-        },
+        }
-        "onionHost": {
+      }
+    },
+    "routeGetTokenRequest": {
+      "type": "object",
+      "properties": {
+        "token": {
           "type": "string"
         },
         "id": {
@@ -205,80 +213,62 @@
         }
       }
     },
-    "GetHostResponse": {
+    "routeIDResponse": {
       "type": "object",
       "properties": {
-        "host": {
+        "id": {
-          "$ref": "#/definitions/Host"
+          "type": "string"
         }
       }
     },
-    "Host": {
+    "routeNil": {
+      "type": "object"
+    },
+    "routeRoute": {
       "type": "object",
       "properties": {
         "id": {
           "type": "string"
         },
-        "hostname": {
+        "creator": {
           "type": "string"
         },
-        "onionHostname": {
-          "type": "string"
-        },
-        "token": {
-          "type": "string"
-        },
-        "onionKey": {
-          "type": "string",
-          "format": "byte"
-        },
-        "kind": {
-          "type": "integer",
-          "format": "int32"
-        },
-        "port": {
-          "type": "string"
-        }
-      }
-    },
-    "LoginRequest": {
-      "type": "object",
-      "properties": {
-        "oauth2provider": {
-          "type": "string"
-        }
-      }
-    },
-    "LoginResponse": {
-      "type": "object",
-      "properties": {
-        "token": {
-          "type": "string"
-        },
-        "uid": {
-          "type": "string"
-        }
-      }
-    },
-    "RemoveHostRequest": {
-      "type": "object",
-      "properties": {
-        "base": {
-          "$ref": "#/definitions/BaseAPICall"
-        },
         "host": {
           "type": "string"
         }
       }
     },
-    "RemoveHostResponse": {
+    "routeToken": {
       "type": "object",
       "properties": {
-        "success": {
+        "id": {
+          "type": "string"
+        },
+        "body": {
+          "type": "string"
+        },
+        "scopes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "active": {
           "type": "boolean",
           "format": "boolean"
         }
       }
+    },
+    "routeTokenSet": {
+      "type": "object",
+      "properties": {
+        "tokens": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/routeToken"
+          }
+        }
+      }
     }
   }
 }