mirror of https://github.com/nymea/nymea.git
delete unused files
Simon Stürz
Michael Zanetti
parent
aa3efd5726
commit
5042bb7460
|
|
@ -1,94 +0,0 @@
|
|||
#!/bin/sh
|
||||
CODE_DIR=guh
|
||||
BUILD_DIR=builddir
|
||||
USER=root
|
||||
USER_ID=0
|
||||
PASSWORD=hive
|
||||
BINARY=guh
|
||||
TARGET_IP=${TARGET_IP-10.10.10.108}
|
||||
TARGET_SSH_PORT=22
|
||||
TARGET_DEBUG_PORT=3768
|
||||
RUN_OPTIONS=-qmljsdebugger=port:$TARGET_DEBUG_PORT
|
||||
SETUP=false
|
||||
GDB=false
|
||||
SUDO="echo $PASSWORD | sudo -S"
|
||||
NUM_JOBS='$(( `grep -c ^processor /proc/cpuinfo` + 1 ))'
|
||||
FLIPPED=false
|
||||
|
||||
usage() {
|
||||
echo "usage: run_on_device [OPTIONS]\n"
|
||||
echo "Script to setup a build environment and sync build and run $BINARY on the device\n"
|
||||
echo "OPTIONS:"
|
||||
echo " -s, --setup Setup the build environment"
|
||||
echo ""
|
||||
echo "IMPORTANT:"
|
||||
echo " * Make sure to have networking setup on the device beforehand."
|
||||
echo " * Execute that script from a directory containing $PACKAGE code."
|
||||
exit 1
|
||||
}
|
||||
|
||||
exec_with_ssh() {
|
||||
ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -t $USER@$TARGET_IP -p $TARGET_SSH_PORT sudo -u $USER -i bash -ic \"$@\"
|
||||
}
|
||||
|
||||
install_ssh_key() {
|
||||
ssh-keygen -R $TARGET_IP
|
||||
ssh-copy-id $USER@$TARGET_IP
|
||||
}
|
||||
|
||||
install_dependencies() {
|
||||
exec_with_ssh $SUDO apt-get -y install build-essential gcc-4.7 g++-4.7 ccache gdb openssh
|
||||
echo "** Switching system to gcc 4.7 ***"
|
||||
exec_with_ssh update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.7 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.7
|
||||
}
|
||||
|
||||
sync_code() {
|
||||
WORK_DIR=`pwd`
|
||||
[ -e .bzr ] && bzr export --uncommitted --format=dir /tmp/$CODE_DIR
|
||||
[ -e .git ] && cd /tmp && cp -r $WORK_DIR $CODE_DIR && cd $CODE_DIR && git clean -f -x && rm .git -rf && cd -
|
||||
rsync -crlOzv --delete --exclude builddir -e "ssh -p $TARGET_SSH_PORT -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" /tmp/$CODE_DIR/ $USER@$TARGET_IP:$CODE_DIR/
|
||||
rm -rf /tmp/$CODE_DIR
|
||||
}
|
||||
|
||||
build() {
|
||||
exec_with_ssh mkdir -p $CODE_DIR/$BUILD_DIR
|
||||
exec_with_ssh PATH="/usr/lib/ccache:$PATH" ccache -s
|
||||
exec_with_ssh QT_SELECT=qt5 PATH=/usr/local/qt5/bin:/usr/lib/ccache:$PATH "cd $CODE_DIR/$BUILD_DIR && PATH=/usr/local/qt5/bin:/usr/lib/ccache:$PATH CC='ccache gcc' qmake .. CONFIG+=boblight"
|
||||
exec_with_ssh PATH=/usr/lib/ccache:$PATH "cd $CODE_DIR/$BUILD_DIR && PATH=/usr/lib/ccache:$PATH make -j2"
|
||||
}
|
||||
|
||||
run() {
|
||||
exec_with_ssh "LD_LIBRARY_PATH=$CODE_DIR/$BUILD_DIR/libguh $CODE_DIR/$BUILD_DIR/server/$BINARY"
|
||||
}
|
||||
|
||||
set -- `getopt -n$0 -u -a --longoptions="setup,gdbhelp" "sgh" "$@"`
|
||||
|
||||
# FIXME: giving incorrect arguments does not call usage and exit
|
||||
while [ $# -gt 0 ]
|
||||
do
|
||||
case "$1" in
|
||||
-s|--setup) SETUP=true;;
|
||||
-g|--gdb) GDB=true;;
|
||||
-h|--help) usage;;
|
||||
--) shift;break;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
|
||||
|
||||
if $SETUP; then
|
||||
echo "Setting up environment for building $PACKAGE..."
|
||||
install_ssh_key
|
||||
install_dependencies
|
||||
sync_code
|
||||
else
|
||||
echo "Transferring code.."
|
||||
sync_code
|
||||
|
||||
export PATH="/usr/local/qt5/:$PATH"
|
||||
|
||||
echo "Building.."
|
||||
build
|
||||
echo "Running.."
|
||||
run
|
||||
fi
|
||||
|
|
@ -1,934 +0,0 @@
|
|||
#!/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()
|
||||
|
||||
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
#!/bin/sh
|
||||
CODE_DIR=guh
|
||||
BUILD_DIR=builddir-rpi
|
||||
USER=root
|
||||
USER_ID=0
|
||||
PASSWORD=guh
|
||||
BINARY=guh
|
||||
TARGET_IP=${TARGET_IP-10.10.10.108}
|
||||
TARGET_SSH_PORT=22
|
||||
TARGET_DEBUG_PORT=3768
|
||||
RUN_OPTIONS=-qmljsdebugger=port:$TARGET_DEBUG_PORT
|
||||
SETUP=false
|
||||
GDB=false
|
||||
SUDO="echo $PASSWORD | sudo -S"
|
||||
NUM_JOBS='$(( `grep -c ^processor /proc/cpuinfo` + 1 ))'
|
||||
FLIPPED=false
|
||||
|
||||
usage() {
|
||||
echo "usage: run_on_device [OPTIONS]\n"
|
||||
echo "Script to setup a build environment and sync build and run $BINARY on the device\n"
|
||||
echo "OPTIONS:"
|
||||
echo " -s, --setup Setup the build environment"
|
||||
echo ""
|
||||
echo "IMPORTANT:"
|
||||
echo " * Make sure to have networking setup on the device beforehand."
|
||||
echo " * Execute that script from a directory containing $PACKAGE code."
|
||||
exit 1
|
||||
}
|
||||
|
||||
exec_with_ssh() {
|
||||
ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -t $USER@$TARGET_IP -p $TARGET_SSH_PORT sudo -u $USER -i bash -ic \"$@\"
|
||||
}
|
||||
|
||||
install_ssh_key() {
|
||||
ssh-keygen -R $TARGET_IP
|
||||
ssh-copy-id $USER@$TARGET_IP
|
||||
}
|
||||
|
||||
install_dependencies() {
|
||||
exec_with_ssh $SUDO apt-get -y install build-essential gcc-4.7 g++-4.7 ccache gdb
|
||||
echo "** Switching system to gcc 4.7 ***"
|
||||
exec_with_ssh update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.7 40 --slave /usr/bin/g++ g++ /usr/bin/g++-4.7
|
||||
}
|
||||
|
||||
build() {
|
||||
mkdir -p $BUILD_DIR
|
||||
cd $BUILD_DIR
|
||||
/usr/local/qt5pi/bin/qmake .. CONFIG+=boblight CONFIG+=xcompile
|
||||
make -j9
|
||||
cd ..
|
||||
}
|
||||
|
||||
sync_build() {
|
||||
rsync -rl $BUILD_DIR/ $USER@$TARGET_IP:/root/$BUILD_DIR/
|
||||
}
|
||||
|
||||
run() {
|
||||
exec_with_ssh "LD_LIBRARY_PATH=/root/$BUILD_DIR/libguh /root/$BUILD_DIR/server/$BINARY"
|
||||
}
|
||||
|
||||
set -- `getopt -n$0 -u -a --longoptions="setup,gdbhelp" "sgh" "$@"`
|
||||
|
||||
# FIXME: giving incorrect arguments does not call usage and exit
|
||||
while [ $# -gt 0 ]
|
||||
do
|
||||
case "$1" in
|
||||
-s|--setup) SETUP=true;;
|
||||
-g|--gdb) GDB=true;;
|
||||
-h|--help) usage;;
|
||||
--) shift;break;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
|
||||
|
||||
if $SETUP; then
|
||||
echo "Setting up environment for building $PACKAGE..."
|
||||
install_ssh_key
|
||||
install_dependencies
|
||||
sync_code
|
||||
else
|
||||
echo "Building.."
|
||||
build
|
||||
echo "Syncing build..."
|
||||
sync_build
|
||||
echo "Running.."
|
||||
run
|
||||
fi
|
||||
Loading…
Reference in New Issue