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.
//

//! Service mutations

use crate::models::subsystem::Mutations;
use crate::models::{MutationResponse, TestType};
use crate::schema::Context;
use juniper::FieldResult;

/// Top-level mutation root structure
pub struct Root;

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

    // Execute a trivial command against the system
    //
    //  mutation {
    //      noop {
    //          success: Boolean!
    //          errors: String!
    //      }
    //  }
    field noop(&executor) -> FieldResult<MutationResponse>
        as "Run no-op command"
    {
        executor.context().subsystem().set_last_mutation(Mutations::Noop);
        Ok(executor.context().subsystem().reset_watchdog()?)
    }

    //  Manually reset the EPS
    //
    //  mutation {
    //      manualReset {
    //          success: Boolean!
    //          errors: String!
    //      }
    //  }
    field manual_reset(&executor) -> FieldResult<MutationResponse>
        as "Perform manual reset of EPS board"
    {
        executor.context().subsystem().set_last_mutation(Mutations::ManualReset);
        Ok(executor.context().subsystem().manual_reset()?)
    }

    //  Reset the communications watchdog timer
    //
    //  mutation {
    //      resetWatchdog {
    //          success: Boolean!
    //          errors: String!
    //      }
    //  }
    field reset_watchdog(&executor) -> FieldResult<MutationResponse>
        as "Reset/kick communications watchdog"
    {
        executor.context().subsystem().set_last_mutation(Mutations::ResetWatchdog);
        Ok(executor.context().subsystem().reset_watchdog()?)
    }

    //  Set the communications watchdog timeout period
    //
    //  - period: New timeout period, in minutes
    //
    //  mutation {
    //      setWatchdogPeriod(period: Int!) {
    //          success: Boolean!
    //          errors: String!
    //      }
    //  }
    field set_watchdog_period(&executor, period: i32) -> FieldResult<MutationResponse>
        as "Set watchdog period (in minutes)"
    {
        executor.context().subsystem().set_last_mutation(Mutations::SetWatchdogPeriod);
        Ok(executor.context().subsystem().set_watchdog_period(period as u8)?)
    }

    //  Pass a custom command through to the system
    //
    //  - command: Decimal value of the command byte to send
    //  - data: Decimal values of the command parameters to send. Should be `[0]` if there are no additional parameters required.
    //
    //  mutation {
    //      issueRawCommand(command: Int!, data: [Int!]) {
    //          success: Boolean!
    //          errors: String!
    //      }
    //  }
    field issue_raw_command(&executor, command: i32, data: Vec<i32>) -> FieldResult<MutationResponse>
        as "Issue raw command to EPS"
    {
        executor.context().subsystem().set_last_mutation(Mutations::RawCommand);
        let data_u8 = data.iter().map(|x| *x as u8).collect();
        Ok(executor.context().subsystem().raw_command(command as u8, data_u8)?)
    }

    // Perform a system test
    //
    // - test: Specific test to perform. Should be `HARDWARE`
    //
    //  mutation {
    //      testHardware(test: TestType) {
    //          success: Boolean!
    //          errors: String!
    //      }
    //  }
    field testHardware(&executor, test: TestType) -> FieldResult<MutationResponse>
        as "Test hardware"
    {
        executor.context().subsystem().set_last_mutation(Mutations::TestHardware);

        match test {
            TestType::Hardware => Ok(executor.context().subsystem().test_hardware()?),
            TestType::Integration => Ok(MutationResponse {
                    errors: "Not Implemented".to_owned(),
                    success: false
            })
        }
    }
});