| /* |
| * |
| * Copyright (c) 2017 Nest Labs, Inc. |
| * All rights reserved. |
| * |
| * 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. |
| */ |
| |
| /** |
| * @file |
| * This file implements a few mock event generators |
| * |
| */ |
| |
| #ifndef __STDC_LIMIT_MACROS |
| #define __STDC_LIMIT_MACROS |
| #endif |
| #include <new> |
| #include <stdint.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include <nlbyteorder.h> |
| #include "ToolCommon.h" |
| |
| #include <InetLayer/Inet.h> |
| #include <Weave/Core/WeaveCore.h> |
| #include <Weave/Core/WeaveMessageLayer.h> |
| #include <Weave/Core/WeaveEncoding.h> |
| #include <Weave/Core/WeaveTLV.h> |
| #include <Weave/Core/WeaveTLVDebug.hpp> |
| #include <Weave/Core/WeaveTLVUtilities.hpp> |
| #include <Weave/Core/WeaveTLVData.hpp> |
| #include <Weave/Core/WeaveSecurityMgr.h> |
| #include <Weave/Profiles/security/WeaveSecurity.h> |
| #include <Weave/Profiles/ProfileCommon.h> |
| #include <Weave/Support/TraitEventUtils.h> |
| |
| #include <MockEvents.h> |
| |
| #include "schema/weave/trait/telemetry/NetworkWiFiTelemetryTrait.h" |
| #include <schema/weave/common/DayOfWeekEnum.h> |
| #include <schema/nest/test/trait/TestCommonTrait.h> |
| |
| using namespace nl::Weave::TLV; |
| using namespace nl::Weave::Profiles::DataManagement; |
| using namespace Schema::Maldives_prototype::Trait::Flintstone::NetworkWiFiTelemetryTrait; |
| using namespace Schema::Nest::Test::Trait::TestETrait; |
| using namespace Schema::Nest::Test::Trait; |
| using namespace Schema::Weave::Common; |
| |
| static const uint64_t kTestNodeId = 0x18B4300001408362ULL; |
| static const uint64_t kTestNodeId1 = 0x18B43000002DCF71ULL; |
| static char kTestUserId[] = "USER_0123456789ABCDEF"; |
| |
| // ResourceID helper |
| |
| // tags for ResourceID structure |
| #ifdef PHOENIX_RESOURCE_STRINGS |
| |
| const uint64_t kResourceIDTag = ContextTag(1); |
| |
| WEAVE_ERROR WriteResourceID(nl::Weave::TLV::TLVWriter & writer, const uint64_t & tag, user_id_t resourceId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| nl::Weave::TLV::TLVType container; |
| |
| VerifyOrExit(resourceId != NULL, err = WEAVE_NO_ERROR); |
| |
| err = writer.StartContainer(tag, nl::Weave::TLV::kTLVType_Structure, container); |
| SuccessOrExit(err); |
| |
| err = writer.PutString(kResourceIDTag, resourceId); |
| SuccessOrExit(err); |
| |
| err = writer.EndContainer(container); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| #else // PHOENIX_RESOURCE_STRINGS |
| |
| WEAVE_ERROR WriteResourceID(nl::Weave::TLV::TLVWriter & writer, const uint64_t & tag, user_id_t resourceId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| if (resourceId != 0) |
| err = writer.Put(tag, resourceId); |
| |
| return err; |
| } |
| #endif // PHOENIX_RESOURCE_STRINGS |
| |
| |
| const uint32_t kLivenessTraitID = 0x00000022; |
| const uint32_t kLivenessChangeEvent = 1; |
| const uint64_t kLivenessDeviceStatus = nl::Weave::TLV::ContextTag(1); |
| |
| static WEAVE_ERROR WriteLivenessStatusEvent(nl::Weave::TLV::TLVWriter & writer, uint8_t inDataTag, void * anAppState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| nl::Weave::TLV::TLVType liveness; |
| int32_t * context = static_cast<int32_t *>(anAppState); |
| |
| VerifyOrExit(context != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| err = writer.StartContainer(ContextTag(nl::Weave::Profiles::DataManagement::kTag_EventData), nl::Weave::TLV::kTLVType_Structure, liveness); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kLivenessDeviceStatus, *context); |
| SuccessOrExit(err); |
| |
| err = writer.EndContainer(liveness); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| event_id_t LogLiveness(uint64_t inNodeID, LivenessDeviceStatus inStatus) |
| { |
| nl::Weave::Profiles::DataManagement::EventOptions options; |
| nl::Weave::Profiles::DataManagement::DetailedRootSection root; |
| static EventSchema schema = { |
| kLivenessTraitID, |
| kLivenessChangeEvent, |
| nl::Weave::Profiles::DataManagement::Production, |
| 1, |
| 1 |
| }; |
| int32_t status = static_cast<int32_t>(inStatus); |
| |
| root.ResourceID = inNodeID; |
| root.TraitInstanceID = 0; |
| |
| options = EventOptions((uint32_t)0, &root, 0, nl::Weave::Profiles::DataManagement::kImportanceType_Invalid, true); |
| |
| return nl::Weave::Profiles::DataManagement::LogEvent( |
| schema, |
| WriteLivenessStatusEvent, |
| &status, |
| &options); |
| } |
| |
| /************************************************************************/ |
| |
| // Pincode input trait. |
| const uint32_t kPincodeInputTraitID = 0x00000e05; |
| const uint32_t kKeypadEntryEvent = 1; |
| const uint32_t kUserDisabledEvent = 2; |
| |
| const uint64_t kPincodeStatus = nl::Weave::TLV::ContextTag(1); |
| const uint64_t kUserID = nl::Weave::TLV::ContextTag(2); |
| const uint64_t kInvalidEntryCount = nl::Weave::TLV::ContextTag(3); |
| const uint64_t kPincodeEntryResult = nl::Weave::TLV::ContextTag(4); |
| |
| const uint64_t kUserDisabled = nl::Weave::TLV::ContextTag(1); |
| |
| KeypadEntryEventStruct::KeypadEntryEventStruct() : |
| user_id(USER_ID_INITIAL), |
| invalidEntryCount(0), |
| status(0), |
| entryResult(0) |
| { |
| } |
| |
| UserDisabledEventStruct::UserDisabledEventStruct() : |
| user_id(USER_ID_INITIAL), |
| disabled(false) |
| { |
| } |
| |
| static WEAVE_ERROR WriteKeypadEntryEvent(nl::Weave::TLV::TLVWriter & writer, uint8_t inDataTag, void * anAppState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| nl::Weave::TLV::TLVType keypadEntry; |
| KeypadEntryEventStruct * context = static_cast<KeypadEntryEventStruct *>(anAppState); |
| |
| VerifyOrExit(context != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| err = writer.StartContainer(ContextTag(nl::Weave::Profiles::DataManagement::kTag_EventData), nl::Weave::TLV::kTLVType_Structure, keypadEntry); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kPincodeStatus, context->status); |
| SuccessOrExit(err); |
| |
| err = WriteResourceID(writer, kUserID, context->user_id); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kInvalidEntryCount, context->invalidEntryCount); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kPincodeEntryResult, context->entryResult); |
| SuccessOrExit(err); |
| |
| err = writer.EndContainer(keypadEntry); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| event_id_t LogKeypadEntry(CredentialStatus inStatus, PincodeEntryResult inResult, user_id_t inUserID) |
| { |
| static KeypadEntryEventStruct eventStruct; |
| static EventSchema schema = { |
| kPincodeInputTraitID, |
| kKeypadEntryEvent, |
| nl::Weave::Profiles::DataManagement::Production, |
| 1, |
| 1 |
| }; |
| |
| if (inResult == PINCODE_ENTRY_RESULT_SUCCESS) |
| { |
| eventStruct.invalidEntryCount = 0; |
| } |
| else |
| { |
| eventStruct.invalidEntryCount++; |
| } |
| |
| eventStruct.user_id = inUserID; |
| eventStruct.status = inStatus; |
| eventStruct.entryResult = inResult; |
| |
| return nl::Weave::Profiles::DataManagement::LogEvent( |
| schema, |
| WriteKeypadEntryEvent, |
| &eventStruct); |
| } |
| |
| static WEAVE_ERROR WriteUserDisabledEvent(nl::Weave::TLV::TLVWriter & writer, uint8_t inDataTag, void * anAppState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| nl::Weave::TLV::TLVType userDisabled; |
| UserDisabledEventStruct * context = static_cast<UserDisabledEventStruct *>(anAppState); |
| |
| VerifyOrExit(context != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| err = writer.StartContainer(ContextTag(nl::Weave::Profiles::DataManagement::kTag_EventData), nl::Weave::TLV::kTLVType_Structure, userDisabled); |
| SuccessOrExit(err); |
| |
| err = writer.PutBoolean(kUserDisabled, context->disabled); |
| SuccessOrExit(err); |
| |
| err = WriteResourceID(writer, kUserID, context->user_id); |
| SuccessOrExit(err); |
| |
| err = writer.EndContainer(userDisabled); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| event_id_t LogKeypadEnable(bool inEnable, user_id_t inUserID) |
| { |
| UserDisabledEventStruct eventStruct; |
| static EventSchema schema = { |
| kPincodeInputTraitID, |
| kUserDisabledEvent, |
| nl::Weave::Profiles::DataManagement::Production, |
| 1, |
| 1 |
| }; |
| |
| eventStruct.user_id = inUserID; |
| eventStruct.disabled = !inEnable; |
| |
| return nl::Weave::Profiles::DataManagement::LogEvent( |
| schema, |
| WriteUserDisabledEvent, |
| &eventStruct); |
| } |
| |
| /************************************************************************/ |
| |
| // Bolt lock trait. |
| |
| const uint32_t kBoltLockTraitID = 0x00000e02; |
| const uint32_t kBoltActuatorStateChangeEvent = 1; |
| |
| const uint64_t kBoltState = nl::Weave::TLV::ContextTag(1); |
| const uint64_t kActuatorState = nl::Weave::TLV::ContextTag(2); |
| const uint64_t kLockedState = nl::Weave::TLV::ContextTag(3); |
| const uint64_t kBlame = nl::Weave::TLV::ContextTag(4); |
| const uint64_t kWhoDunnit = nl::Weave::TLV::ContextTag(5); |
| |
| BoltActuatorEventStruct::BoltActuatorEventStruct() : |
| user_id(USER_ID_INITIAL), |
| state(0), |
| actuatorState(0), |
| lockedState(0), |
| blame(0) |
| { |
| } |
| |
| static WEAVE_ERROR WriteBoltActuatorStateChangeEvent(nl::Weave::TLV::TLVWriter & writer, uint8_t inDataTag, void * anAppState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| nl::Weave::TLV::TLVType userDisabled; |
| BoltActuatorEventStruct * context = static_cast<BoltActuatorEventStruct *>(anAppState); |
| |
| VerifyOrExit(context != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| err = writer.StartContainer(ContextTag(nl::Weave::Profiles::DataManagement::kTag_EventData), nl::Weave::TLV::kTLVType_Structure, userDisabled); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kBoltState, context->state); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kActuatorState, context->actuatorState); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kLockedState, context->lockedState); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kBlame, context->blame); |
| SuccessOrExit(err); |
| |
| err = WriteResourceID(writer, kWhoDunnit, context->user_id); |
| SuccessOrExit(err); |
| |
| err = writer.EndContainer(userDisabled); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| event_id_t LogBoltStateChange(BoltState inState, BoltActuatorState inActuatorState, BoltLockedState inLockedState, BoltBlame inBlame, user_id_t inUserID, event_id_t inEventID) |
| { |
| nl::Weave::Profiles::DataManagement::EventOptions options; |
| BoltActuatorEventStruct eventStruct; |
| static EventSchema schema = { |
| kBoltLockTraitID, |
| kBoltActuatorStateChangeEvent, |
| nl::Weave::Profiles::DataManagement::Production, |
| 1, |
| 1 |
| }; |
| |
| eventStruct.state = static_cast<int16_t>(inState); |
| eventStruct.actuatorState = static_cast<int16_t>(inActuatorState); |
| eventStruct.lockedState = static_cast<int16_t>(inLockedState); |
| eventStruct.blame = static_cast<int16_t>(inBlame); |
| eventStruct.user_id = inUserID; |
| |
| if (inEventID != 0) |
| { |
| options = EventOptions((uint32_t)0, NULL, inEventID, nl::Weave::Profiles::DataManagement::Production, false); |
| } |
| else |
| { |
| options = EventOptions(); |
| } |
| |
| |
| return nl::Weave::Profiles::DataManagement::LogEvent( |
| schema, |
| WriteBoltActuatorStateChangeEvent, |
| &eventStruct, |
| &options |
| ); |
| } |
| |
| /************************************************************************/ |
| |
| // open/close event. Interesting because it is the canonical example of Maldives. |
| const uint32_t kOpenCloseTraitID = 0x235A0208; |
| const uint32_t kOpenCloseEvent = 1; |
| |
| const uint64_t kOpenCloseState = nl::Weave::TLV::ContextTag(1); |
| |
| static WEAVE_ERROR WriteOpenCloseEvent(nl::Weave::TLV::TLVWriter & writer, uint8_t inDataTag, void * anAppState) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| nl::Weave::TLV::TLVType userDisabled; |
| int32_t * context = static_cast<int32_t *>(anAppState); |
| |
| VerifyOrExit(context != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| err = writer.StartContainer(ContextTag(nl::Weave::Profiles::DataManagement::kTag_EventData), nl::Weave::TLV::kTLVType_Structure, userDisabled); |
| SuccessOrExit(err); |
| |
| err = writer.Put(kOpenCloseState, *context); |
| SuccessOrExit(err); |
| |
| err = writer.EndContainer(userDisabled); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| event_id_t LogOpenClose(OpenCloseState inState) |
| { |
| static EventSchema schema = { |
| kOpenCloseTraitID, |
| kOpenCloseEvent, |
| nl::Weave::Profiles::DataManagement::Production, |
| 1, |
| 1 |
| }; |
| int32_t eventState = static_cast<int32_t>(inState); |
| |
| return nl::Weave::Profiles::DataManagement::LogEvent( |
| schema, |
| WriteOpenCloseEvent, |
| &eventState); |
| } |
| |
| /************************************************************************/ |
| // Event generators |
| |
| EventGenerator::EventGenerator(size_t aNumStates, size_t aInitialState) : |
| mNumStates(aNumStates), |
| mState(aInitialState) |
| { |
| } |
| |
| size_t EventGenerator::GetNumStates() |
| { |
| return mNumStates; |
| } |
| |
| // premiere selection of log lines from helloweave app |
| |
| static const char* gLogLines[] = |
| { |
| "Initializing weave platform", |
| "StartWeave Setting LocalNodeId: 18b4300001408362", |
| "Setting FabricId 93abf1086e41822", |
| "Init: configuration Settings = 00000009", |
| "RequestInvokeActions", |
| "Init NM Daemon", |
| "Watchdog ID = 1.", |
| "nlWirelessCalPlatformLoadFromSysEnv: Loading From Environment for 'nlwirelessregcal.em357'", |
| "setting application tag for task 0x20004148 ('NMGR') to 0x20009e20", |
| "Init NM Client", |
| "Waiting for events!", |
| "Init pair fail: -1355284483", |
| "setting application tag for task 0x20004194 ('VNCP') to 0x2000bc30", |
| "Enabling watchdog tracking. ID = 2", |
| "netif init", |
| "[TECHBASE] \"6LoWPAN\" (0x66f6ae45) persistently enabled.", |
| "[SILBS] SiLabs :: Probe - Starting 6lowpan status:0", |
| "ember reset with cause 6", |
| "CurrentNetwork id=NEST-PAN-1822, xPanId=B6096E5D00EBACD1, panId=be51, chan=19, nodeType=4, txPwr=-12, old status=0, new status=1, reason=0", |
| "emberInitReturn (status: 0)", |
| "[SILBS] HandleNetworkParametersChanged, status:1, name:NEST-PAN-1822, device role:4", |
| "[SILBS] UpdateCurrentService: Creating new service", |
| "[SVCBASE] NEST-PAN-1822: 1 (create) : 0 (unknown) -> 1 (idle)", |
| "[SVCCTLR] NEST-PAN-1822: 0 (unknown) -> 1 (idle)", |
| "[PROVCTLR] Non-partial Service \"NEST-PAN-1822\" (w/ Prov=0x1591d382) has score 3 against prov 0x1591d382.", |
| "[PROVCTLR] ProvisionAction on Service \"NEST-PAN-1822\" (w/ Prov=0x1591d382) has score 3 against prov 0x1591d382.", |
| "[PSKMIXIN] 0x2000a458: SetPSK set to (type:1, length16)", |
| "[PROVDRVRBASE] Svc NEST-PAN-1822 matches prov 0x1591d382. Request AutoConnect.", |
| "[SILBS] HandleSavedNetworkStatus: Resuming network", |
| "(wpan) Thread bin.mgmt.ver:3328, stack.ver:1.0.5.0, build.ver:536 (Jun 1 2016 14:36:21)", |
| "emberSetTxPowerModeReturn (status 0)", |
| "CurrentNetwork id=NEST-PAN-1822, xPanId=B6096E5D00EBACD1, panId=be51, chan=19, nodeType=4, txPwr=-12, old status=0, new status=1, reason=0", |
| "[SVCCTLR] RunAutoConnect: Start (1)", |
| "[SVCCTLR] RunAutoConnect: Start (2)", |
| "[SVCCTLR] RunAutoConnect: Start (3)", |
| "[SVCCTLR] AC svc found NEST-PAN-1822: state=idle flags=auto_conn ", |
| "[SVCCTLR] RunAutoConnect: 0,0", |
| "[SVCCTLR] Internally-initiated connection to \"NEST-PAN-1822\" (0xb505acd3)", |
| "[SVCCTLR] RunAutoConnect: Start (1)", |
| "[SVCCTLR] RunAutoConnect: Start (2)", |
| "[SVCCTLR] RunAutoConnect: Start (3)", |
| "[SVCCTLR] RunAutoConnect: Exit due to CanProxy", |
| "[SILBS] HandleNetworkParametersChanged, status:1, name:NEST-PAN-1822, device role:4", |
| "[SILBS] HandleSavedNetworkStatus: In the process of resuming already.", |
| "emberInitReturn (status: 0)", |
| "(wpan) Thread bin.mgmt.ver:3328, stack.ver:1.0.5.0, build.ver:536 (Jun 1 2016 14:36:21)", |
| "CurrentNetwork id=NEST-PAN-1822, xPanId=B6096E5D00EBACD1, panId=be51, chan=19, nodeType=4, txPwr=-12, old status=1, new status=5, reason=0", |
| "resume network return (status: 0)", |
| "[SILBS] Resume status:0", |
| "[SVCBASE] NEST-PAN-1822: 7 (connect) : 1 (idle) -> 2 (association)", |
| "[SVCCTLR] NEST-PAN-1822: 1 (idle) -> 2 (association)", |
| "[SILBS] Connect: Join network NEST-PAN-1822", |
| "[SILBS] HandleNetworkParametersChanged, status:5, name:NEST-PAN-1822, device role:4", |
| "CurrentNetwork id=NEST-PAN-1822, xPanId=B6096E5D00EBACD1, panId=be51, chan=19, nodeType=3, txPwr=-12, old status=5, new status=5, reason=0", |
| "[SILBS] HandleNetworkParametersChanged, status:5, name:NEST-PAN-1822, device role:3" |
| }; |
| |
| DebugEventGenerator::DebugEventGenerator() : |
| EventGenerator(sizeof(gLogLines) / sizeof(char*), 0), |
| mLogLines(gLogLines) |
| { |
| } |
| |
| void DebugEventGenerator::Generate(void) |
| { |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Production, mLogLines[mState]); |
| mState = (mState + 1) % mNumStates; |
| } |
| |
| LivenessEventGenerator::LivenessEventGenerator(void) : |
| EventGenerator(10, 0) |
| { |
| } |
| |
| void LivenessEventGenerator::Generate(void) |
| { |
| // Scenario: monitoring liveness for two devices -- self and remote. Remote device goes offline and returns. |
| switch (mState) |
| { |
| case 0: |
| LogLiveness(kTestNodeId, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| case 1: |
| LogLiveness(kTestNodeId1, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| case 2: |
| LogLiveness(kTestNodeId, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| case 3: |
| LogLiveness(kTestNodeId1, LIVENESS_DEVICE_STATUS_UNREACHABLE); |
| break; |
| |
| case 4: |
| LogLiveness(kTestNodeId, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| case 5: |
| LogLiveness(kTestNodeId1, LIVENESS_DEVICE_STATUS_REBOOTING); |
| break; |
| |
| case 6: |
| LogLiveness(kTestNodeId, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| case 7: |
| LogLiveness(kTestNodeId1, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| case 8: |
| LogLiveness(kTestNodeId, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| case 9: |
| LogLiveness(kTestNodeId1, LIVENESS_DEVICE_STATUS_ONLINE); |
| break; |
| |
| default: |
| mState = 0; |
| } |
| |
| mState = (mState + 1) % mNumStates; |
| } |
| |
| SecurityEventGenerator::SecurityEventGenerator(void) : |
| EventGenerator(14, 0), |
| mRelatedEvent(0) |
| { |
| } |
| |
| void SecurityEventGenerator::Generate(void) |
| { |
| // Scenario: debug logs are happening in the background. The user |
| // of the device enters a wrong pincode, corrects it subsequently, |
| // the bolt unlocks. The door opens, and closes soon |
| // thereafter. The user disables the pincode. Subsequently someone |
| // else attempts to activate the keypad. |
| switch (mState) |
| { |
| case 0: |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Keypad Activated"); |
| break; |
| |
| case 1: |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Wrong pincode: %-5d", 12345); |
| break; |
| |
| case 2: |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Keypad Activated"); |
| break; |
| |
| case 3: |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Correct pincode: %-5d", 55555); |
| break; |
| |
| case 4: |
| // valid credential, trigger the BoltStateChange |
| LogBoltStateChange(BOLT_STATE_EXTENDED, BOLT_ACTUATOR_STATE_UNLOCKING, BOLT_LOCKED_STATE_LOCKED, BOLT_BLAME_OUTSIDE_KEYPAD_PIN, kTestUserId, mRelatedEvent); |
| break; |
| |
| case 5: |
| LogBoltStateChange(BOLT_STATE_RETRACTED, BOLT_ACTUATOR_STATE_OK, BOLT_LOCKED_STATE_UNLOCKED, BOLT_BLAME_OUTSIDE_KEYPAD_PIN, kTestUserId, mRelatedEvent); |
| |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Successful unlock"); |
| break; |
| |
| case 6: |
| |
| break; |
| |
| case 7: |
| |
| break; |
| |
| case 8: |
| // lets lock the door manually (no known user ID) |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Manual locking from inside"); |
| LogBoltStateChange(BOLT_STATE_RETRACTED, BOLT_ACTUATOR_STATE_LOCKING, BOLT_LOCKED_STATE_UNLOCKED, BOLT_BLAME_INSIDE_MANUAL, 0ULL, 0); |
| break; |
| |
| case 9: |
| LogBoltStateChange(BOLT_STATE_EXTENDED, BOLT_ACTUATOR_STATE_OK, BOLT_LOCKED_STATE_LOCKED, BOLT_BLAME_INSIDE_MANUAL, 0ULL, 0); |
| break; |
| |
| case 10: |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Keypad Activated"); |
| break; |
| |
| case 11: |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Correct pincode: %-5d", 55555); |
| break; |
| |
| case 12: |
| // and disable the keypad |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Keypad disabled"); |
| break; |
| |
| case 13: |
| // and disable the keypad |
| nl::Weave::Profiles::DataManagement::LogFreeform(nl::Weave::Profiles::DataManagement::Debug, "Keypad disabled"); |
| break; |
| |
| default: |
| mState = 0; |
| } |
| |
| mState = (mState + 1) % mNumStates; |
| } |
| |
| |
| TelemetryEventGenerator::TelemetryEventGenerator(void) : |
| EventGenerator(8, 0) |
| { |
| } |
| |
| void TelemetryEventGenerator::Generate(void) |
| { |
| NetworkWiFiStatsEvent event; |
| NetworkWiFiDeauthEvent deauth; |
| NetworkWiFiInvalidKeyEvent invalidkey; |
| NetworkWiFiDHCPFailureEvent dhcpfail; |
| |
| event.bssid = 0x01de; |
| event.freq = 11; |
| event.rssi = -62; |
| event.bcnRecvd = 0; |
| event.bcnLost = 0; |
| event.pktMCastRX = 0; |
| event.pktUCastRX = 0; |
| event.currRXRate = 6; |
| event.currTXRate = 6; |
| event.sleepTimePercent = 70; |
| event.numOfAP = 1; |
| |
| // TelemetryEventGenerator generates WiFi telemetry events: |
| // StatsEvent, DeauthEvent, InvalidKeyEvent and DHCPFailureEvent in sequence. |
| // |
| // The first 5 events are StatsEvents with bcnRecvd/pktUcastRX/sleepTimePercent udpated |
| // The 6th event is DeauthEvent |
| // The 7th event is InvalidKeyEvent |
| // The 8th event is DHCPFailureEvent |
| |
| if (mState < 5) |
| { |
| event.bcnRecvd += mState; |
| event.pktUCastRX += mState; |
| event.sleepTimePercent += mState; |
| LogNetworkWiFiStatsEvent(&event, nl::Weave::Profiles::DataManagement::Production); |
| } |
| else if (mState == 5) |
| { |
| deauth.reason = -16; |
| LogNetworkWiFiDeauthEvent(&deauth, nl::Weave::Profiles::DataManagement::Production); |
| } |
| else if (mState == 6) |
| { |
| invalidkey.reason = -10; |
| LogNetworkWiFiInvalidKeyEvent(&invalidkey, nl::Weave::Profiles::DataManagement::Production); |
| } |
| else if (mState == 7) |
| { |
| dhcpfail.reason = -40; |
| LogNetworkWiFiDHCPFailureEvent(&dhcpfail, nl::Weave::Profiles::DataManagement::Production); |
| } |
| |
| mState = (mState + 1) % mNumStates; |
| } |
| |
| TestTraitEventGenerator::TestTraitEventGenerator(void) : |
| EventGenerator(3, 0) |
| { |
| mEvent = { 0 }; |
| mNullableEvent = { 0 }; |
| } |
| |
| void TestTraitEventGenerator::Generate(void) |
| { |
| static const char *kTestString = "teststring"; |
| switch (mState) |
| { |
| case 0: |
| // init state |
| mEvent.teA = 5; |
| mEvent.teB = -5; |
| mEvent.teC = true; |
| mEvent.teD = ENUM_E_VALUE_1; |
| mEvent.teE.seA = 200; |
| mEvent.teE.seB = true; |
| mEvent.teE.seC = TestCommonTrait::COMMON_ENUM_E_VALUE_2; |
| mEvent.teF = TestCommonTrait::COMMON_ENUM_E_VALUE_1; |
| mEvent.teG.seA = 200; |
| mEvent.teG.seB = true; |
| mEvent.teJ = -900; |
| |
| memset(&tek_buf[0], 0xAA, sizeof(tek_buf)); |
| mEvent.teK.mBuf = &tek_buf[0]; |
| mEvent.teK.mLen = sizeof(tek_buf); |
| |
| // day of week |
| mEvent.teL = DAY_OF_WEEK_SUNDAY; |
| |
| //implicit resource id |
| mEvent.teM = 0x18b4300000000001ULL; |
| |
| // explicit resource id |
| ten_resource_type = (ten_resource_type + 1) % 8; |
| { |
| uint8_t *tmp = &ten_buf[0]; |
| nl::Weave::Encoding::LittleEndian::Write16(tmp, ten_resource_type); |
| nl::Weave::Encoding::LittleEndian::Write64(tmp, mEvent.teM); |
| } |
| mEvent.teN.mBuf = &ten_buf[0]; |
| mEvent.teN.mLen = sizeof(ten_buf); |
| |
| // timestamp |
| mEvent.teO = 1493336639; |
| mEvent.teP = 1493336639000; |
| |
| // duration |
| mEvent.teQ = -1000; |
| mEvent.teR = 1000; |
| mEvent.teS = 20000; |
| |
| nl::LogEvent(&mEvent); |
| |
| mNullableEvent.neA = 300; |
| mNullableEvent.neB = -300; |
| mNullableEvent.neC = true; |
| mNullableEvent.neD = kTestString; |
| mNullableEvent.neI = kTestString; |
| mNullableEvent.neE = 600; |
| mNullableEvent.neJ.neA = 100; |
| mNullableEvent.neJ.neA = true; |
| |
| nl::LogEvent(&mNullableEvent); |
| break; |
| |
| case 1: |
| // day of week |
| mEvent.teL ^= DAY_OF_WEEK_FRIDAY; |
| nl::LogEvent(&mEvent); |
| break; |
| case 2: |
| // implicit resource id |
| ten_resource_type = (ten_resource_type + 1) % 8; |
| { |
| uint8_t *tmp = &ten_buf[0]; |
| nl::Weave::Encoding::LittleEndian::Write16(tmp, ten_resource_type); |
| nl::Weave::Encoding::LittleEndian::Write64(tmp, mEvent.teM); |
| } |
| mEvent.teN.mBuf = &ten_buf[0]; |
| mEvent.teN.mLen = sizeof(ten_buf); |
| |
| nl::LogEvent(&mEvent); |
| break; |
| case 3: |
| // timestamp/duration |
| // timestamp |
| mEvent.teO++; |
| mEvent.teP++; |
| |
| // duration |
| mEvent.teQ++; |
| mEvent.teR++; |
| mEvent.teS++; |
| |
| nl::LogEvent(&mEvent); |
| break; |
| case 4: |
| default: |
| // null |
| mEvent.SetTeJNull(); |
| mEvent.SetTeMNull(); |
| mEvent.SetTeNNull(); |
| mEvent.SetTePNull(); |
| mEvent.SetTeSNull(); |
| |
| nl::LogEvent(&mEvent); |
| |
| mNullableEvent.neJ.SetNeANull(); |
| |
| nl::LogEvent(&mNullableEvent); |
| |
| mEvent.SetTeJPresent(); |
| mEvent.SetTeMPresent(); |
| mEvent.SetTeNPresent(); |
| mEvent.SetTePPresent(); |
| mEvent.SetTeSPresent(); |
| |
| mNullableEvent.neJ.SetNeAPresent(); |
| mNullableEvent.SetNeJNull(); |
| |
| nl::LogEvent(&mNullableEvent); |
| break; |
| } |
| |
| mState = (mState + 1) % mNumStates; |
| } |
