Files

adcs_api

lib.rs

cbor_protocol

lib.rs

channel_protocol

error.rslib.rsparsers.rsprotocol.rs

clyde_3g_eps_api

commands

board_status.rschecksum.rslast_error.rsmod.rsreset.rsversion.rswatchdog.rs

telemetry

daughterboard.rslib.rsmod.rsmotherboard.rsreset.rs

eps.rslib.rs

clyde_3g_eps_service

models

board_status.rsdaughterboard_telemetry.rslast_error.rsmod.rsmotherboard_telemetry.rsreset_telemetry.rssubsystem.rsversion.rs

schema

mod.rsmutation.rsquery.rs

main.rs

comms_service

config.rserrors.rslib.rspacket.rsservice.rsspacepacket.rstelemetry.rs

db_test

main.rs

eps_api

lib.rs

example_rust_c_service

main.rsmodel.rsschema.rs

example_rust_service

main.rsmodel.rsschema.rs

extern_lib

lib.rs

file_protocol

error.rslib.rsmessages.rsparsers.rsprotocol.rsstorage.rs

file_service

lib.rs

iobc_supervisor_service

main.rsmodel.rsschema.rs

isis_ants

main.rs

isis_ants_api

ants.rsffi.rslib.rsparse.rs

isis_ants_service

main.rsmodel.rsobjects.rsschema.rs

isis_imtq_api

ffi.rsimtq.rslib.rs

isis_iobc_supervisor

ffi.rslib.rs

kubos_app

framework.rslib.rsquery.rs

kubos_app_service

app_entry.rserror.rsmain.rsmonitor.rsobjects.rsregistry.rsschema.rs

kubos_build_helper

lib.rs

kubos_file_client

main.rs

kubos_service

lib.rsmacros.rsservice.rs

kubos_shell_client

main.rs

kubos_system

config.rslib.rslogger.rsuboot.rs

kubos_telemetry_db

lib.rsmodels.rs

large_download

main.rs

large_upload

main.rs

local_comms_service

comms.rsmain.rs

mai400

main.rs

mai400_api

messages

rx

irehs.rsmod.rsraw_imu.rsrotating.rsstd_telem.rs

mod.rstx.rs

lib.rsmai400.rs

mai400_service

main.rsmodel.rsobjects.rsschema.rs

monitor_service

main.rsmeminfo.rsobjects.rsprocess.rsschema.rsuserinfo.rs

novatel_oem6_api

messages

commands

log.rsmod.rsunlog.rsunlog_all.rs

logs

best_xyz.rsmod.rsrxstatusevent.rsversion.rs

mod.rs

crc32.rslib.rsoem6.rs

novatel_oem6_service

main.rsmodel.rsobjects.rsschema.rs

nsl_duplex_d2

messages

file.rsgeo_record.rsmod.rsstate_of_health.rs

duplex_d2.rslib.rsserial_comm.rs

nsl_duplex_d2_comms_service

comms.rsmain.rsmodel.rsschema.rs

obc_hs

check_fs.rscheck_mem.rscheck_reset.rsclean_db.rsmain.rsping.rs

radio_api

lib.rs

rust_i2c

lib.rs

rust_mission_app

main.rs

rust_uart

error.rslib.rsmock.rs

scheduler_service

app.rserror.rsmain.rsmode.rsscheduler.rsschema.rstask.rstask_list.rs

serial_comms_service

comms.rskiss.rsmain.rsmodel.rsschema.rs

shell_protocol

messages

error.rsexit.rskill.rslist.rsmod.rspid.rsspawn.rsstderr.rsstdin.rsstdout.rs

error.rslib.rsprocess.rsprotocol.rs

shell_service

lib.rs

telemetry_service

main.rsschema.rsudp.rs

uart_comms_client

comms.rskiss.rsmain.rs

udp_client

main.rs

utils

lib.rstesting.rs

>

//
// Copyright (C) 2019 Kubos Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License")
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

//!
//! GraphQL schema for exposing communications service
//! telemetry information.
//!

use crate::model::{GeoRecordResponse, StateOfHealthResponse, Subsystem};
use juniper::FieldResult;

type Context = kubos_service::Context<Subsystem>;

pub struct QueryRoot;

