def post(self): kwargs = { 'key_name': self.request.get('id'), 'device': self.request.get('type'), 'version': self.request.get('version'), 'country': self.request.get('country'), 'carrier': self.request.get('carrier'), } Device.add(**kwargs)
def get(self): db.delete(DeviceVersions.all().fetch(400)) total = (Device.all().count() / 10) + 1 for x in xrange(total): offset = x * 10 taskqueue.add(url='/tasks/AggregateVersionsWorker', params={'offset': offset})
def post(self): offset = int(self.request.get('offset')) devices = Device.all().filter('version =', 'Unknown').fetch(10, offset) for device in devices: logging.debug("Device: %s" % device.key().name()) if device.version_raw: UnknownVersions.increment(device.version_raw)
def post(self): offset = int(self.request.get('offset')) devices = Device.all().fetch(10, offset) for device in devices: logging.debug("Device: %s" % device.key().name()) if device.type: DeviceAggregate.increment(device.type)
def post(self): offset = int(self.request.get('offset')) devices = Device.all().fetch(10, offset) for device in devices: logging.debug("Device: %s" % device.key().name()) if device.version: DeviceVersions.increment(device.version)
def old_xml_import(xmlfile, user, request_form): filename = xmlfile.filename data = xmlfile.readlines() if isinstance(data[0], bytes): data = [str(x.decode('utf-8')) for x in data] data[0] = data[0] + "<sml>" data.append("</sml>") filematch = re.match( r'log-([A-F0-9]{16})-\d{4}-\d{2}-\d{2}T\d{2}_\d{2}_\d{2}-\d+\.xml', filename) if not filematch: flash("illegal filename: '%s'" % filename, 'error') return serial_number = filematch.group(1) tree = objectify.fromstring("\n".join(data).encode('utf-8')) move = parse_move(tree) move.source = filename move.import_module = __name__ device = Device.query.filter_by(serial_number=serial_number).scalar() if not device: device = Device() device.serial_number = serial_number db.session.add(device) if Move.query.filter_by(user=user, date_time=move.date_time, device=device).scalar(): flash("%s at %s already exists" % (move.activity, move.date_time), 'warning') else: move.user = user move.device = device db.session.add(move) for sample in parse_samples(tree.Samples.iterchildren(), move): db.session.add(sample) postprocess_move(move) db.session.commit() return move
def get(self): db.delete(UnknownVersions.all().fetch(400)) total = (Device.all().filter('version =', 'Unknown').count() / 10) + 1 for x in xrange(total): offset = x * 10 taskqueue.add(url='/tasks/AggregateUnknownVersionsWorker', params={'offset': offset})
def post(self): offset = int(self.request.get('offset')) devices = Device.all().fetch(10, offset) for device in devices: logging.debug("Device: %s" % device.key().name()) if device.country_code: DeviceCountries.increment(device.country_code)
def get(self): db.delete(DeviceCountries.all().fetch(1000)) total = (Device.all().count() / 10) + 1 for x in xrange(total): offset = x * 10 taskqueue.add(url='/tasks/AggregateCountriesWorker', params={'offset': offset})
def initialize_device(): """ Set up the Device info into the database. By this time, the HardwareDefinition and SoftwareDefinition entries must be entered. """ session = Session() hd = session.query(HardwareDefinition).one() sd = session.query(SoftwareDefinition).one() device = Device(id=hd.serial_number, interior_sensor=hd.interior_sensor, exterior_sensor=hd.exterior_sensor) device.hardware_version = hd.hardware_version device.software_version = sd.software_version device.database_service = True # database always set to True device.device_service = sd.device_service device.grainbin_service = sd.grainbin_service session.add(device) # set grainbin info if sd.grainbin_service: grainbins = initialize_grainbin(device.id, hd.grainbin_reader_count) device.grainbin_count = len(grainbins) session.add_all(grainbins) session.commit() session.close() return
def post(self): offset = int(self.request.get('offset')) devices = Device.all().fetch(10, offset) for device in devices: logging.debug("Device: %s" % device.key().name()) if not device.carrier: device.carrier = "Unknown" DeviceCarriers.increment(device.carrier)
def __create_device(self) -> Device: firmware = self.__get_firmware() protocol = self.__get_protocol() errors = self.__get_errors() return Device(name='Advanced Sample Device', firmware=firmware, protocol=protocol, errors=errors)
def edit(device_id): device = Device.get(device_id) if not device: device = Device() form = DeviceProfileForm() form.type.choices = [('1', u'Base Station'), ('2', u'Node')] if request.method == 'POST': form.save_form(device) return redirect(url_for('devices')) return render_template('edit.html', form=form, device=device)
def get(self): tpl_values = { 'device_count': Device.getCount(), 'devices_count': DeviceAggregate.getKeyCount(), 'device_data': DeviceAggregate.generateGraphData(), 'carrier_count': DeviceCarriers.getKeyCount(), 'country_count': DeviceCountries.getKeyCount(), } self.render(tpl_values)
def old_xml_import(xmlfile, user, request_form): filename = xmlfile.filename data = xmlfile.readlines() if isinstance(data[0], bytes): data = [str(x.decode('utf-8')) for x in data] data[0] = data[0] + "<sml>" data.append("</sml>") filematch = re.match(r'log-([A-F0-9]{16})-\d{4}-\d{2}-\d{2}T\d{2}_\d{2}_\d{2}-\d+\.xml', filename) if not filematch: flash("illegal filename: '%s'" % filename, 'error') return serial_number = filematch.group(1) tree = objectify.fromstring("\n".join(data).encode('utf-8')) move = parse_move(tree) move.source = filename move.import_module = __name__ device = Device.query.filter_by(serial_number=serial_number).scalar() if not device: device = Device() device.serial_number = serial_number db.session.add(device) if Move.query.filter_by(user=user, date_time=move.date_time, device=device).scalar(): flash("%s at %s already exists" % (move.activity, move.date_time), 'warning') else: move.user = user move.device = device db.session.add(move) for sample in parse_samples(tree.Samples.iterchildren(), move): db.session.add(sample) postprocess_move(move) db.session.commit() return move
def clientRegisterDevice(self, data): try: if self.authenticated: self.user.update() device_id = data['device'] if not device_id: self.sendAPI(1,447,'Value empty') return if len(device_id) > 120: self.sendAPI(1,449,'Value exceeds maximum input length') return device = Device(device_id) phone_number = data['phone_number'] if not isinstance(phone_number, int): self.sendAPI(1,448,'Value is wrong data type') return if phone_number > 2147483646: self.sendAPI(1,449,'Value exceeds maximum input length') return if phone_number < 0: self.sendAPI(1,447,'Value empty') return if device.exist(): self.sendAPI(1,436,'Device already exist') return device.user = self.user if 'phone_number' in data: device.phone_number = phone_number self.user.addDevice(device) self.sendAPI(0,236,'Device registered') else: self.sendAPI(1,410,'User unauthorized') except (KeyError, TypeError): self.sendAPI(1,401,'Not in reference format')
def get_faulty_devices_for_user(self, user_id): faulty_devices = self.repositories.device_repository.get_faulty_devices() house_id = self.collection.get_houses_for_user(user_id)[0].house_id target_devices = [] fault_check = False for device in faulty_devices: if device.house_id == house_id: fault_check = True target_devices.append(Device(device)) self.collection.update_one({'_id': user_id}, {"$set": {'faulty': fault_check}}, upsert=False) return target_devices
def load_devices(cls): cls.devicenamelist = [] for device in cls.config['Devices']: deviceobject = Device(device['deviceid']) deviceobject.devicename = device['devicename'] deviceobject.serverport = device['serverport'] deviceobject.bootstrapport = device['bootstrapport'] deviceobject.platformname = device['platformname'] deviceobject.platformversion = device['platformversion'] deviceobject.server = device['server'] cls.devices[deviceobject.deviceid] = deviceobject cls.devicenamelist.append(device['devicename']) Log.logger.info(u"配置yaml列表中一共有 %s 台设备" % len(cls.devices))
def get_devices(self): """Return a list of devices with Spotify players running. Returns: list: The Devices. """ results = self.get_api_v1("me/player/devices") if results and "devices" in results: return tuple(Device(device) for device in results['devices']) else: return []
def index(): if request.method == 'POST': four_node_data = list() res = None for node in request.form: device_id = int(node.rsplit('_')[1]) device = Device.get(device_id) if device: lng = device.lng lat = device.lat t = float(request.form[node]) data = (lng, lat, t) four_node_data.append(data) if len(four_node_data) >= 4: res = get_position(four_node_data) return jsonify({'lng': res[0], 'lat': res[1]}) devices = Device.get_base_station() return render_template('index.html', devices=devices)
def load_devices(cls): cls.device_name_list = [] for device in cls.config['Devices']: device_object = Device(device['deviceid']) device_object.device_name = device['devicename'] device_object.server_port = device['serverport'] device_object.bootstrap_port = device['bootstrapport'] device_object.platform_name = device['platformname'] device_object.platform_version = device['platformversion'] device_object.server = device['server'] cls.devices[device_object.device_id] = device_object cls.device_name_list.append(device['devicename']) Log.logger.info("There are %s devices in the configuration list" % len(cls.devices))
def submitDigital(self, subject): device = subject.get('i') self.statusDevice[device] = subject.get('v') self.log.info("change : {} = {}".format(device, self.statusDevice[device])) self.publish(u'io.robotica.controle.on_{}'.format(device), self.statusDevice[device]) self.publish(u'io.robotica.controle.on_digital', self.statusDevice) #Write to Mongodb last status of device deviceDB = Device.objects(mac = device).get() deviceDB.date = datetime.now() deviceDB.status = self.statusDevice[device] deviceDB.save() return subject
def getResults(resultsDir, build, version, pipeline, commiter): testResults = [] date = time.strftime('%x') for subdir, dirs, files in os.walk(resultsDir, topdown=True): testList = prepareTestList(files, subdir) if testList: deviceMeta = getDeviceMeta(subdir) device = Device(deviceMeta[0], build, version, pipeline, deviceMeta[3], deviceMeta[2], "00:00", date, commiter, "Android, " + deviceMeta[1], testList) testResults.append(device) return testResults
def get_device_by_id(self, device_id): device = self.collection.find_one({'_id': device_id}) if device is None: return None device_type = device['device_type'] if 'device_type' in device else None if device_type == "thermostat": return Thermostat(device) elif device_type == "motion_sensor": return MotionSensor(device) elif device_type == "light_switch": return LightSwitch(device) elif device_type == "open_sensor": return OpenSensor(device) return Device(device)
def clientDeleteDevice(self, data): try: if self.authenticated: self.user.update() device_id = data['device'] if not device_id: self.sendAPI(1,447,'Value empty') return if not isinstance(device_id, basestring): self.sendAPI(1,448,'Value is wrong data type') return device = Device(device_id) if device.exist(): self.user.deleteDevice(device) self.sendAPI(0,266,'Device deleted') else: self.sendAPI(1,410,'User unauthorized') except (KeyError, TypeError): self.sendAPI(1,401,'Not in reference format')
def createSpineIFDs(self, pod, spines): devices = [] interfaces = [] for spine in spines: user = spine.get('user') password = spine.get('pass') device = Device(spine['name'], pod.spineDeviceType, user, password, 'spine', spine['mac_address'], spine['mgmt_ip'], pod) devices.append(device) portNames = util.getPortNamesForDeviceFamily(device.family, self.conf['deviceFamily']) for name in portNames['ports']: # spine does not have any uplink/downlink marked, it is just ports ifd = InterfaceDefinition(name, device, 'downlink') interfaces.append(ifd) self.dao.createObjects(devices) self.dao.createObjects(interfaces)
def devices_lnglat(): data = [] devices = Device.get_devices() for device in devices: d = {} d['device_id'] = device.id d['lng'] = device.lng d['lat'] = device.lat d['name'] = device.name if device.type == NODE: d['icon_uri'] = url_for('static', filename=NODE_IMG_URI) else: d['icon_uri'] = url_for('static', filename=BASESTATION_IMG_URI) data.append(d) return jsonify({'data': data})
def createLeafIFDs(self, pod, leafs): devices = [] interfaces = [] for leaf in leafs: user = leaf.get('user') password = leaf.get('pass') device = Device(leaf['name'], pod.leafDeviceType, user, password, 'leaf', leaf['mac_address'], leaf['mgmt_ip'], pod) devices.append(device) portNames = util.getPortNamesForDeviceFamily(device.family, self.conf['deviceFamily']) for name in portNames['uplinkPorts']: # all uplink IFDs towards spine ifd = InterfaceDefinition(name, device, 'uplink') interfaces.append(ifd) for name in portNames['downlinkPorts']: # all downlink IFDs towards Access/Server ifd = InterfaceDefinition(name, device, 'downlink') interfaces.append(ifd) self.dao.createObjects(devices) self.dao.createObjects(interfaces)
def add_device_readings(): # huey.courses.add(Course.select().where(Course.name.contains('English'))) device = Device.get(name='Sensor-300578') print(device.id, device.name, device.health)
def parse_device(tree): device = Device() device.name = tree.DeviceLog.Device.Name.text device.serial_number = tree.DeviceLog.Device.SerialNumber.text return device
def get(self): self.render({'device_count': Device.getCount()})
def get_all_devices(self): devices = self.collection.find() target_devices = [] for device in devices: target_devices.append(Device(device)) return target_devices
def get_devices_for_room(self, room_id): devices = self.collection.find({'room_id': room_id}) target_devices = [] for device in devices: target_devices.append(Device(device)) return target_devices
def delete(device_id): Device.delete(device_id) return redirect(url_for('devices'))
def PollRequest(device_id): db = session() tree = cut_namespace_request() # create or update parameters for device device = db.query(Device).get(device_id) if device == None: device = Device() device.id = device_id db.add(device) device.management_system = tree.lookup('ManagementSystem/Name') device.management_version = tree.lookup('ManagementSystem/Version') device.name = tree.lookup('Identification/DeviceName') device.username = tree.lookup('Identification/UserName') device.platform = tree.lookup('Identification/Platform') device.processor = tree.lookup('Identification/Processor') device.ip_address = tree.lookup('Identification/NetworkAdapter/IPAddress') device.ip_subnet = tree.lookup('Identification/NetworkAdapter/IPSubnet') device.codepage = tree.lookup('Identification/CodePage') device.default_locale_id = tree.lookup('Identification/SystemDefaultLCID') device.last_poll_update() db.commit() # send current parameters back to device return render_template('poll_response.xml', device = device, server = Server())
def create_device(): device = Device() device.name = GPX_DEVICE_NAME device.serial_number = GPX_DEVICE_SERIAL return device
def __init__(self, config): ApplicationSession.__init__(self, config) self.payload = {} self.user = User() self.device = Device() self.statusDevice = {}
def get(self): self.response.out.write("%s" % Device.getCount())
def collectLldpAndMatchDevice(self): if (self.configurationInProgressCache.checkAndAddDevice(self.deviceIp)): # for real device the password is coming from pod tmpDevice = Device(self.deviceIp, None, 'root', self.pod.getCleartextPassword(), 'leaf', None, self.deviceIp, None) tmpDevice.id = self.deviceIp self.updateSelfDeviceContext(tmpDevice) logger.debug('Started two stage configuration for %s' % (self.deviceIp)) for i in range(1, self.attempt+1): # wait first: this will replace the original delay design logger.debug('Wait for %d seconds...' % (self.interval)) # don't do unnecessary context switch if self.interval > 0: self.stopEvent.wait(self.interval) if self.stopEvent.is_set(): return logger.debug('Connecting to %s: attempt %d' % (self.deviceIp, i)) try: self.connectToDevice() logger.debug('Connected to %s' % (self.deviceIp)) break except Exception as exc: pass if self.deviceConnectionHandle is None: logger.error('All %d attempts failed for %s' % (self.attempt, self.deviceIp)) self.configurationInProgressCache.doneDevice(self.deviceIp) raise DeviceConnectFailed('All %d attempts failed for %s' % (self.attempt, self.deviceIp)) try: self.device.family = self.deviceConnectionHandle.facts['model'].lower() self.device.serialNumber = self.deviceConnectionHandle.facts['serialnumber'] self.runPreLldpCommands() lldpData = self.collectLldpFromDevice() except Exception as exc: logger.error('Failed to execute deleteVcpPorts for %s, %s' % (self.deviceIp, exc)) raise DeviceRpcFailed('Failed to execute deleteVcpPorts %s' % (self.deviceIp), exc) uplinksWithIfds = self.filterUplinkAppendRemotePortIfd(lldpData, self.device.family) self.updateSpineStatusFromLldpData([x['ifd2'] for x in uplinksWithIfds]) device = self.findMatchedDevice(uplinksWithIfds) if device is None: logger.info('Did not find good enough match for %s' % (self.deviceIp)) self.configurationInProgressCache.doneDevice(self.deviceIp) return self.fixInterfaces(device, self.device.family, uplinksWithIfds) # persist serialNumber device.serialNumber = self.device.serialNumber self._dao.updateObjectsAndCommitNow(self._session, [device]) self.updateSelfDeviceContext(device) try: try: self.runPostLldpCommands() except SkipCommit: self.updateDeviceConfigStatus('good') return self.updateDeviceConfigStatus('processing') self.updateDeviceConfiguration() self.updateDeviceConfigStatus('good') except DeviceRpcFailed as exc: logger.error('Two stage configuration failed for %s, %s' % (self.deviceLogStr, exc)) self.updateDeviceConfigStatus(None, error = exc) raise except Exception as exc: logger.error('Two stage configuration failed for %s, %s' % (self.deviceLogStr, exc)) self.updateDeviceConfigStatus('error', str(exc)) raise finally: self.releaseConfigurationInProgressLock(self.deviceIp) logger.debug('Ended two stage configuration for %s' % (self.deviceLogStr)) else: logger.debug('Two stage configuration is already in progress for %s', (self.deviceLogStr))
def devices(): devices = Device.get_devices() return render_template('devices.html', devices=devices)
def collectLldpAndMatchDevice(self): if (self.configurationInProgressCache.checkAndAddDevice( self.deviceIp)): # for real device the password is coming from pod tmpDevice = Device(self.deviceIp, None, 'root', self.pod.getCleartextPassword(), 'leaf', None, self.deviceIp, None) tmpDevice.id = self.deviceIp self.updateSelfDeviceContext(tmpDevice) logger.debug('Started two stage configuration for %s' % (self.deviceIp)) for i in range(1, self.attempt + 1): # wait first: this will replace the original delay design logger.debug('Wait for %d seconds...' % (self.interval)) # don't do unnecessary context switch if self.interval > 0: self.stopEvent.wait(self.interval) if self.stopEvent.is_set(): return logger.debug('Connecting to %s: attempt %d' % (self.deviceIp, i)) try: self.connectToDevice() logger.debug('Connected to %s' % (self.deviceIp)) break except Exception as exc: pass if self.deviceConnectionHandle is None: logger.error('All %d attempts failed for %s' % (self.attempt, self.deviceIp)) self.configurationInProgressCache.doneDevice(self.deviceIp) raise DeviceConnectFailed('All %d attempts failed for %s' % (self.attempt, self.deviceIp)) try: self.device.family = self.deviceConnectionHandle.facts[ 'model'].lower() self.device.serialNumber = self.deviceConnectionHandle.facts[ 'serialnumber'] self.runPreLldpCommands() lldpData = self.collectLldpFromDevice() except Exception as exc: logger.error('Failed to execute deleteVcpPorts for %s, %s' % (self.deviceIp, exc)) raise DeviceRpcFailed( 'Failed to execute deleteVcpPorts %s' % (self.deviceIp), exc) uplinksWithIfds = self.filterUplinkAppendRemotePortIfd( lldpData, self.device.family) self.updateSpineStatusFromLldpData( [x['ifd2'] for x in uplinksWithIfds]) device = self.findMatchedDevice(uplinksWithIfds) if device is None: logger.info('Did not find good enough match for %s' % (self.deviceIp)) self.configurationInProgressCache.doneDevice(self.deviceIp) return self.fixInterfaces(device, self.device.family, uplinksWithIfds) # persist serialNumber device.serialNumber = self.device.serialNumber self._dao.updateObjectsAndCommitNow(self._session, [device]) self.updateSelfDeviceContext(device) try: try: self.runPostLldpCommands() except SkipCommit: self.updateDeviceConfigStatus('good') return self.updateDeviceConfigStatus('processing') self.updateDeviceConfiguration() self.updateDeviceConfigStatus('good') except DeviceRpcFailed as exc: logger.error('Two stage configuration failed for %s, %s' % (self.deviceLogStr, exc)) self.updateDeviceConfigStatus(None, error=exc) raise except Exception as exc: logger.error('Two stage configuration failed for %s, %s' % (self.deviceLogStr, exc)) self.updateDeviceConfigStatus('error', str(exc)) raise finally: self.releaseConfigurationInProgressLock(self.deviceIp) logger.debug('Ended two stage configuration for %s' % (self.deviceLogStr)) else: logger.debug( 'Two stage configuration is already in progress for %s', (self.deviceLogStr))
def __create_device() -> Device: return Device(name='Sample Device', firmware=0xa2c3f, protocol='SAMPLE', errors=[0x0000])
def get_devices_for_house(self, house_id): devices = self.collection.find({'house_id': house_id}) target_devices = [] for device in devices: target_devices.append(Device(device)) return target_devices
def parse_device(tree): device = Device() device.name = GPX_DEVICE_NAME device.serial_number = GPX_DEVICE_SERIAL return device
def post(self): post = simplejson.loads(self.request.body) phoneKey = None deviceKey = None brandKey = None benchmarkKey = None phoneID = None device = None brand = None totalScore = None testResults = [] # get post data try: phoneID = post["phoneid"] device = post["device"] brand = post["brand"] totalScore = int(post["total_score"]) testResults = post["results"] except KeyError: self.error(404) if phoneID is not None and device is not None and brand is not None and totalScore is not None and testResults: query = Phone.all() query.filter("phoneid =", phoneID) results = query.fetch(1) # get phone key if query.count(1) > 0: phoneKey = results[0].key() else: phoneKey = Phone( phoneid = phoneID ).put() query = Device.all() query.filter("name =", device) results = query.fetch(1) # get device key if query.count(1) > 0: deviceKey = results[0].key() else: query = Brand.all() query.filter("brandname =", brand) results = query.fetch(1) # get brand key if query.count(1) > 0: brandKey = results[0].key() else: # add brand brandKey = Brand( brandname = brand ).put() # add device deviceKey = Device( brandkey = Key(brandKey), name = device ).put() # new benchmark if phoneKey is not None and deviceKey is not None: benchmarkKey = Benchmark( phonekey = phoneKey, devicekey = deviceKey, total_score = totalScore ).put() if benchmarkKey is not None: for result in testResults: test = None testKey = None try: test = result["test"] except KeyError: self.error(404) # get test key query = Test.all() query.filter("name =", test) results = query.fetch(1) # get phone key if query.count(1) > 0: testKey = results[0].key() score = None successful = None try: score = int(result["score"]) successful = bool(result["successful"]) except KeyError: self.error(404) if testKey is not None and score is not None and successful is not None: # put test result testResultKey = TestResult( benchmarkkey = benchmarkKey, testkey = testKey, score = score, successful = successful ).put() if not testResultKey: self.error(405) break; else: self.error(404) else: self.error(404) else: self.error(404) else: self.error(404)