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 scheduler service's public interface
//!

use crate::mode::*;
use crate::scheduler::{Scheduler, SAFE_MODE};
use crate::task_list::{import_raw_task_list, import_task_list, remove_task_list};
use juniper::FieldResult;
use juniper::{graphql_object, GraphQLObject};
use kubos_service;
use serde::Deserialize;

type Context = kubos_service::Context<Scheduler>;

// Generic GraphQL Response
#[derive(Debug, Deserialize, GraphQLObject)]
pub struct GenericResponse {
    pub success: bool,
    pub errors: String,
}

pub struct QueryRoot;

// Base GraphQL query model
graphql_object!(QueryRoot: Context as "Query" |&self| {

    // Test query to verify service is running without attempting
    // to communicate with the underlying subsystem
    //
    // {
    //     ping: "pong"
    // }
    field ping() -> FieldResult<String>
    {
        Ok(String::from("pong"))
    }

    // Returns information on the currently active mode
    // {
    //     activeMode: {
    //         name: String,
    //         path: String,
    //         lastRevised: String,
    //         schedule: [TaskList],
    //         active: Boolean
    //     }
    // }
    field active_mode(&executor) -> FieldResult<Option<ScheduleMode>> as "Active Mode"
    {
        Ok(get_active_mode(&executor.context().subsystem().scheduler_dir)?)
    }

    // Returns a list of information on currently available modes
    // {
    //     availableModes: [
    //         {
    //             name: String,
    //             path: String,
    //             lastRevised: String,
    //             schedule: [TaskList],
    //             active: Boolean
    //         }
    //     ]
    // }
    field available_modes(&executor, name: Option<String>) -> FieldResult<Vec<ScheduleMode>> as "Available Modes"
    {
        Ok(get_available_modes(&executor.context().subsystem().scheduler_dir, name)?)
    }
});

pub struct MutationRoot;

// Base GraphQL mutation model
graphql_object!(MutationRoot: Context as "Mutation" |&self| {

    // Creates a new mode
    //
    // mutation {
    //     createMode(name: String!): {
    //         errors: String,
    //         success: Boolean
    //    }
    // }
    field create_mode(&executor, name: String) -> FieldResult<GenericResponse> {
        Ok(match create_mode(&executor.context().subsystem().scheduler_dir, &name) {
            Ok(_) => {
                GenericResponse { success: true, errors: "".to_owned() }
            },
            Err(error) => GenericResponse { success: false, errors: error.to_string() }
        })
    }

    // Removes an existing mode
    //
    // mutation {
    //     removeMode(name: String!): {
    //         errors: String,
    //         success: Boolean
    //    }
    // }
    field remove_mode(&executor, name: String) -> FieldResult<GenericResponse> {
        Ok(match remove_mode(&executor.context().subsystem().scheduler_dir, &name) {
            Ok(_) => {
                GenericResponse { success: true, errors: "".to_owned() }
            },
            Err(error) => GenericResponse { success: false, errors: error.to_string() }
        })
    }

    // Activates a mode
    //
    // mutation {
    //     activateMode(name: String!): {
    //         errors: String,
    //         success: Boolean
    //    }
    // }
    field activate_mode(&executor, name: String) -> FieldResult<GenericResponse> {
        if name == SAFE_MODE {
            return Ok(GenericResponse { success: false, errors: "Must use safeMode to activate safe".to_owned() });
        }
        Ok(match activate_mode(&executor.context().subsystem().scheduler_dir, &name)
        .and_then(|_| executor.context().subsystem().stop())
        .and_then(|_| executor.context().subsystem().start()) {
            Ok(_) => {
                GenericResponse { success: true, errors: "".to_owned() }
            },
            Err(error) => GenericResponse { success: false, errors: error.to_string() }
        })
    }

    // Activates the safe mode
    //
    // mutation {
    //     safeMode(): {
    //         errors: String,
    //         success: Boolean
    //    }
    // }
    field safe_mode(&executor) -> FieldResult<GenericResponse> {
        Ok(match activate_mode(&executor.context().subsystem().scheduler_dir, SAFE_MODE)
        .and_then(|_| executor.context().subsystem().stop())
        .and_then(|_| executor.context().subsystem().start()) {
            Ok(_) => {
                GenericResponse { success: true, errors: "".to_owned() }
            },
            Err(error) => GenericResponse { success: false, errors: error.to_string() }
        })
    }

    // Imports a new task list into a mode
    //
    // mutation {
    //     importTaskList(name: String!, path: String!, mode: String!): {
    //         errors: String,
    //         success: Boolean
    //    }
    // }
    field import_task_list(&executor, name: String, path: String, mode: String) -> FieldResult<GenericResponse> {
        Ok(match import_task_list(&executor.context().subsystem().scheduler_dir, &name, &path, &mode)
        .and_then(|_| executor.context().subsystem().check_stop_task_list(&name, &mode))
        .and_then(|_| executor.context().subsystem().check_start_task_list(&name, &mode)) {
            Ok(_) => GenericResponse { success: true, errors: "".to_owned() },
            Err(error) => GenericResponse { success: false, errors: error.to_string() }
        })
    }

    // Removes a task list from a mode
    //
    // mutation {
    //     removeTaskList(name: String!, mode:String!): {
    //         errors: String,
    //         success: Boolean
    //    }
    // }
    field remove_task_list(&executor, name: String, mode: String) -> FieldResult<GenericResponse> {
        Ok(match remove_task_list(&executor.context().subsystem().scheduler_dir, &name, &mode)
        .and_then(|_| executor.context().subsystem().check_stop_task_list(&name, &mode)) {
            Ok(_) => {
                GenericResponse { success: true, errors: "".to_owned() }
            },
            Err(error) => GenericResponse { success: false, errors: error.to_string() }
        })
    }

    // Imports a raw task list into a mode
    //
    // mutation {
    //     importRawTaskList(path: String!, name: String!, mode: String!): {
    //         errors: String,
    //         success: Boolean
    //    }
    // }
    field import_raw_task_list(&executor, name: String, mode: String, json: String) -> FieldResult<GenericResponse> {
        Ok(match import_raw_task_list(&executor.context().subsystem().scheduler_dir, &name, &mode, &json)
        .and_then(|_| executor.context().subsystem().check_stop_task_list(&name, &mode))
        .and_then(|_| executor.context().subsystem().check_start_task_list(&name, &mode)) {
            Ok(_) => GenericResponse { success: true, errors: "".to_owned() },
            Err(error) => GenericResponse { success: false, errors: error.to_string() }
        })
    }
});