graphql_object!(QueryRoot: Context as "Query" |&self| {
    // Test query to verify service is running without attempting
    // to communicate with the underlying subsystem
    //
    // Query
    //
    // {
    //     ping
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "ping": "pong"
    //     },
    //     "errors": ""
    // }
    field ping() -> FieldResult<String>
    {
        Ok(String::from("pong"))
    }

    // Request number of bad uplink packets
    //
    // Query
    //
    // {
    //     failedPacketsUp
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "failedPacketsUp" : 0
    //            },
    //     "errors" : ""
    // }
    field failed_packets_up(&executor) -> FieldResult<i32>
    {
        Ok(executor.context().subsystem().failed_packets_up()?)
    }

    // Request number of bad downlink packets
    //
    // Query
    //
    // {
    //     failedPacketsDown
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "failedPacketsDown" : 0
    //            },
    //     "errors" : ""
    // }
    field failed_packets_down(&executor) -> FieldResult<i32>
    {
        Ok(executor.context().subsystem().failed_packets_down()?)
    }

    // Request number of packets successfully uplinked
    //
    // Query
    //
    // {
    //     packetsUp
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "packetsUp" : 0
    //            },
    //     "errors" : ""
    // }
    field packets_up(&executor) -> FieldResult<i32>
    {
        Ok(executor.context().subsystem().packets_up()?)
    }

    // Request number of packets successfully downlinked
    //
    // Query
    //
    // {
    //     packetsDown
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "packetsDown" : 10
    //            },
    //     "errors" : ""
    // }
    field packets_down(&executor) -> FieldResult<i32>
    {
        Ok(executor.context().subsystem().packets_down()?)
    }

    // Request errors that have occured
    //
    // Query
    //
    // {
    //     errors
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "errors" : ["A UDP header was unable to be correctly parsed"]
    //            },
    //     "errors" : ""
    // }
    field errors(&executor) -> FieldResult<Vec<String>>
    {
        Ok(executor.context().subsystem().errors()?)
    }

    // Request current modem health information
    //
    // Query
    //
    // {
    //     modemHealth {
    //         resetCount,
    //         currentTime,
    //         currentRssi,
    //         connectionStatus,
    //         globalstarGateway,
    //         lastContactTime,
    //         lastAttemptTime,
    //         callAttemptsSinceReset,
    //         successfulConnectsSinceReset,
    //         averageConnectionDuration,
    //         connectionDurationStdDev
    //     }
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //         "modemHealth": {
    //             "resetCount": 1,
    //             "currentTime": 1025,
    //             "currentRssi": 3,
    //             "connectionStatus": 1,
    //             "globalstarGateway": 45,
    //             "lastContactTime": 500,
    //             "lastAttemptTime": 10,
    //             "callAttemptsSinceReset": 4,
    //             "successfulConnectsSinceReset": 25,
    //             "averageConnectionDuration": 120,
    //             "connectionDurationStdDev": 10,
    //         }
    //     },
    //     "errors" : ""
    // }
    field modem_health(&executor) -> FieldResult<StateOfHealthResponse>
    {
        Ok(executor.context().subsystem().modem_health()?)
    }

    // Request current geolocation data
    //
    // Query
    //
    // {
    //     geolocation {
    //         lon,
    //         lat,
    //         time,
    //         maxError
    //     }
    // }
    //
    // Response
    //
    // {
    //    "data": {
    //         "geolocation": {
    //             "lat": 22202.22,
    //             "lon": 3333.2,
    //             "time": 1818119191,
    //             "maxError": 100
    //         }
     //    },
    //     "errors" : ""
    // }
    field geolocation(&executor) -> FieldResult<GeoRecordResponse>
    {
        Ok(executor.context().subsystem().geolocation()?)
    }

    // Request number of files in the downlink queue
    //
    // Query
    //
    // {
    //     downlink_queue_count
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "downlink_queue_count" : 10
    //            },
    //     "errors" : ""
    // }
    field downlink_queue_count(&executor) -> FieldResult<i32>
    {
        Ok(executor.context().subsystem().file_queue_count()?)
    }

    // Queries the modem's 'is_alive' status
    //
    // Query
    //
    // {
    //     alive
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "alive": true
    //            },
    //     "errors" : ""
    // }
    field alive(&executor) -> FieldResult<bool>
    {
        Ok(executor.context().subsystem().get_alive()?)
    }
});

pub struct MutationRoot;

// Base GraphQL mutation model
graphql_object!(MutationRoot: Context as "Mutation" |&self| {
    // Execute a trivial command against the system
    //
    // Mutation
    //
    // mutation {
    //     noop
    // }
    //
    // Response
    //
    // {
    //     "data":{
    //                "noop": true
    //            },
    //     "errors" : ""
    // }
    field noop(&executor) -> FieldResult<bool>
    {
        Ok(executor.context().subsystem().get_alive()?)
    }
});