mirror of https://github.com/nymea/nymea.git
935 lines
32 KiB
Python
Executable File
935 lines
32 KiB
Python
Executable File
#!/usr/bin/python
|
|
|
|
import telnetlib
|
|
import json
|
|
import datetime
|
|
|
|
HOST='localhost'
|
|
PORT=1234
|
|
commandId=0
|
|
|
|
methods = {'1': 'add_device',
|
|
'2': 'remove_device',
|
|
'3': 'list_configured_device_params',
|
|
'4': 'list_device_states',
|
|
'5': 'execute_action',
|
|
'6': 'add_rule',
|
|
'7': 'remove_rule',
|
|
'8': 'list_rule_detail',
|
|
'9': 'enable_disable_rule',
|
|
'10': 'list_vendors',
|
|
'11': 'list_configured_devices',
|
|
'12': 'list_deviceClasses',
|
|
'13': 'list_deviceClasses_by_vendor',
|
|
'14': 'list_rules',
|
|
'15': 'list_rules_containig_deviceId',
|
|
'16': 'list_logEntries'
|
|
}
|
|
|
|
|
|
def get_menu_selection():
|
|
print ""
|
|
print "----------------------------------------"
|
|
print "What do you want to do?"
|
|
print "----------------------------------------"
|
|
print ""
|
|
print "Devices --------------------------------"
|
|
print " 1 -> Add a new device"
|
|
print " 2 -> Remove a device"
|
|
print " 3 -> List device parameters"
|
|
print " 4 -> List device states"
|
|
print " 5 -> Execute an action"
|
|
print ""
|
|
print "Rules ----------------------------------"
|
|
print " 6 -> Add a new rule"
|
|
print " 7 -> Remove a rule"
|
|
print " 8 -> Rule details"
|
|
print " 9 -> Enable/Disable a rule"
|
|
print ""
|
|
print "Other ----------------------------------"
|
|
print " 10 -> List supported vendors"
|
|
print " 11 -> List configured devices"
|
|
print " 12 -> List supported devices"
|
|
print " 13 -> List supported devices by vendor"
|
|
print " 14 -> List configured rules"
|
|
print " 15 -> List rules containing a certain device"
|
|
print " 16 -> Print log"
|
|
print "----------------------------------------"
|
|
print ""
|
|
selection = raw_input("Enter selection: ")
|
|
n = 0
|
|
for i in methods.keys():
|
|
if i == selection:
|
|
return methods.values()[int(n)]
|
|
|
|
n= n+1
|
|
|
|
print "\nError in selection!"
|
|
return None
|
|
|
|
|
|
def get_selection(title, options):
|
|
print "\n\n", title
|
|
for i in range(0,len(options)):
|
|
print "%5i: %s" % (i, options[i])
|
|
|
|
selection = raw_input("Enter selection: ")
|
|
if not selection:
|
|
print "\n -> error in selection"
|
|
return None
|
|
|
|
return int(selection)
|
|
|
|
|
|
def send_command(method, params = None):
|
|
global commandId
|
|
commandObj = {}
|
|
commandObj['id'] = commandId
|
|
commandObj['method'] = method
|
|
if not params == None and len(params) > 0:
|
|
commandObj['params'] = params
|
|
|
|
command = json.dumps(commandObj) + '\n'
|
|
commandId = commandId + 1
|
|
tn.write(command)
|
|
response = json.loads(tn.read_until("\n}\n"))
|
|
if response['status'] != "success":
|
|
print "JSON error happened: %s" % response
|
|
return None
|
|
|
|
return response
|
|
|
|
|
|
def get_vendors():
|
|
return send_command("Devices.GetSupportedVendors")
|
|
|
|
|
|
def list_vendors():
|
|
response = get_vendors();
|
|
print "=== Vendors ==="
|
|
for vendor in response['params']['vendors']:
|
|
print "%40s %s" % (vendor['name'], vendor['id'])
|
|
|
|
print "=== Vendors ==="
|
|
|
|
|
|
def select_vendor():
|
|
vendors = get_vendors()['params']['vendors']
|
|
if not vendors:
|
|
print "\n No vendors found. Please install guh-plugins and restart guhd."
|
|
return None
|
|
|
|
vendorList = []
|
|
vendorIdList = []
|
|
for i in range(0,len(vendors)):
|
|
vendorList.append(vendors[i]['name'])
|
|
vendorIdList.append(vendors[i]['id'])
|
|
|
|
selection = get_selection("Please select vendor", vendorList)
|
|
if selection != None:
|
|
return vendorIdList[selection]
|
|
|
|
|
|
def get_deviceClasses(vendorId = None):
|
|
params = {};
|
|
if vendorId != None:
|
|
params['vendorId'] = vendorId
|
|
|
|
return send_command("Devices.GetSupportedDevices", params)['params']['deviceClasses']
|
|
|
|
def list_configured_device_params():
|
|
deviceId = select_configured_device()
|
|
device = get_device(deviceId)
|
|
deviceParams = device['params']
|
|
print "\nParams of the device with the id ", deviceId, "\n"
|
|
print "=== Params ==="
|
|
for i in range(len(deviceParams)):
|
|
print "%20s: %s" % (deviceParams[i]['name'], deviceParams[i]['value'])
|
|
|
|
print "=== Params ==="
|
|
|
|
|
|
def list_deviceClasses(vendorId = None):
|
|
response = get_deviceClasses(vendorId)
|
|
print "=== DeviceClasses ==="
|
|
for deviceClass in response:
|
|
print "%40s %s" % (deviceClass['name'], deviceClass['id'])
|
|
|
|
print "=== DeviceClasses ==="
|
|
|
|
|
|
def select_deviceClass():
|
|
vendorId = select_vendor()
|
|
deviceClasses = get_deviceClasses(vendorId)
|
|
if len(deviceClasses) == 0:
|
|
print " No supported devices for this vendor"
|
|
return None
|
|
|
|
deviceClassList = []
|
|
deviceClassIdList = []
|
|
for i in range(0,len(deviceClasses)):
|
|
deviceClassList.append(deviceClasses[i]['name'])
|
|
deviceClassIdList.append(deviceClasses[i]['id'])
|
|
|
|
selection = get_selection("Please select device class", deviceClassList)
|
|
if selection != None:
|
|
return deviceClassIdList[selection]
|
|
|
|
|
|
def select_configured_device():
|
|
devices = get_configured_devices()
|
|
deviceList = []
|
|
deviceIdList = []
|
|
for device in devices:
|
|
deviceList.append(device['name'])
|
|
deviceIdList.append(device['id'])
|
|
|
|
selection = get_selection("Please select a device: ", deviceList)
|
|
if selection != None:
|
|
return deviceIdList[selection]
|
|
|
|
return None
|
|
|
|
|
|
def get_action_types(deviceClassId):
|
|
params = {}
|
|
params['deviceClassId'] = deviceClassId
|
|
return send_command("Devices.GetActionTypes", params)['params']['actionTypes']
|
|
|
|
|
|
def get_eventTypes(deviceClassId):
|
|
params = {}
|
|
params['deviceClassId'] = deviceClassId
|
|
return send_command("Devices.GetEventTypes", params)['params']['eventTypes']
|
|
|
|
|
|
def list_deviceClasses_by_vendor():
|
|
vendorId = select_vendor()
|
|
list_deviceClasses(vendorId)
|
|
|
|
|
|
def get_configured_devices():
|
|
return send_command("Devices.GetConfiguredDevices")['params']['devices']
|
|
|
|
|
|
def list_configured_devices():
|
|
deviceList = get_configured_devices()
|
|
print "=== Configured Devices ==="
|
|
for device in deviceList:
|
|
print "Name: %40s, ID: %s, DeviceClassID: %s" % (device['name'], device['id'], device['deviceClassId'])
|
|
|
|
print "=== Configured Devices ==="
|
|
|
|
|
|
def read_params(paramTypes):
|
|
params = []
|
|
for paramType in paramTypes:
|
|
if any("allowedValues" in item for item in paramType):
|
|
selection = get_selection("Please select one of following allowed values:", paramType['allowedValues'])
|
|
paramValue = paramType['allowedValues'][selection]
|
|
param = {}
|
|
param['name'] = paramType['name']
|
|
param['value'] = paramValue
|
|
else:
|
|
paramValue = raw_input("Please enter value for parameter %s (type: %s): " % (paramType['name'], paramType['type']))
|
|
param = {}
|
|
param['name'] = paramType['name']
|
|
param['value'] = paramValue
|
|
|
|
params.append(param)
|
|
|
|
return params
|
|
|
|
|
|
def select_valueOperator():
|
|
valueOperators = ["ValueOperatorEquals", "ValueOperatorNotEquals", "ValueOperatorLess", "ValueOperatorGreater", "ValueOperatorLessOrEqual", "ValueOperatorGreaterOrEqual"]
|
|
selection = get_selection("Please select an operator to compare this parameter: ", valueOperators)
|
|
if selection != None:
|
|
return valueOperators[selection]
|
|
|
|
return None
|
|
|
|
|
|
def select_stateOperator():
|
|
stateOperators = ["StateOperatorAnd", "StateOperatorOr"]
|
|
selection = get_selection("Please select an operator to compare this state: ", stateOperators)
|
|
if selection != None:
|
|
return stateOperators[selection]
|
|
|
|
return None
|
|
|
|
|
|
def read_paramDescriptors(paramTypes):
|
|
params = []
|
|
for paramType in paramTypes:
|
|
paramValue = raw_input("Please enter value for parameter <%s> (type: %s): " % (paramType['name'], paramType['type']))
|
|
operator = select_valueOperator()
|
|
param = {}
|
|
param['name'] = paramType['name']
|
|
param['value'] = paramValue
|
|
param['operator'] = operator
|
|
params.append(param)
|
|
|
|
print "got params:", params
|
|
return params
|
|
|
|
|
|
def discover_device(deviceClassId = None):
|
|
if deviceClassId == None:
|
|
deviceClassId = select_deviceClass()
|
|
|
|
deviceClass = get_deviceClass(deviceClassId)
|
|
params = {}
|
|
params['deviceClassId'] = deviceClassId
|
|
discoveryParams = read_params(deviceClass['discoveryParamTypes'])
|
|
if len(discoveryParams) > 0:
|
|
params['discoveryParams'] = discoveryParams
|
|
|
|
print "\ndiscovering..."
|
|
response = send_command("Devices.GetDiscoveredDevices", params)
|
|
deviceDescriptorList = [];
|
|
deviceDescriptorIdList = [];
|
|
for deviceDescriptor in response['params']['deviceDescriptors']:
|
|
deviceDescriptorList.append("%s (%s)" % (deviceDescriptor['title'], deviceDescriptor['description']))
|
|
deviceDescriptorIdList.append(deviceDescriptor['id'])
|
|
|
|
if not deviceDescriptorIdList:
|
|
print "\n Timeout: no device found"
|
|
return None
|
|
|
|
selection = get_selection("Please select a device descriptor", deviceDescriptorList)
|
|
if selection != None:
|
|
return deviceDescriptorIdList[selection]
|
|
|
|
|
|
|
|
def get_deviceClass(deviceClassId):
|
|
deviceClasses = get_deviceClasses()
|
|
for deviceClass in deviceClasses:
|
|
if deviceClass['id'] == deviceClassId:
|
|
return deviceClass
|
|
|
|
return None
|
|
|
|
|
|
def get_device(deviceId):
|
|
devices = get_configured_devices()
|
|
for device in devices:
|
|
if device['id'] == deviceId:
|
|
return device
|
|
|
|
return None
|
|
|
|
|
|
def get_actionType(actionTypeId):
|
|
params = {}
|
|
params['actionTypeId'] = actionTypeId
|
|
response = send_command("Actions.GetActionType", params)
|
|
if "actionType" in response['params']:
|
|
return response['params']['actionType']
|
|
return None
|
|
|
|
|
|
def get_eventType(eventTypeId):
|
|
params = {}
|
|
params['eventTypeId'] = eventTypeId
|
|
response = send_command("Events.GetEventType", params)
|
|
return response['params']['eventType']
|
|
|
|
def add_configured_device(deviceClassId):
|
|
deviceClass = get_deviceClass(deviceClassId)
|
|
|
|
params = {}
|
|
params['deviceClassId'] = deviceClassId
|
|
|
|
deviceParams = read_params(deviceClass['paramTypes'])
|
|
if len(deviceParams) > 0:
|
|
params['deviceParams'] = deviceParams
|
|
|
|
print "add device command params:", params
|
|
response = send_command("Devices.AddConfiguredDevice", params)
|
|
print_device_error_code(response['params']['deviceError'])
|
|
|
|
|
|
def add_discovered_device(deviceClassId, deviceDescriptorId):
|
|
params = {}
|
|
params['deviceClassId'] = deviceClassId
|
|
params['deviceDescriptorId'] = deviceDescriptorId
|
|
|
|
deviceClass = get_deviceClass(deviceClassId)
|
|
if deviceClass['setupMethod'] == "SetupMethodJustAdd":
|
|
response = send_command("Devices.AddConfiguredDevice", params)
|
|
if not response['status'] == "success":
|
|
print "Adding device failed: %s" % response['params']['deviceError']
|
|
else:
|
|
print "Device added successfully. Device ID: %s" % response['params']['deviceId']
|
|
else:
|
|
params = {}
|
|
params['deviceClassId'] = deviceClassId
|
|
params['deviceDescriptorId'] = deviceDescriptorId
|
|
response = send_command("Devices.PairDevice", params)
|
|
print "pairdevice response:", response
|
|
if not response['status'] == "success":
|
|
print "Pairing failed: %s", response['params']['deviceError']
|
|
return
|
|
else:
|
|
print "\nPairing device %s\n\n%s" % (deviceClass['name'], response['params']['displayMessage'])
|
|
if response['params']['setupMethod'] == "SetupMethodPushButton":
|
|
raw_input("Press enter to confirm")
|
|
|
|
params = {}
|
|
params['pairingTransactionId'] = response['params']['pairingTransactionId']
|
|
response = send_command("Devices.ConfirmPairing", params)
|
|
if response['status'] == "success":
|
|
print "Device paired successfully"
|
|
else:
|
|
print "Error pairing device: %s" % response['params']['deviceError']
|
|
|
|
|
|
def add_device():
|
|
deviceClassId = select_deviceClass()
|
|
if deviceClassId == "":
|
|
print " Empty deviceClass. Can't continue"
|
|
return
|
|
|
|
deviceClass = get_deviceClass(deviceClassId)
|
|
print "createmethods are", deviceClass['createMethods']
|
|
if "CreateMethodUser" in deviceClass['createMethods']:
|
|
add_configured_device(deviceClassId)
|
|
elif "CreateMethodDiscovery" in deviceClass['createMethods']:
|
|
deviceDescriptorId = discover_device(deviceClassId)
|
|
if deviceDescriptorId == None:
|
|
return
|
|
|
|
add_discovered_device(deviceClassId, deviceDescriptorId)
|
|
elif "CreateMethodAuto" in deviceClass['createMethods']:
|
|
print "Can't create this device manually. It'll be created automatically when hardware is discovered."
|
|
|
|
|
|
def select_device():
|
|
devices = get_configured_devices()
|
|
deviceList = []
|
|
deviceIdList = []
|
|
for i in range(len(devices)):
|
|
deviceList.append(devices[i]['name'])
|
|
deviceIdList.append(devices[i]['id'])
|
|
|
|
selection = get_selection("Please select a device", deviceList)
|
|
if selection != None:
|
|
return deviceIdList[selection]
|
|
|
|
|
|
def remove_device():
|
|
deviceId = select_device()
|
|
print "should remove device", deviceId
|
|
params = {}
|
|
params['deviceId'] = deviceId
|
|
response = send_command("Devices.RemoveConfiguredDevice", params)
|
|
print_device_error_code(response['params']['deviceError'])
|
|
|
|
|
|
def select_actionType(deviceClassId):
|
|
actions = get_action_types(deviceClassId)
|
|
if not actions:
|
|
return None
|
|
|
|
actionList = []
|
|
print "got actions", actions
|
|
for i in range(len(actions)):
|
|
print "got actiontype", actions[i]
|
|
actionList.append(actions[i]['name'])
|
|
|
|
selection = get_selection("Please select an action type:", actionList)
|
|
return actions[selection]
|
|
|
|
|
|
def select_eventType(deviceClassId):
|
|
eventTypes = get_eventTypes(deviceClassId)
|
|
if not eventTypes:
|
|
return None
|
|
|
|
eventTypeList = []
|
|
for i in range(len(eventTypes)):
|
|
eventTypeList.append(eventTypes[i]['name'])
|
|
|
|
selection = get_selection("Please select an event type:", eventTypeList)
|
|
return eventTypes[selection]
|
|
|
|
|
|
def execute_action():
|
|
deviceId = select_device()
|
|
device = get_device(deviceId)
|
|
actionType = select_actionType(device['deviceClassId'])
|
|
if actionType == "":
|
|
print "\n This device has no actions"
|
|
return
|
|
|
|
actionTypeId = actionType['id']
|
|
params = {}
|
|
params['actionTypeId'] = actionTypeId
|
|
params['deviceId'] = deviceId
|
|
actionType = get_actionType(actionTypeId)
|
|
actionParams = read_params(actionType['paramTypes'])
|
|
params['params'] = actionParams
|
|
response = send_command("Actions.ExecuteAction", params)
|
|
print_device_error_code(response['params']['deviceError'])
|
|
|
|
|
|
def print_device_error_code(deviceError):
|
|
if deviceError == "DeviceErrorNoError":
|
|
print "\nSuccess! (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorPluginNotFound":
|
|
print "\nERROR: the plugin could not be found. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorDeviceNotFound":
|
|
print "\nERROR: the device could not be found. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorDeviceClassNotFound":
|
|
print "\nERROR: the deviceClass could not be found. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorActionTypeNotFound":
|
|
print "\nERROR: the actionType could not be found. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorStateTypeNotFound":
|
|
print "\nERROR: the stateType could not be found. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorEventTypeNotFound":
|
|
print "\nERROR: the eventType could not be found. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorDeviceDescriptorNotFound":
|
|
print "\nERROR: the deviceDescriptor could not be found. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorMissingParameter":
|
|
print "\nERROR: some parameters are missing. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorInvalidParameter":
|
|
print "\nERROR: invalid parameter. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorSetupFailed":
|
|
print "\nERROR: setup failed. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorDuplicateUuid":
|
|
print "\nERROR: uuid allready exists. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorCreationMethodNotSupported":
|
|
print "\nERROR: the selected CreationMethod is not supported for this device. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorSetupMethodNotSupported":
|
|
print "\nERROR: the selected SetupMethod is not supported for this device. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorHardwareNotAvailable":
|
|
print "\nERROR: the hardware is not available. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorHardwareFailure":
|
|
print "\nERROR: hardware failure. Something went wrong with the hardware. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorAsync":
|
|
print "\nINFO: the response will need some time. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorDeviceInUse":
|
|
print "\nERROR: the device is currently in use. Try again later. (", deviceError, ")"
|
|
elif deviceError == "DeviceErrorPairingTransactionIdNotFound":
|
|
print "\nERROR: the pairingTransactionId could not be found. (", deviceError, ")"
|
|
else:
|
|
print "\nERROR: Unknown error code: ", deviceError, "Please take a look at the newest API version."
|
|
|
|
|
|
def print_rule_error_code(ruleError):
|
|
if ruleError == "RuleErrorNoError":
|
|
print "\nSuccess! (", ruleError, ")"
|
|
elif ruleError == "RuleErrorInvalidRuleId":
|
|
print "\nERROR: the ruleId is not valid. (", ruleError, ")"
|
|
elif ruleError == "RuleErrorRuleNotFound":
|
|
print "\nERROR: the rule could not be found. (", ruleError, ")"
|
|
elif ruleError == "RuleErrorDeviceNotFound":
|
|
print "\nERROR: the device could not be found for this rule. (", ruleError, ")"
|
|
elif ruleError == "RuleErrorEventTypeNotFound":
|
|
print "\nERROR: the eventType could not be found for this rule. (", ruleError, ")"
|
|
elif ruleError == "RuleErrorActionTypeNotFound":
|
|
print "\nERROR: the actionType could not be found for this rule. (", ruleError, ")"
|
|
elif ruleError == "RuleErrorInvalidParameter":
|
|
print "\nERROR: invalid parameter in this rule. (", ruleError, ")"
|
|
elif ruleError == "RuleErrorMissingParameter":
|
|
print "\nERROR: missing parameter in this rule. (", ruleError, ")"
|
|
else:
|
|
print "\nERROR: Unknown error code: ", ruleError, "Please take a look at the newest API version."
|
|
|
|
|
|
def list_device_states():
|
|
deviceId = select_device()
|
|
device = get_device(deviceId)
|
|
deviceClass = get_deviceClass(device['deviceClassId'])
|
|
print "\n\n=== States for device %s (%s) ===" % (device['name'], deviceId)
|
|
for i in range(len(deviceClass['stateTypes'])):
|
|
params = {}
|
|
params['deviceId'] = deviceId
|
|
params['stateTypeId'] = deviceClass['stateTypes'][i]['id']
|
|
response = send_command("Devices.GetStateValue", params)
|
|
print "%s: %s" % (deviceClass['stateTypes'][i]['name'], response['params']['value'])
|
|
|
|
print "=== States ==="
|
|
|
|
|
|
def create_eventDescriptors():
|
|
enough = False
|
|
eventDescriptors = []
|
|
while not enough:
|
|
print "\nCreating EventDescriptor:"
|
|
deviceId = select_configured_device()
|
|
device = get_device(deviceId)
|
|
eventType = select_eventType(device['deviceClassId']);
|
|
params = read_paramDescriptors(eventType['paramTypes'])
|
|
eventDescriptor = {}
|
|
eventDescriptor['deviceId'] = deviceId
|
|
eventDescriptor['eventTypeId'] = eventType['id']
|
|
if len(params) > 0:
|
|
eventDescriptor['paramDescriptors'] = params
|
|
|
|
eventDescriptors.append(eventDescriptor)
|
|
input = raw_input("Do you want to add another EventDescriptor? (y/N): ")
|
|
if not input == "y":
|
|
enough = True
|
|
|
|
print "got eventDescriptors:", eventDescriptors
|
|
return eventDescriptors
|
|
|
|
|
|
def create_eventDescriptor():
|
|
print "\nCreating EventDescriptor:"
|
|
deviceId = select_configured_device()
|
|
device = get_device(deviceId)
|
|
eventType = select_eventType(device['deviceClassId']);
|
|
params = read_paramDescriptors(eventType['paramTypes'])
|
|
eventDescriptor = {}
|
|
eventDescriptor['deviceId'] = deviceId
|
|
eventDescriptor['eventTypeId'] = eventType['id']
|
|
if len(params) > 0:
|
|
eventDescriptor['paramDescriptors'] = params
|
|
|
|
print "got eventDescriptors:", eventDescriptor
|
|
return eventDescriptor
|
|
|
|
|
|
def create_actions():
|
|
enough = False
|
|
actions = []
|
|
while not enough:
|
|
print "\nCreating Action:"
|
|
deviceId = select_configured_device()
|
|
device = get_device(deviceId)
|
|
actionType = select_actionType(device['deviceClassId'])
|
|
params = read_params(actionType['paramTypes'])
|
|
action = {}
|
|
action['deviceId'] = deviceId
|
|
action['actionTypeId'] = actionType['id']
|
|
if len(params) > 0:
|
|
action['params'] = params
|
|
|
|
actions.append(action)
|
|
input = raw_input("Do you want to add another action? (y/N): ")
|
|
if not input == "y":
|
|
enough = True
|
|
|
|
return actions
|
|
|
|
|
|
def add_rule():
|
|
params = {}
|
|
params['eventDescriptorList'] = create_eventDescriptors()
|
|
if len(params['eventDescriptorList']) > 1:
|
|
params['stateEvaluator'] = select_stateOperator()
|
|
|
|
params['actions'] = create_actions()
|
|
print "adding rule with params:", params
|
|
response = send_command("Rules.AddRule", params)
|
|
print_rule_error_code(response['params']['ruleError'])
|
|
|
|
|
|
def enable_disable_rule():
|
|
ruleId = select_rule()
|
|
if ruleId == "":
|
|
print "\n No rules found"
|
|
return
|
|
|
|
actionTypes = ["enable", "disable"]
|
|
selection = get_selection("What do you want to do with this rule: ", actionTypes)
|
|
if selection == 0:
|
|
params = {}
|
|
params['ruleId'] = ruleId
|
|
response = send_command("Rules.EnableRule", params)
|
|
print_rule_error_code(response['params']['ruleError'])
|
|
else:
|
|
params = {}
|
|
params['ruleId'] = ruleId
|
|
response = send_command("Rules.DisableRule", params)
|
|
print_rule_error_code(response['params']['ruleError'])
|
|
|
|
|
|
def get_rule_status(ruleId):
|
|
params = {}
|
|
params['ruleId'] = ruleId
|
|
response = send_command("Rules.GetRuleDetails", params)
|
|
if response['params']['rule']['enabled'] == True:
|
|
return "enabled"
|
|
else:
|
|
return "disabled"
|
|
|
|
def list_rules():
|
|
response = send_command("Rules.GetRules", {})
|
|
if not response['params']['ruleIds']:
|
|
print "\n No rules found."
|
|
return None
|
|
|
|
print "\nRules found:"
|
|
for i in range(len(response['params']['ruleIds'])):
|
|
ruleId = response['params']['ruleIds'][i]
|
|
params = {}
|
|
params['ruleId'] = ruleId
|
|
ruleDetail = send_command("Rules.GetRuleDetails", params)
|
|
#print ruleDetail
|
|
print response['params']['ruleIds'][i], "(", get_rule_status(ruleId), ")"
|
|
|
|
|
|
def get_rule_detail(ruleId):
|
|
params = {}
|
|
params['ruleId'] = ruleId
|
|
response = send_command("Rules.GetRuleDetails", params)
|
|
if 'rule' in response['params']:
|
|
return response['params']['rule']
|
|
return None
|
|
|
|
def list_rule_detail():
|
|
ruleId = select_rule()
|
|
if ruleId == "":
|
|
print "\n No rules found"
|
|
return None
|
|
|
|
rule = get_rule_detail(ruleId)
|
|
print "\nDetails for rule", ruleId, "which currently is", get_rule_status(ruleId)
|
|
print "\nEvents ->", get_stateEvaluator_text(rule['stateEvaluator']['operator']), ":"
|
|
for i in range(len(rule['eventDescriptors'])):
|
|
eventDescriptor = rule['eventDescriptors'][i]
|
|
device = get_device(eventDescriptor['deviceId'])
|
|
eventType = get_eventType(eventDescriptor['eventTypeId'])
|
|
paramDescriptors = eventDescriptor['paramDescriptors']
|
|
print "%5s. -> %40s -> eventTypeId: %10s: " %(i, device['name'], eventType['name'])
|
|
for i in range(len(paramDescriptors)):
|
|
print "%58s %s %s" %(paramDescriptors[i]['name'], get_valueOperator_symbol(paramDescriptors[i]['operator']), paramDescriptors[i]['value'])
|
|
|
|
print "\nActions:"
|
|
for i in range(len(rule['actions'])):
|
|
action = rule['actions'][i]
|
|
device = get_device(action['deviceId'])
|
|
actionType = get_actionType(rule['actions'][i]['actionTypeId'])
|
|
actionParams = rule['actions'][i]['params']
|
|
print "%5s. -> %40s -> action: %s" %(i, device['name'], actionType['name'])
|
|
for i in range(len(actionParams)):
|
|
print "%61s: %s" %(actionParams[i]['name'], actionParams[i]['value'])
|
|
|
|
|
|
def get_valueOperator_symbol(valueOperator):
|
|
if valueOperator == "ValueOperatorEquals":
|
|
return "="
|
|
elif valueOperator == "ValueOperatorNotEquals":
|
|
return "!="
|
|
elif valueOperator == "ValueOperatorLess":
|
|
return "<"
|
|
elif valueOperator == "ValueOperatorGreater":
|
|
return ">"
|
|
elif valueOperator == "ValueOperatorLessOrEqual":
|
|
return "<="
|
|
elif valueOperator == "ValueOperatorGreaterOrEqual":
|
|
return ">="
|
|
else:
|
|
return "<unknown value operator>"
|
|
|
|
def get_stateEvaluator_text(stateEvaluator):
|
|
if stateEvaluator == "StateOperatorAnd":
|
|
return "(AND) | ALL of the events/states has to be true/emited."
|
|
elif stateEvaluator == "StateOperatorOr":
|
|
return "(OR) | ONE of the events/states has to be true/emited."
|
|
else:
|
|
return "<unknown state evaluator>"
|
|
|
|
|
|
def list_rules_containig_deviceId():
|
|
deviceId = select_configured_device()
|
|
device = get_device(deviceId)
|
|
params = {}
|
|
params['deviceId'] = deviceId
|
|
response = send_command("Rules.FindRules", params)
|
|
if not response['params']['ruleIds']:
|
|
print "\nThere is no rule containig this device."
|
|
return None
|
|
|
|
print "\nFollowing rules contain this device"
|
|
for i in range(len(response['params']['ruleIds'])):
|
|
print "Device ", deviceId, "found in rule", response['params']['ruleIds'][i]
|
|
|
|
|
|
def select_rule():
|
|
ruleIds = send_command("Rules.GetRules", {})['params']['ruleIds']
|
|
if not ruleIds:
|
|
return None
|
|
|
|
selection = get_selection("Please select rule:", ruleIds)
|
|
if selection != None:
|
|
return ruleIds[selection]
|
|
|
|
|
|
def remove_rule():
|
|
ruleId = select_rule()
|
|
if ruleId == "":
|
|
print "\nNo rule found"
|
|
return None
|
|
|
|
params = {}
|
|
params['ruleId'] = ruleId
|
|
response = send_command("Rules.RemoveRule", params)
|
|
print "removeRule response", response
|
|
|
|
def get_stateType(stateTypeId):
|
|
params = {}
|
|
params['stateTypeId'] = stateTypeId
|
|
response = send_command("States.GetStateType", params);
|
|
if "stateType" in response['params']:
|
|
return response['params']['stateType']
|
|
return None
|
|
|
|
def list_logEntries():
|
|
params = {}
|
|
response = send_command("Logging.GetLogEntries", params)
|
|
stateTypeIdCache = {}
|
|
actionTypeIdCache = {}
|
|
eventTypeIdCache = {}
|
|
deviceIdCache = {}
|
|
ruleIdCache = {}
|
|
for i in range(len(response['params']['logEntries'])):
|
|
entry = response['params']['logEntries'][i]
|
|
|
|
if entry['loggingLevel'] == "LoggingLevelInfo":
|
|
levelString = "(I)"
|
|
error = ""
|
|
else:
|
|
levelString = "(A)"
|
|
error = entry['errorCode']
|
|
|
|
if entry['source'] == "LoggingSourceSystem":
|
|
deviceName = "Guh Server"
|
|
sourceType = "System Event"
|
|
symbolString = "->"
|
|
sourceName = "Active changed"
|
|
if entry['active'] == True:
|
|
value = "active"
|
|
else:
|
|
value = "inactive"
|
|
|
|
if entry['source'] == "LoggingSourceStates":
|
|
typeId = entry['typeId']
|
|
sourceType = "State Changed"
|
|
symbolString = "->"
|
|
if typeId in stateTypeIdCache:
|
|
sourceName = stateTypeIdCache[typeId]
|
|
else:
|
|
stateType = get_stateType(typeId)
|
|
if stateType is not None:
|
|
sourceName = stateType["name"]
|
|
stateTypeIdCache[typeId] = sourceName
|
|
else:
|
|
sourceName = typeId
|
|
value = entry['value']
|
|
if entry['deviceId'] in deviceIdCache:
|
|
deviceName = deviceIdCache[entry['deviceId']]
|
|
else:
|
|
device = get_device(entry['deviceId'])
|
|
if device is not None:
|
|
deviceName = device['name']
|
|
else:
|
|
deviceName = entry['deviceId']
|
|
deviceIdCache[entry['deviceId']] = deviceName
|
|
|
|
|
|
if entry['source'] == "LoggingSourceActions":
|
|
typeId = entry['typeId']
|
|
sourceType = "Action executed"
|
|
symbolString = "()"
|
|
if typeId in actionTypeIdCache:
|
|
sourceName = actionTypeIdCache[typeId]
|
|
else:
|
|
actionType = get_actionType(typeId)
|
|
if actionType is not None:
|
|
sourceName = actionType['name']
|
|
else:
|
|
sourceName = typeId
|
|
actionTypeIdCache[typeId] = sourceName
|
|
value = entry['value']
|
|
if entry['deviceId'] in deviceIdCache:
|
|
deviceName = deviceIdCache[entry['deviceId']]
|
|
else:
|
|
device = get_device(entry['deviceId'])
|
|
if device is not None:
|
|
deviceName = device['name']
|
|
else:
|
|
deviceName = entry['deviceId']
|
|
deviceIdCache[entry['deviceId']] = deviceName
|
|
|
|
if entry['source'] == "LoggingSourceEvents":
|
|
typeId = entry['typeId']
|
|
sourceType = "Event triggered"
|
|
symbolString = "()"
|
|
if typeId in eventTypeIdCache:
|
|
sourceName = eventTypeIdCache[typeId]
|
|
else:
|
|
eventType = get_eventType(typeId)
|
|
sourceName = eventType['name']
|
|
eventTypeIdCache[typeId] = sourceName
|
|
value = entry['value']
|
|
if entry['deviceId'] in deviceIdCache:
|
|
deviceName = deviceIdCache[entry['deviceId']]
|
|
else:
|
|
device = get_device(entry['deviceId'])
|
|
if device is not None:
|
|
deviceName = device['name']
|
|
else:
|
|
deviceName = entry['deviceId']
|
|
deviceIdCache[entry['deviceId']] = deviceName
|
|
|
|
|
|
if entry['source'] == "LoggingSourceRules":
|
|
typeId = entry['typeId']
|
|
if entry['eventType'] == "LoggingEventTypeTrigger":
|
|
sourceType = "Rule triggered"
|
|
sourceName = "triggered"
|
|
symbolString = "()"
|
|
value = ""
|
|
else:
|
|
sourceType = "Rule active changed"
|
|
symbolString = "()"
|
|
sourceName = "active"
|
|
if entry['active']:
|
|
value = "active"
|
|
else:
|
|
value = "inactive"
|
|
|
|
if typeId in ruleIdCache:
|
|
deviceName = ruleIdCache[typeId]
|
|
else:
|
|
rule = get_rule_detail(typeId)
|
|
if rule is not None and 'name' in rule:
|
|
deviceName = rule['name']
|
|
else:
|
|
deviceName = typeId
|
|
ruleIdCache[typeId] = deviceName
|
|
|
|
timestamp = datetime.datetime.fromtimestamp(entry['timestamp']/1000)
|
|
sourceType = sourceType.ljust(20)
|
|
deviceName = deviceName.ljust(38)
|
|
sourceName = sourceName.ljust(38)
|
|
value = value.ljust(30)
|
|
print levelString, timestamp, ":", sourceType, ":", deviceName, ":", sourceName, symbolString, value, ":", error
|
|
|
|
############################################################################################
|
|
import sys
|
|
|
|
if len(sys.argv) > 1:
|
|
HOST=sys.argv[1]
|
|
|
|
tn = telnetlib.Telnet(HOST, PORT)
|
|
packet = tn.read_until("\n}\n")
|
|
|
|
packet = json.loads(packet)
|
|
print "connected to", packet["server"], "\nserver version:", packet["version"], "\nprotocol version:", packet["protocol version"], "\n"
|
|
|
|
while True:
|
|
method = get_menu_selection()
|
|
if method != None:
|
|
#print "call method: ", method
|
|
methodCall = globals()[method]
|
|
methodCall()
|
|
|
|
|