def snapshot(self, credentials): timestamp = time.time() hostname = credentials['host'] test_file = Utility.load_yaml( f"testfiles/{credentials['device_type']}.yaml") dev = ConnectHandler(**credentials) output = '' for test in test_file: if 'command' not in test_file[test][0]: continue raw_command_name = str(test).replace('-', '_') #command = test_file[test][0]['command'] module = import_module( f'drivers.snapshot.cisco.commands.{raw_command_name}') command_ref = getattr(module, raw_command_name) command_ref = command_ref() xml = command_ref.schemaify( command_ref.parse(dev.send_command(command_ref.command()))) output = output + f"{hostname}@@@@{timestamp}@@@@{raw_command_name}@@@@{xml}@@@@@@" with open(f'snapshots/compiled_snapshots/{hostname}_{timestamp}.xml', 'w') as fp: fp.write(output) return Utility.return_json(True, 'Snapshot Completed')
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, visitor=self.visitor.to_json(all_fields), host=self.host.to_json(all_fields), representing=self.representing, purpose=self.purpose, start_date=self.start_date.isoformat(), end_date=self.end_date.isoformat(), start_time=self.start_time.isoformat(), end_time=self.end_time.isoformat(), escort_required=self.escort_required, is_approved=self.is_approved, is_expired=self.is_expired, is_removed=self.is_removed, teams=self.get_team_members(), entrance=self.entrance, created=self.created.isoformat(), modified=Utility.format_datetime(self.modified), created_by=Utility.return_instance_id(self.created_by), modified_by=Utility.return_instance_id(self.modified_by) ) if all_fields: json_object.update(dict()) return json_object
def parse(self, response): ipItem = IpItem() proxy = response.meta['p'] rootPath = proxy['root'] table = response.xpath(rootPath).extract() for sel in Selector(response=response).xpath(rootPath): ipPath = proxy['ip'] portPath = proxy['port'] ipList = sel.xpath(ipPath).extract() portList = sel.xpath(portPath).extract() ip = Utility.listToStr(ipList) port = Utility.listToStr(portList) # using regular expression regex = '\d.{1,3}\d{1,3}' if re.match(regex, ip): print ip v = ValidateIp() protocol, anonymous, speed = v.validate(ip, port) if protocol is not -1: ipItem['ip'] = ip ipItem['port'] = port print ipItem['ip'], ':', ipItem['port'] yield ipItem else: continue else: continue
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, first_name=self.first_name, last_name=self.last_name, email=self.email, gender=self.gender, phone=self.phone, black_listed=self.black_listed, occupation=self.occupation, company=self.get_company(), date_of_birth=Utility.format_datetime(self.date_of_birth), nationality=self.nationality, state_of_origin=self.state_of_origin, lga_of_origin=self.lga_of_origin, pass_code=self.pass_code, type=self.get_type(), created=Utility.format_datetime(self.created), modified=Utility.format_datetime(self.modified), created_by=Utility.return_instance_id(self.created_by), modified_by=Utility.return_instance_id(self.modified_by) ) if all_fields: json_object.update(dict( image=self.image, fingerprint=self.fingerprint, signature=self.signature, )) return json_object
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, email=self.email, last_name=self.last_name, first_name=self.first_name, username=self.username, is_superuser=self.is_superuser, is_active=self.is_active, is_staff=self.is_staff, date_joined=Utility.format_datetime(self.date_joined), last_login=Utility.format_datetime(self.last_login), groups=list(self.get_group_permissions(self.groups)), user_permissions=list(self.get_all_permissions(self.user_permissions)), phone=self.phone, work_phone=self.work_phone, gender=self.gender, home_phone=self.home_phone, department=self.get_department_or_object(all_fields), ) if all_fields: json_object.update(dict( password=self.password, image=self.image )) return json_object
def parseAccount(self, response): urls = [] articleListItem = ArticleListItem() title = response.xpath('/html/head/title//text()').extract() print Utility.listToStr(title) # account = response.xpath('//*[@class="profile_infoß"]//text()').extract()[0].strip() print '----------------------account-------------------------' for articlePath in Selector(response=response).xpath( '//*[@class="weui_media_box appmsg"]/div'): # title title = articlePath.xpath('./h4//text()').extract()[0].strip() articleListItem['title'] = title print articleListItem['title'] # url url = articlePath.xpath('./h4//@hrefs').extract()[0] url = "https://mp.weixin.qq.com" + url articleListItem['url'] = url print articleListItem['url'] # date date = articlePath.xpath( './/*[@class="weui_media_extra_info"]//text()').extract()[0] articleListItem['date'] = date print articleListItem['date'] # abstract abstract = articlePath.xpath( './/*[@class="weui_media_desc"]//text()').extract() articleListItem['abstract'] = Utility.listToStr(abstract) print articleListItem['abstract'] urls.append(url) return urls
def get_pre_snapshots(self, hostname): try: return Utility.return_json( 1, 'get_pre_snapshots()', JSnapComparison().get_pre_snapshots(hostname)) except Exception as e: return Utility.return_json(0, e.msg)
def test_encrypt_decrypt(self): text = 'abcd123' encrypt = Utility.encrypt(text) self.assertTrue(isinstance(encrypt, str)) decrypt = Utility.decrypt(encrypt) self.assertTrue(isinstance(decrypt, str)) self.assertEqual(decrypt, text)
def post_or_put(self, request, *args, **kwargs): request.data['_id'] = self.kwargs['_id'] request.data['created_by'] = Utility.return_id(UserProfile, request.data.get('created_by'), '_id') request.data['modified_by'] = Utility.return_id(UserProfile, request.data.get('modified_by'), '_id') try: model.objects.get(_id=self.kwargs['_id']) return self.update(request, *args, **kwargs) except model.DoesNotExist: return self.create(request, *args, **kwargs)
def setUp(self): self.listing_file = Utility.get_stock_listing_xlsx(Market.US) self.stock_file_CINF = Utility.get_stock_price_history_file( Market.US, 'CINF', '1985', 'nasdaq') self.stock_file_GOOG = Utility.get_stock_price_history_file( Market.US, 'GOOG', '2004', 'nasdaq') self.stock_file_MMM = Utility.get_stock_price_history_file( Market.US, 'MMM', '1985', 'nyse') self.stock_file_GS = Utility.get_stock_price_history_file( Market.US, 'GS', '1999', 'nyse')
def __init__(self): # init logging os.makedirs('logs', exist_ok=True) logging.config.dictConfig(Utility.get_logging_config()) self.logger = logging.getLogger(__name__) self.config = Utility.get_config() self.args = self.parse_argument() self.robinhood = RobinhoodAccount(self.config.robinhood_account, Utility.decrypt(self.args.rhp))
def setUp(self): self.listing_file = Utility.get_stock_listing_xlsx(Market.US) self.stock_file_CINF = Utility.get_stock_price_history_file( Market.US, 'CINF') self.stock_file_GOOG = Utility.get_stock_price_history_file( Market.US, 'GOOG') self.stock_file_MMM = Utility.get_stock_price_history_file( Market.US, 'MMM') self.stock_file_GS = Utility.get_stock_price_history_file( Market.US, 'GS')
def delete_snapshot(self, hostname, timestamp): try: if not Utility.is_file_path_safe(hostname) or str(timestamp).count('.') > 1: return Utility.return_json(0, 'Invalid hostname') os.remove(f"snapshots/compiled_snapshots/{hostname}_{timestamp}.xml") except: return Utility.return_json(0, 'Unable to delete snapshot, probably non-existent') return Utility.return_json(1, 'Snapshot deleted')
def nest_row(row, id=None): if id is not None: row['_id'] = id appointment = Utility.get_nested(Appointments, AppointmentSerializer, row['appointment']) if len(appointment) > 0: appointment['host'] = Utility.get_nested(UserProfile, UserSerializer, appointment['host']) appointment['visitor'] = Utility.get_nested(Visitors, VisitorSerializer, appointment['visitor']) del appointment['visitor']['image'] del appointment['host']['image'] appointment['log'] = row row = appointment return row
def post_or_put(self, request, *args, **kwargs): request.data['_id'] = self.kwargs['_id'] request.data['company'] = Utility.return_id(Company, request.data.get('company', None), 'name') request.data['type'] = Utility.return_id(VisitorTypes, request.data.get('type', None), 'name') try: model.objects.get(_id=self.kwargs['_id']) instance_exists = True except model.DoesNotExist: instance_exists = False if instance_exists: return self.update(request, *args, **kwargs) else: return self.create(request, *args, **kwargs)
def post_or_put(self, request, *args, **kwargs): request.data['_id'] = self.kwargs['_id'] request.data['entrance'] = Utility.return_id(Entrance, request.data.get('entrance'), 'name') request.data['created_by'] = Utility.return_id(UserProfile, request.data.get('created_by'), '_id') request.data['modified_by'] = Utility.return_id(UserProfile, request.data.get('modified_by'), '_id') try: model.objects.get(_id=self.kwargs['_id']) instance_exists = True except model.DoesNotExist: instance_exists = False if instance_exists: return self.update(request, *args, **kwargs) else: return self.create(request, *args, **kwargs)
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, name=self.name, created=Utility.format_datetime(self.created), modified=Utility.format_datetime(self.modified), created_by=Utility.get_instance_fields(self.created_by, ['_id', 'username']), modified_by=Utility.get_instance_fields(self.modified_by, ['_id', 'username']) ) if all_fields: json_object.update(dict()) return json_object
def post(self, request): config = ConfigManager().get_config() user = None username = request.data.get('username', None) password = request.data.get('password', None) if config.get('authType', 'api') == 'api': user = authenticate(username=username, password=password) if config.get('authType', 'api') == 'ldap': user = LDAPManager().ldap_login(username, password) if user is not None: if user.is_active: token = Token.objects.get(user=user) serializer = UserSerializer(user) data = serializer.data del data['password'] data['department'] = Utility.get_nested(Department, DepartmentSerializer, data['department']) return Response({'user': data, 'token': token.key}) else: return Response({'detail': 'User not active'}, status=status.HTTP_400_BAD_REQUEST) return Response({'detail': 'invalid credentials provided'}, status=status.HTTP_401_UNAUTHORIZED)
def parseArticle(self, response): articleItem = ArticleItem() title = response.xpath( '//*[@id="activity-name"]//text()').extract()[0].strip() date = response.xpath('//*[@id="post-date"]//text()').extract()[0] author = response.xpath( '//*[@id="img-content"]/div[1]/em[2]').extract() account = response.xpath('//*[@id="post-user"]//text()').extract()[0] accountId = response.xpath( '//*[@id="js_profile_qrcode"]/div/p[1]/span//text()').extract()[0] content = response.xpath('//*[@id="js_content"]').extract() articleItem['title'] = title.encode('utf-8') articleItem['date'] = date.encode('utf-8') articleItem['account'] = account.encode('utf-8') articleItem['accountId'] = accountId.encode('utf-8') articleItem['content'] = Utility.listToStr(content).encode('utf-8') if len(author) > 0: author = author[0].encode('utf-8') articleItem['author'] = author else: articleItem['author'] = '' print articleItem['title'] # Utility.writeArticleToFile(articleItem) yield articleItem
def getBlock(self, coordinate): i, j = [Utility.round(k) for k in coordinate] i, j = self.coordinateToIndex((i, j)) if i < 0 or i >= self.width or j < 0 or j >= self.height: return Constants.AIR_BLOCK block = self.blocks[j][i] return block
def save_snapshot(sender, instance, **kwargs): def get_value(data, field): from django.db.models.fields.related import ForeignKey if isinstance(field, ForeignKey) and data: return getattr(data, '_id', 'no id') elif data is not None: return data elif isinstance(field, (DateTimeField, DateField, TimeField)): return Utility.format_datetime(data) else: return '' if getattr(instance, '_id', None) is not None: changed = dict() current_record = sender.objects.filter(_id=instance._id) if len(current_record) > 0: current_record = current_record.first() fields = instance._meta.get_fields() for field in fields: if field.name not in ['modified_by', 'created_by', '_rev', 'logentry', 'password']: try: current_value = getattr(current_record, field.name) instance_value = getattr(instance, field.name) if current_value != instance_value: if instance(field, DateField): current_value = Utility.format_datetime(current_value) changed[field.name] = get_value(current_value, field) except: pass if len(changed) > 0: model = sender.__name__.lower() try: Changes.objects.create(model=model, type='updated', row_id=instance._id, snapshot=json.dumps(changed)) except Exception as e: print (changed)
def get(self, request, *args, **kwargs): user = Utility.get_data_or_none(UserProfile, request, **kwargs) if user is None: return Response({'detail': 'Not Found'}, status=status.HTTP_404_NOT_FOUND) else: profile = user.to_json(True) del profile['password'] return Response(profile)
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, name=self.name, floor=self.floor, description=self.description, created=Utility.format_datetime(self.created), modifeid=Utility.format_datetime(self.modified), created_by=Utility.return_instance_id(self.created_by), modified_by=Utility.return_instance_id(self.modified_by) ) if all_fields: json_object.update(dict()) return json_object
def get(self, request, *args, **kwargs): instance = Utility.get_data_or_none(model, request, **kwargs) if instance is None: return Response({'detail': 'Not Found'}, status=status.HTTP_404_NOT_FOUND) else: serializer = VisitorGroupSerializer(instance) data = serializer.data row = nest_row(data) return Response(row)
def compare(self, hostname, presnap_timestamp, postsnap_timestamp): try: device_info = Utility.get_device_info(hostname) # Breaking DI by instantiating JSnapComparison here, but I don't foresee making a custom comparison engine for awhile. # But for easier future proofing, I'm leaving this essentially useless class in the process, as it will serve # as an abstraction layer when I do design my own comparison engine return Utility.return_json( 1, "Compare()", JSnapComparison().compare( hostname, presnap_timestamp, postsnap_timestamp, Utility.get_vendor_models()[device_info['vendor']][ device_info['model']])) except Exception as e: return Utility.return_json( 0, 'Failed - ensure you can access sense.one.twcbiz.com APIs')
def get_value(data, field): from django.db.models.fields.related import ForeignKey if isinstance(field, ForeignKey) and data: return getattr(data, '_id', 'no id') elif data is not None: return data elif isinstance(field, (DateTimeField, DateField, TimeField)): return Utility.format_datetime(data) else: return ''
def process_item(self, item, spider): if isinstance(item, ArticleItem): print '==========================================================' p = re.compile(r'(<img(.*?)src=\"(.*?)\")') i = 0 for m in p.finditer(item['content']): url = m.group(3) filename = './img/article_' + str(i) + '.jpg' Utility.getPicFromUrl(url, filename) ls_f = Utility.convertPicToBase64(filename) item['content'] = item['content'].replace('data-src', 'src') item['content'] = item['content'].replace( m.group(3), 'data:image/jpeg;base64,' + ls_f) i += 1 Utility.writeArticleToFile(item) return item
def get(self, request, *args, **kwargs): user = Utility.get_data_or_none(UserProfile, request, **kwargs) if user is None: return Response({'detail': 'Not Found'}, status=status.HTTP_404_NOT_FOUND) else: serializer = UserSerializer(user) data = serializer.data del data['password'] row = nest_row(data) return Response(row)
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, appointment=self.get_appointment(all_fields), license=self.license, model=self.model, type=self.type, color=self.color, created=Utility.format_datetime(self.created), modified=Utility.format_datetime(self.modified), created_by=Utility.get_instance_fields(self.created_by, ['_id', 'username']), modified_by=Utility.get_instance_fields(self.modified_by, ['_id', 'username']) ) if all_fields: json_object.update(dict()) return json_object
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, message_body=self.message_body, destination=self.destination, status=self.status, type=self.type, source=self.source, created=Utility.format_datetime(self.created), modified=Utility.format_datetime(self.modified), created_by=Utility.get_instance_fields(self.created_by, ['_id', 'username']), modified_by=Utility.get_instance_fields(self.modified_by, ['_id', 'username']) ) if all_fields: json_object.update(dict()) return json_object
def extra_filters(request, list): built_filter = Utility.build_filter(FILTER_FIELDS, request.query_params, model) query = dict() order_by = request.query_params.get('order_by', '-created').replace('.', '__') for key in built_filter: query['{}__iexact'.format(key)] = built_filter[key] try: list = model.objects.filter(**query).order_by(order_by) except Exception as e: print (e) return list
def get_snapshots(self, hostname): if not Utility.is_file_path_safe(hostname): raise Exception('Hostname was invalid') snap_files = sorted(glob(f"snapshots/compiled_snapshots/{hostname}_*.xml"), reverse=True) for iter, file in enumerate(snap_files): snap_files[iter] = (os.path.basename(str(file))) (temp_hostname, temp_timestamp) = snap_files[iter].split('_') temp_timestamp = temp_timestamp.strip('.xml') snap_files[iter] = [temp_hostname, temp_timestamp] return snap_files
def get(self, request, *args, **kwargs): instance = Utility.get_data_or_none(model, request, **kwargs) if instance is None: return Response({'detail': 'Not Found'}, status=status.HTTP_404_NOT_FOUND) else: row = instance.to_json(True) row['status'] = Appointments().get_status(row) logs = AppointmentLogs().get_logs(row.get('_id')) sorted_logs = sorted(logs, key=lambda k: k['created'], reverse=True) row['logs'] = sorted_logs if len(sorted_logs) > 0: row['latest'] = sorted_logs[0] return Response(row)
def parse(self, response): for n in range(9): articleListItem = ArticleListItem() num = self.articleListCon rootPath = '//*[@id="sogou_vr_' + num titlePath = rootPath + '_title_' + str(n) + '"]' contentPath = rootPath + '_summary_' + str(n) + '"]' title = response.xpath(titlePath + '//text()').extract() url = response.xpath(titlePath + '/@href').extract()[0] content = response.xpath(contentPath + '//text()').extract() articleListItem['title'] = Utility.listToStr(title) articleListItem['url'] = url articleListItem['abstract'] = Utility.listToStr(content) print 'title==', articleListItem['title'] print 'href==', articleListItem['url'] print 'content==' print articleListItem['abstract'] yield scrapy.Request(url, callback=self.parseArticle)
def post_or_put(self, request, *args, **kwargs): request.data['_id'] = self.kwargs['_id'] request.data['department'] = Utility.return_id(Department, request.data.get('department'), 'name') try: user_instance = UserProfile.objects.get(_id=self.kwargs['_id']) if request.data.get('password', None) is None or request.data.get('password', None) == '': request.data['password'] = user_instance.password elif request.data.get('password', None) is not None and request.data.get('password', None) != '': request.data['password'] = make_password(request.data['password']) return self.update(request, *args, **kwargs) except UserProfile.DoesNotExist: if request.data.get('password', None) is not None and request.data.get('password', None) != '': request.data['password'] = make_password(request.data['password']) return self.create(request, *args, **kwargs)
def snapshot(self, credentials): timestamp = time.time() hostname = credentials['host'] test_file = Utility.load_yaml('testfiles/juniper.yaml') dev = ConnectHandler(**credentials) output = '' for test in test_file: if 'command' not in test_file[test][0]: continue raw_command_name = str(test).replace('-', '_') command = test_file[test][0]['command'] if ' | display xml' not in command: command = command + ' | display xml' result = str(dev.send_command(command)).strip('{master}').strip() xml = etree.fromstring(result).xpath( '//rpc-reply/*[not(self::cli)]') if len(xml) <= 0: return Utility.return_json(False, 'Invalid rpc-reply from device') xml = etree.tostring(xml[0]).decode("utf-8") output = output + f"{hostname}@@@@{timestamp}@@@@{raw_command_name}@@@@{xml}@@@@@@" with open(f'snapshots/compiled_snapshots/{hostname}_{timestamp}.xml', 'w') as fp: fp.write(output) return Utility.return_json(True, 'Snapshot Completed')
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, model=self.model, type=self.type, row_id=self.row_id, rev=self.rev, snapshot=self.snapshot, reviewed=self.reviewed, created=Utility.format_datetime(self.created) ) if all_fields: json_object.update(dict()) return json_object
def nest_row(row, id=None): if id is not None: row['_id'] = id row['visitor'] = Utility.get_nested(Visitors, VisitorSerializer, row['visitor']) row['host'] = Utility.get_nested(UserProfile, UserSerializer, row['host']) row['entrance'] = Utility.get_nested(Entrance, EntranceSerializer, row['entrance']) if type(row['visitor']) is dict and len(row['visitor']) > 0: row['visitor']['company'] = Utility.get_nested(Company, CompanySerializer, row['visitor']['company']) row['visitor']['group'] = Utility.get_nested(VisitorGroup, VisitorGroupSerializer, row['visitor']['group']) if type(row['host']) is dict and len(row['host']) > 0: row['host']['department'] = Utility.get_nested(Department, DepartmentSerializer, row['host']['department']) return row
def parse(self, response): for n in range(1): accountListItem = AccountListItem() num = self.accountListCon rootPath = '//*[@id="sogou_vr_' + num + '_box_' + str(n) + '"]' accountIdPath = './div/div[2]/p[2]/label//text()' txtBox = response.xpath(rootPath) accountId = txtBox.xpath(accountIdPath).extract() accountName = txtBox.xpath('./div/div[2]/p[1]/a//text()').extract() url = txtBox.xpath('./div/div[2]/p[1]/a/@href').extract()[0] accountListItem['account'] = Utility.listToStr(accountName) accountListItem['url'] = url accountListItem['accountId'] = accountId[0].encode('utf-8') print accountListItem['account'] print accountListItem['url'] print accountListItem['accountId'] url = url.replace('http', 'https') cmd = "phantomjs spider/getBody.js '%s'" % url print url print cmd stdout, stderr = subprocess.Popen( cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate() r = HtmlResponse(url=url, body=stdout) articleUrls = self.parseAccount(r) for url in articleUrls: yield scrapy.Request(url, callback=ArticleSpider().parseArticle)
def extra_filters(request, list): if 'q' not in request.query_params: query = [] if request.user.is_superuser is not True and request.user.is_staff is not True: user_appointments = Appointments.objects.filter(host=request.user._id).values_list('visitor___id', flat=True) query.append(Q(_id__in=user_appointments) | Q(created_by=request.user._id)) built_filter = Utility.build_filter(FILTER_FIELDS, request.query_params, model) order_by = request.query_params.get('order_by', '-created').replace('.', '__') for key in built_filter: pin = dict() if 'search' in request.query_params: pin['{}__icontains'.format(key)] = built_filter[key] else: pin['{}__iexact'.format(key)] = built_filter[key] query.append(Q(**pin)) try: list = model.objects.filter(*query).order_by(order_by) except Exception as e: print (e) return list
def to_json(self, all_fields=False): json_object = dict( _id=self._id, _rev=self._rev, appointment=self.appointment, checked_in=Utility.format_datetime(self.checked_in), checked_out=Utility.format_datetime(self.checked_out), label_code=self.label_code, created=Utility.format_datetime(self.created), modified=Utility.format_datetime(self.modified), created_by=Utility.get_instance_fields(self.created_by, ['_id', 'username']), modified_by=Utility.get_instance_fields(self.modified_by, ['_id', 'username']) ) if all_fields: json_object.update(dict()) return json_object
def nest_row(row, id=None): if id is not None: row['_id'] = id visitor = Utility.get_nested(Visitors, VisitorSerializer, row['visitor']) host = Utility.get_nested(UserProfile, UserSerializer, row['host']) if len(visitor) > 0 and id is not None: del visitor['image'] if len(host) > 0 and id is not None: del host['image'] row['visitor'] = visitor row['host'] = host row['status'] = Appointments().get_status(row) row['entrance'] = Utility.get_nested(Entrance, EntranceSerializer, row['entrance']) if type(row['visitor']) is dict and len(row['visitor']) > 0: row['visitor']['company'] = Utility.get_nested(Company, CompanySerializer, row['visitor']['company']) row['visitor']['group'] = Utility.get_nested(VisitorGroup, VisitorGroupSerializer, row['visitor']['group']) if type(row['host']) is dict and len(row['host']) > 0: row['host']['department'] = Utility.get_nested(Department, DepartmentSerializer, row['host']['department']) return row
def snapshot(self, hostname): device_info = Utility.get_device_info(hostname) if device_info == None: return Utility.return_json(0, 'Invalid hostname or IP') class_path_name = Utility.get_vendor_models()[device_info['vendor']][device_info['model']] class_name = class_path_name.capitalize() # Dynamically import and instantiate the correct snapshot class module_name = import_module(f'drivers.snapshot.{device_info["vendor_lower"]}.{class_path_name}') class_ref = getattr(module_name, class_name) snapshot = class_ref() credentials = { 'device_type': Utility.get_device_types()[device_info['vendor']], 'host': hostname, 'username': Utility.get_credentials()['username'], 'password': Utility.get_credentials()['password'] } return snapshot.snapshot(credentials)
def get(self, request, *args, **kwargs): instance = Utility.get_data_or_none(model, request, **kwargs) if instance is None: return Response({'detail': 'Not Found'}, status=status.HTTP_404_NOT_FOUND) else: return Response(instance.to_json(True))
def test_encrypt_decrypt_none(self): self.assertEqual(Utility.encrypt(None), '') self.assertEqual(Utility.decrypt(None), '')
def test_encrypt_decrypt_empty(self): self.assertEqual(Utility.encrypt(''), '') self.assertEqual(Utility.decrypt(''), '')
def setBlock(self, blockType, coordinate): i, j = [Utility.round(k) for k in coordinate] i, j = self.coordinateToIndex((i, j)) self.blocks[j][i] = Block(blockType, i, j)
def test_encrypt_decrypt_space(self): self.assertEqual(Utility.encrypt(' \t '), '') self.assertEqual(Utility.decrypt(' \t \t'), '')
def nest_row(row, id=None): if id is not None: row['_id'] = id row['department'] = Utility.get_nested(Department, DepartmentSerializer, row['department']) return row
def __init__(self): self.loop = None self.snmp_reader = SNMPReader() self.util = Utility()
class EventLoop(object): """AsyncIO EventLoop""" def __init__(self): self.loop = None self.snmp_reader = SNMPReader() self.util = Utility() @staticmethod def get_timeout(sleep, timeout): """ Set a trusted timeout with gathering the sleep time and the timeout. :param sleep: Declared sleep. :param timeout: Declared timeout :return: Trusted Timeout. """ if sleep < timeout: total_time = sleep + timeout else: total_time = max(sleep, timeout) return total_time + .1 # TODO async def read_forever(self, loop, **kwargs): """ Forever worker to collecting the SNMP(s) device. :param loop: asyncio loop. :param kwargs: The below parameters. :return: """ community = kwargs.get('community', 'public') address = kwargs.get('address', '127.0.0.1') port = kwargs.get('port', 161) hostname = (address, port) timeout = kwargs.get('timeout', 1) retries = kwargs.get('retries', 3) oid = kwargs.get('oid', '0.0.0.0.0.0') version = kwargs.get('version', 1) community_data = CommunityData(community, mpModel=version-1) udp_transport_target = UdpTransportTarget(hostname, timeout=timeout, retries=retries) object_type = ObjectType(ObjectIdentity(oid)) while True: try: # async with async_timeout.timeout(total_timeout) as cm: await self.snmp_reader.read_async_full( loop, community_data, udp_transport_target, object_type, **kwargs ) # except asyncio.TimeoutError as exc: # print(cm.expired, exc) # pass except KeyboardInterrupt: loop.close() def run_once(self): """Run once method in asyncio tech.""" if _uvloop: asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) '''Set the uvloop event loop policy.''' loop = asyncio.get_event_loop() configs = get_config() if configs: futures = [asyncio.ensure_future(self.snmp_reader.read_async_full(loop, **conf)) for conf in configs] result = loop.run_until_complete(asyncio.gather(*futures)) print(result) else: raise NotImplementedError() async def restart_loop(self): """An asynchronous loop re-starter worker to monitor the change in the config file.""" loop = asyncio.get_event_loop() _, cache = self.util.is_config_exist() while True: config_path, stamp = self.util.is_config_exist() if stamp != cache: cache = stamp print('Loop will be restarted.') loop.stop() await asyncio.sleep(10) @staticmethod def stop_auth(auth): """Stop ZAP""" try: auth.stop except Exception as exc: print(exc) @staticmethod def destroy_snmp_engines(engine): """ Destroy SNMP-Engine instance. :param engine: :return: """ try: # engine.transportDispatcher.closeDispatcher() engine.unregisterTransportDispatcher() except PySnmpError as snmp_exc: print(snmp_exc) except Exception as exc: print(exc) def termination(self, configs, futures): """ Destroy some expensive instances: Stop ZAP, Destroy SNMP-Engines, Destroy Zombie coroutine Asyncio tasks and clear other memory usage by Python GC. :param configs: SNMP configuration :param futures: Asyncio coroutine tasks. :return: """ for f in futures: f.cancel() for conf in configs: self.destroy_snmp_engines(conf['engine']) for srv in conf['servers']: try: self.stop_auth(srv['auth']) except Exception as exc: print(exc) gc.collect() # TODO def run_forever(self): """Forever event-loop with the loop re-starter ability in asyncio tech.""" if _uvloop: asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) '''Set the uvloop event loop policy.''' loop = asyncio.get_event_loop() loop.create_task(self.restart_loop()) while True: configs = get_config() if configs: futures = [] for conf in configs: if conf['isEnable']: futures.append(loop.create_task(self.read_forever(loop, **conf))) else: info_ = f"{conf['name']} SNMP-Model is Disable." print(info_) try: '''Run''' loop.run_forever() '''Termination''' self.termination(configs, futures) except KeyboardInterrupt: print("The process was killed.") loop.close() sys.exit(0) except asyncio.CancelledError: print('Tasks has been canceled.') loop.close() except Exception: print(traceback.format_exc()) else: time.sleep(5) print("Waiting for SNMP configuration ...")
def __init__(self, app): super().__init__(app) self.initComponents() self.worlds = Utility.loadWorlds() self.updateButtons()
def extra_filters(request, list): if 'load' in request.query_params: load = request.query_params.get('load') def in_progress(): today = date.today() checked_in = AppointmentLogs.objects.filter( checked_in__year=today.year, checked_in__month=today.month, checked_in__day=today.day, checked_out=None, is_removed=False ).values_list('appointment', flat=True) query = dict( _id__in=checked_in, is_removed=False, is_expired=False ) if request.query_params.get('host', None) is not None: query['host'] = request.query_params['host'] if request.user.is_superuser is not True and request.user.is_staff is not True: query['host'] = request.user._id return Appointments.objects.filter(**query) def upcoming(): today = date.today() checked_in = AppointmentLogs.objects.filter( checked_in__year=today.year, checked_in__month=today.month, checked_in__day=today.day, checked_out=None, is_removed=False ).values_list('appointment', flat=True) query = [ Q(start_date__gte=today) | Q(start_date__lte=today), Q(end_date__gte=today), Q(is_expired=False), Q(is_approved=True), Q(is_removed=False), ] if request.query_params.get('host', None) is not None: query.append(Q(host=request.query_params['host'])) if request.user.is_superuser is not True and request.user.is_staff is not True: query.append(Q(host=request.user._id)) return Appointments.objects.filter(*query).exclude(_id__in=checked_in) def awaiting(): today = date.today() query = [ Q(start_date__gte=today) | Q(start_date__lte=today), Q(end_date__gte=today), Q(is_expired=False), Q(is_approved=None), Q(is_removed=False) ] if request.query_params.get('host', None) is not None: query.append(Q(host=request.query_params['host'])) if request.user.is_superuser is not True and request.user.is_staff is not True: query.append(Q(host=request.user._id)) return Appointments.objects.filter(*query) def rejected(): today = date.today() query = dict( is_approved=False, end_date__gt=today, is_removed=False ) if request.query_params.get('host', None) is not None: query['host'] = request.query_params['host'] if request.user.is_superuser is not True and request.user.is_staff is not True: query['host'] = request.user._id return Appointments.objects.filter(**query) if load == 'upcoming': return upcoming() if load == 'pending': return awaiting() if load == 'rejected': return rejected() if load == 'in-progress': return in_progress() if 'q' not in request.query_params: built_filter = Utility.build_filter(FILTER_FIELDS, request.query_params, model) query = dict() search_query = [] if request.user.is_superuser is not True and request.user.is_staff is not True: query['host'] = request.user._id order_by = request.query_params.get('order_by', '-created').replace('.', '__') for key in built_filter: if 'search' in request.query_params: if key == 'host': search_query.append(Q(**{'host__last_name__icontains': built_filter[key]}) | Q(**{'host__first_name__icontains': built_filter[key]})) elif key == 'visitor': search_query.append(Q(**{'visitor__last_name__icontains': built_filter[key]}) | Q(**{'visitor__first_name__icontains': built_filter[key]})) else: search_query.append(Q(**{'{}__icontains'.format(key): built_filter[key]})) else: query['{}__iexact'.format(key)] = built_filter[key] try: if 'search' in request.query_params: list = model.objects.filter(*search_query).order_by(order_by) else: list = model.objects.filter(**query).order_by(order_by) except Exception as e: print (e) return list
def nest_row(row, id=None): if id is not None: row['_id'] = id row['company'] = Utility.get_nested(Company, CompanySerializer, row['company']) return row
def generate_credentials(self): cred = Utility.load_yaml('config/credentials.yaml') return (cred['username'], cred['password'])
def quit(self): Utility.save(self.world) pygame.event.wait() self.app.changeScene("main")
def deleteWorld(self, i): Utility.deleteWorld(i+1) self.worlds[i] = None self.updateButtons()