from config import cfg
from log import logging
from sync import update_member, get_profile
from common import get_profile_api
import client
import time
logger = logging.getLogger(__name__)
logger.info("loading...")
# https://discordpy.readthedocs.io/en/latest/api.html?highlight=discord%20guild#discord.Permissions
def user_is_privledge(ctx):
# allow bot owner
if ctx.message.author.id in cfg['discord']['admins']:
return True
# allow server owner
if ctx.message.author.id == ctx.message.guild.owner.id:
return True
# allow server admins
permissions = ctx.message.channel.permissions_for(ctx.message.author)
if permissions.administrator:
return True
elif permissions.manage_guild:
return True
elif permissions.manage_channels:
return True
elif permissions.manage_roles:
return True
import copy
import time
from log import logging
logger = logging.getLogger('usage.query')
_OPS = {
"gt": ">",
"ge": ">=",
"lt": "<",
"le": "<="
}
def query(field, op, value, type=''):
"""Assemble a dict representing a query filter.
:param field: Field to query
:type field: String
:param op: Query operator
:type op: String
:param value: Value to query
:type value: String
:param type: Type of the value
:type type: String
:return: Query filter dict
:rtype: Dict
"""
return {
'field': field,
from roletester.actions.neutron import floatingip_delete
from roletester.actions.neutron import network_delete
from roletester.actions.neutron import port_delete
from roletester.actions.neutron import router_delete
from roletester.actions.neutron import router_remove_interface
from roletester.actions.neutron import security_group_delete
from roletester.actions.neutron import security_group_rule_delete
from roletester.actions.neutron import subnet_delete
from roletester.actions.nova import server_delete
from roletester.actions.nova import server_wait_for_status
from roletester.actions.swift import swift_container_delete
from roletester.actions.swift import swift_object_delete
from scenario import Scenario
logger = logging.getLogger('roletester.garbage.Collector')
class Collector(object):
def __init__(self, clients):
"""Init the collector with a set of admin clients.
:param clients: Client manager. Should have admin privileges
:type clients: roletester.clients.ClientManager
"""
self._clients = clients
self._delete_map = {
'container_name': Scenario()
.chain(swift_container_delete, clients),
from log import logging
import inspect
logger = logging.getLogger()
class Host(object):
def __init__(self, name, host=None, address=None, component=None, ssh_key=None, state='UNKNOWN'):
self.__name = name
self.__host = host
self.__address = address
self.__component = component
self.__hostDic = {}
self.__ssh_key = ssh_key
self.__state = state
def getName(self):
return self.__name
def setName(self, name):
self.__name = name
def getHost(self):
return self.__host
def setHost(self, host):
self.__host = host
def getAddress(self):
return self.__address
import copy
from exc import NoSamplesError
from exc import UnknownCounterTypeError
from log import logging
from conversions import convert
from conversions.time_units import seconds_to_hours
ALLOWED_METER_TYPES = set(['gauge', 'cumulative', 'delta'])
logger = logging.getLogger('usage.reading')
class Reading:
"""Models a reading of a meter."""
def __init__(self, samples, start, stop):
"""Init the reading.
:param samples: List of samples sorted by timestamp.
:type samples: List
:param start: Starting datetime.
:type start: Datetime
:param stop: Stopping datetime.
:type stop: Datetime
"""
self.start = start
self.stop = stop
self._during_samples = []
self._split_samples(samples)
self._calculate()
import csv
import datetime
from log import logging
logger = logging.getLogger('usage.summary')
class Summary:
"""
This class will group resources by keystone domains then by a group_by
column. Values of the cost column are summed.
"""
def __init__(self,
domain_client=None,
input_file=None,
project_id_column=None,
cost_column=None,
group_by=None):
"""Inits the summary.
:param domain_client: DomainClient instance.
:type domain_client: usage.clients.DomainClient
:param input_file: Name of the input file
:type input_file: String
:param project_id_column: Name of the column containing the project id
:type project_id_column: String
:param cost_column: Name of the column containing the cost
:type cost_column: String
:param group_by: Name of the column to group by
:type group_by: String
import copy
from exc import NoSamplesError
from exc import UnknownCounterTypeError
from log import logging
from conversions import convert
from conversions.time_units import seconds_to_hours
from data import trim
ALLOWED_METER_TYPES = set(['gauge', 'cumulative', 'delta'])
logger = logging.getLogger('usage.reading')
class Reading:
"""Models a reading of a meter."""
def __init__(self, samples, start, stop):
"""Init the reading.
:param samples: List of samples sorted by timestamp.
:type samples: List
:param start: Starting datetime.
:type start: Datetime
:param stop: Stopping datetime.
:type stop: Datetime
"""
self.start = start
self.stop = stop
trim(samples)
self._during_samples = []
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from auth_stack2 import AuthStack
import keystoneclient.v2_0.users
from log import logging
from keystoneauth1 import exceptions as keystone_exceptions
import utils
logger = logging.getLogger('copystack.keystone_common')
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
logger.addHandler(ch)
# Useful CLI commands:
# view tenant details:
# keystone tenant-get foobar1
# get tenant list:
# keystone tenant-list
# create tenant:
# keystone tenant-create --name foobar --description "foobar tenant"
def get_keystone(destination):
import csv
import datetime
from log import logging
logger = logging.getLogger('usage.summary')
class Summary:
"""
This class will group resources by keystone domains then by a group_by
column. Values of the cost column are summed.
"""
def __init__(self,
domain_client=None,
input_file=None,
project_id_column=None,
cost_column=None,
group_by=None):
"""Inits the summary.
:param domain_client: DomainClient instance.
:type domain_client: usage.clients.DomainClient
:param input_file: Name of the input file
:type input_file: String
:param project_id_column: Name of the column containing the project id
:type project_id_column: String
:param cost_column: Name of the column containing the cost
:type cost_column: String
:param group_by: Name of the column to group by
:type group_by: String
from args import parser as argparser
from clients import ClientManager
import config
from log import logging
import time
import utils
from actions.cinder import create as volume_create
from actions.cinder import delete as volume_delete
from actions.glance import create as image_create
from actions.glance import delete as image_delete
from actions.nova import delete as server_delete
from actions.nova import create as server_create
logger = logging.getLogger('randomload')
def run():
logger.info("Starting randomload...")
actions = [
server_create,
server_delete,
image_create,
image_delete,
volume_create,
volume_delete
]
args = argparser.parse_args()
conf = config.load(args.config_file)
interval = conf.get('interval', 60)
from log import logging
logger = logging.getLogger('usage.domain_cache')
_CACHE = {}
_DOMAIN_CLIENT = None
def set_domain_client(domain_client):
global _DOMAIN_CLIENT
_DOMAIN_CLIENT = domain_client
def get_domain_name(project_id):
if _DOMAIN_CLIENT is None:
raise Exception('Unable to retrieve domain for project {}. '
'Please set the domain client first.')
if project_id not in _CACHE:
try:
domain = _DOMAIN_CLIENT.get_domain_for_project(project_id)
_CACHE[project_id] = domain['name']
except Exception:
logger.exception(
'Unable to retrieve domain for project {}'.format(project_id))
_CACHE[project_id] = 'unknown'
return _CACHE[project_id]
import yaml
import random
import inspect
from dataContract.host import Host
from dataContract.stack import Stack
from log import logging
logger = logging.getLogger('chaos.InfoParser')
class InfoParser(object):
# parse the inventory file and generate a stack instance
inventory = '/etc/openstack_deploy/openstack_inventory.json'
logger.info(inventory)
stack = Stack.Instance()
def __init__(self):
with open(self.inventory) as data_file:
data = yaml.safe_load(data_file)
if data and data['_meta'] and data['_meta']['hostvars']:
try:
for key, value in data['_meta']['hostvars'].iteritems():
self.stack.addHost(key, value['physical_host'], value['container_address'], value['component'])
except:
logger.error(str(inspect.stack()[0][3]))
logger.info(
'calling func : ' + str(inspect.stack()[1][3]) + '() from ' + str(inspect.stack()[1][1]))
def getStackInstance(self):
import datetime
import itertools
import query
import utils
from exc import InvalidTimeRangeError
from log import logging
from reading import Reading
logger = logging.getLogger('usage.meter')
def _cmp_sample(a, b):
"""Compare two samples.
First compare the resource ids. Compare the timestamps if the
resource ids are the same.
:param a: First sample
:param b: Second sample
:return: Result of cmp function.
:rtype: Integer
"""
result = cmp(a.resource_id, b.resource_id)
if result == 0:
result = cmp(a.timestamp, b.timestamp)
return result
class Meter:
"""
import settings
import requests
import json
import base64
from tqdm import tqdm
# Import logging
from log import logging
logger = logging.getLogger('Ondadias puler')
# Querying products paging results:
# 1 item for page
# --------------------------------
url = settings.SERVICE_URL + settings.OB_PATH_PRODUCTS + '?' + settings.OB_TPL_PAGING.format(
0, 1)
# Querying Sentinel-3 SRAL Products
url += '&$search="instrumentShortName:SRAL"'
response = requests.get(url)
#controlliamo che non ci siano errori nella risposta e nel caso stampiamo a video i messaggio
if response.status_code != 200:
err_msg = f'Status Code: {response.status_code}, err msg: {response.content}'
logger.error(err_msg)
raise Exception(err_msg)
jresponse = json.loads(response.content)
"""SCF 函数的入口
"""
import base64
from io import BytesIO
from conf.settings import WORKPIECES
from log import logging
from screenshot import generate_screenshot, upload_yqt_screenshot
from submit_to_yqt import submit_to_yqt
logger = logging.getLogger('yqt_bot')
def main_handler(event, _):
# 定时触发，填报疫情通
if event.get('Type') == 'Timer' and event.get('TriggerName') == 'submit_to_yqt':
# [总数, 成功数]
count = [0, 0]
for item in WORKPIECES:
if 'submit_to_yqt' in item['actions']:
try:
count[0] += 1
submit_to_yqt(item['stu_id'], item['passwd'])
count[1] += 1
except ValueError as e:
if str(e) == '今天已经填报疫情通，不能重复填报':
logger.warning(f'{item["name"]} 今天已经填报疫情通，已忽略')
from os import path, listdir, mkdir
from typing import Callable, Union, Optional, Tuple, Any
from Download import (ResultPackage, RequestPackageList, AbsDownloader,
ExitState)
from log import logging, core_logger
logging.getLogger('werkzeug').setLevel(logging.WARNING)
_SUBCLASS_NAME_SET = set()
_SUBCLASS_ORDER = 0
SUBCLASS_DICT = {}
class StorageUnit:
def __init__(self, tid: int, task_name: str, type_id: int, over: bool,
current_stage: int, params_list: list, data: list,
save_path: str):
self.Tid = tid
self.TaskName = task_name
self.TypeID = type_id
self.Over = over
self.CurrentStage = current_stage
if not data: # if list of data is empty
assert params_list is not None
self.ParamsList = params_list
self.Data = data
self.SavePath = save_path
def json(self) -> list:
return [
import yaml
import random
import inspect
from dataContract.host import Host
from dataContract.stack import Stack
from log import logging
logger = logging.getLogger('chaos.InfoParser')
class InfoParser(object):
# parse the inventory file and generate a stack instance
inventory = '/etc/openstack_deploy/openstack_inventory.json'
logger.info(inventory)
stack = Stack.Instance()
def __init__(self):
with open(self.inventory) as data_file:
data = yaml.safe_load(data_file)
if data and data['_meta'] and data['_meta']['hostvars']:
try:
for key, value in data['_meta']['hostvars'].iteritems():
self.stack.addHost(key, value['physical_host'],
value['container_address'],
value['component'])
except:
logger.error(str(inspect.stack()[0][3]))
logger.info('calling func : ' +
str(inspect.stack()[1][3]) + '() from ' +
from log import logging
logger = logging.getLogger('usage.domain_cache')
_CACHE = {}
_DOMAIN_CLIENT = None
def set_domain_client(domain_client):
global _DOMAIN_CLIENT
_DOMAIN_CLIENT = domain_client
def get_domain_name(project_id):
if _DOMAIN_CLIENT is None:
raise Exception('Unable to retrieve domain for project {}. '
'Please set the domain client first.')
if project_id not in _CACHE:
try:
domain = _DOMAIN_CLIENT.get_domain_for_project(project_id)
_CACHE[project_id] = domain['name']
except Exception:
logger.exception('Unable to retrieve domain for project {}'
.format(project_id))
_CACHE[project_id] = 'unknown'
return _CACHE[project_id]
'''
ARP Scanner
This module will need root privilege
'''
from scapy.all import srp,Ether,ARP
from log import logging
from orchestrator.common.config import CONF
LOG = logging.getLogger(__name__)
mac_ip_table = {}
def scan_macs(subnet = CONF.get('Default', 'local_net')):
try:
ans,unans = srp(Ether(dst="FF:FF:FF:FF:FF:FF")/ARP(pdst=subnet),timeout=2,verbose=False)
except Exception,e:
LOG.error(str(e))
else:
for snd,rcv in ans:
mac = rcv.sprintf("%Ether.src%")
ip = rcv.sprintf("%ARP.psrc%")
mac_ip_table[mac] = ip
return mac_ip_table
def logger(self):
logger = logging.getLogger(self.__class__.__name__)
return logging.LoggerAdapter(logger,
{'spider': self.__class__.__name__})
import utils
from args.report import parser as report_parser
from args.summary import parser as summary_parser
from clients import create_client_manager
from log import logging
from report import Report
from summary import Summary
LOG_LEVELS = {
'debug': logging.DEBUG,
'info': logging.INFO
}
logger = logging.getLogger('usage')
logger.setLevel(logging.INFO)
def console_licensing():
"""Summarizes a csv report."""
from licensing import Licensing
from args.licensing import parser as licensing_parser
from domain_cache import set_domain_client
args = licensing_parser.parse_args()
conf = config.load(args.config_file)
logger.setLevel(LOG_LEVELS.get(args.log_level.lower(), 'info'))
clientmanager = create_client_manager(**conf.get('auth_kwargs', {}))
set_domain_client(clientmanager.get_domain())
Licensing(
definition_file=args.definition_file,
from args import parser as argparser
from clients import ClientManager
import config
from log import logging
import time
import utils
from actions.cinder import create as volume_create
from actions.cinder import delete as volume_delete
from actions.glance import create as image_create
from actions.glance import delete as image_delete
from actions.nova import delete as server_delete
from actions.nova import create as server_create
logger = logging.getLogger('randomload')
def run():
logger.info("Starting randomload...")
actions = [
server_create, server_delete, image_create, image_delete,
volume_create, volume_delete
]
args = argparser.parse_args()
conf = config.load(args.config_file)
interval = conf.get('interval', 60)
clients = ClientManager(**conf.get('auth_kwargs', {}))
last_action_time = 0
while True:
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from auth_stack2 import AuthStack
import keystoneclient.v2_0.users
from log import logging
from keystoneauth1 import exceptions as keystone_exceptions
import utils
logger = logging.getLogger('copystack.keystone_common')
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
logger.addHandler(ch)
# Useful CLI commands:
# view tenant details:
# keystone tenant-get foobar1
# get tenant list:
# keystone tenant-list
# create tenant:
# keystone tenant-create --name foobar --description "foobar tenant"
def get_keystone(destination):
import csv
import time
import utils
import yaml
from contextlib import contextmanager
from exc import UnknownFieldFunctionError
from fields import field_function
from fields.reading import image_metadata_field
from fields.reading import metadata_field
from log import logging
from meter import Meter
logger = logging.getLogger('usage.report')
class Report:
"""Report class."""
def __init__(self,
client,
definition_filename,
output,
max_samples=15000,
start=None,
stop=None):
"""Read in report definition from file.
:param client: Ceilometer client
:type client:
:param definition_filename: Name of report definition file.
:type definition_filename: String
import config
import utils
from args import parser
from clients import ClientManager
from log import logging
from report import Report
LOG_LEVELS = {
'debug': logging.DEBUG,
'info': logging.INFO
}
logger = logging.getLogger('usage')
logger.setLevel(logging.INFO)
def console_report():
"""Runs a report from the cli."""
args = parser.parse_args()
conf = config.load(args.config_file)
logger.setLevel(LOG_LEVELS.get(args.log_level.lower(), 'info'))
manager = ClientManager(**conf.get('auth_kwargs', {}))
ceilometer = manager.get_ceilometer()
if args.mtd:
start, stop = utils.mtd_range()
elif args.today:
start, stop = utils.today_range()
import datetime
import itertools
import query
import utils
from exc import InvalidTimeRangeError
from exc import NoSamplesError
from log import logging
from reading import Reading
logger = logging.getLogger('usage.meter')
def _cmp_sample(a, b):
"""Compare two samples.
First compare the resource ids. Compare the timestamps if the
resource ids are the same.
:param a: First sample
:param b: Second sample
:return: Result of cmp function.
:rtype: Integer
"""
result = cmp(a.resource_id, b.resource_id)
if result == 0:
result = cmp(a.timestamp, b.timestamp)
return result
class Meter:
from roletester.actions.cinder import volume_wait_for_status
from roletester.actions.glance import image_delete
from roletester.actions.neutron import floatingip_delete
from roletester.actions.neutron import network_delete
from roletester.actions.neutron import port_delete
from roletester.actions.neutron import router_delete
from roletester.actions.neutron import security_group_delete
from roletester.actions.neutron import security_group_rule_delete
from roletester.actions.neutron import subnet_delete
from roletester.actions.nova import server_delete
from roletester.actions.swift import swift_container_delete
from roletester.actions.swift import swift_object_delete
from scenario import Scenario
logger = logging.getLogger('roletester.garbage.Collector')
class Collector(object):
def __init__(self, clients):
"""Init the collector with a set of admin clients.
:param clients: Client manager. Should have admin privileges
:type clients: roletester.clients.ClientManager
"""
self._clients = clients
self._delete_map = {
'container_name':
Scenario().chain(swift_container_delete, clients),
'floatingip_id':
Scenario().chain(floatingip_delete, clients),
"""该应用的命令行入口
"""
import argparse
from log import logging
from index import main_handler
from screenshot import generate_screenshot
logger = logging.getLogger('yqt_tool')
def main():
parser = argparse.ArgumentParser(prog='python3 yqttool.py',
description='疫情通填报、截图生成、截图上传工具')
parser.add_argument(
'action',
type=str,
metavar='ACTION',
choices=('submit_to_yqt', 'upload_screenshot', 'generate_screenshot'),
help=('执行的操作。 '
'submit_to_yqt ，根据 conf/settings.py 的配置填报疫情通； '
'upload_screenshot ，根据 conf/settings.py 的配置上传疫情通截图； '
'generate_screenshot ，生成疫情通截图。'))
parser.add_argument('-n',
'--name',
type=str,
metavar='NAME',
help='姓名，生成疫情通截图时必填')
from dataContract.infoParser import InfoParser
from dataContract.logLevel import LogLevel
from log import logging
import sys
import argparse
if __name__ == '__main__':
logger = logging.getLogger()
parser = argparse.ArgumentParser(description='Process Chaos creation.')
parser.add_argument(
'--act',
type=str,
default='container',
choices=['container', 'service'],
help='Usage for act on container/service level, default=container')
parser.add_argument(
'--log',
type=str,
default='debug',
choices=['critical', 'error', 'warning', 'debug', 'info', 'notest'],
help='Usage for log level, default=debug')
parser.add_argument('--min',
type=int,
default=30,
help='Usage for min sec, should be > 30 sec')
parser.add_argument('--max',
type=int,
default=50,
help='Usage for max sec, should be > 50 sec')
from args import parser as argparser
from clients import ClientManager
import config
from log import logging
import time
import utils
from keystone_manager import KeystoneManager
from clients import ClientManager
from actions.nova import delete as server_delete
from actions.nova import create as server_create
from scenario import Scenario
logger = logging.getLogger('roletester')
from exc import NovaNotFound
km = KeystoneManager()
admin_kwargs = {
'auth_url': 'someurl',
'username': '******',
'password': '******',
'project_id': 'someprojectid',
'user_domain_name': 'Default',
'project_domain_name': 'Default'
}
admin_clients = km.find_user_credentials('Default', 'admin', 'admin')
demo_kwargs = {
from log import logging
from keystone_manager import KeystoneManager
from actions.nova import delete as server_delete
from actions.nova import create as server_create
from scenario import Scenario
logger = logging.getLogger('roletester')
from exc import NovaNotFound
km = KeystoneManager()
admin_kwargs = {
'auth_url': 'someurl',
'username': '******',
'password': '******',
'project_id': 'someprojectid',
'user_domain_name': 'Default',
'project_domain_name': 'Default'
}
admin_clients = km.find_user_credentials('Default', 'admin', 'admin')
demo_kwargs = {
'auth_url': 'someurl',
'username': '******',
'password': '******',
'project_id': 'someprojectid',
'user_domain_name': 'demodomain',
'project_domain_name': 'demodeomain'
