def setUpClass(cls):
secret = cls.get_secret()
region = cls.get_region()
cls.ec2_connector = ECSConnector(Transaction(), {})
print('SET CLIENT')
cls.ec2_connector.set_client(secret, region)
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.monitoring')
connect('test', host='mongomock://localhost')
cls.domain_id = utils.generate_id('domain')
cls.transaction = Transaction({
'service': 'monitoring',
'api_class': 'DataSource'
})
super().setUpClass()
def notify(self, transaction: Transaction, params: dict) -> dict:
token = self._get_token(transaction.meta)
domain_id = self._extract_domain_id(token)
meta: list = transaction.get_connection_meta()
token_info = self._authenticate(token, domain_id, meta)
self._update_meta(transaction, token_info)
return params
def __init__(self, transaction=None, conf=None, **kwargs):
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction()
self.config = conf
for k, v in kwargs.items():
setattr(self, k, v)
def setUpClass(cls):
config.init_conf(package='spaceone.notification')
connect('test', host='mongomock://localhost')
cls.domain_id = utils.generate_id('domain')
cls.transaction = Transaction({
'service': 'notificaiton',
'api_class': 'ProjectChannel'
})
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.statistics')
connect('test', host='mongomock://localhost')
cls.domain_id = utils.generate_id('domain')
cls.transaction = Transaction({
'service': 'statistics',
'api_class': 'Schedule'
})
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.identity')
config.set_service_config()
config.set_global(MOCK_MODE=True)
connect('test', host='mongomock://localhost')
cls.domain_id = utils.generate_id('domain')
cls.transaction = Transaction({
'service': 'identity',
'api_class': 'Provider'
})
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.power_scheduler')
config_path = os.environ.get('TEST_CONFIG')
test_config = utils.load_yaml_from_file(config_path)
cls.schema = 'azure_client_secret'
cls.azure_credentials = test_config.get('AZURE_CREDENTIALS', {})
cls.vm_connector = AzureVMConnector(transaction=Transaction(), config={}, secret_data=cls.azure_credentials)
# cls.resource_data =
cls.vm_manager = AzureVmManager(azure_vm_connector=cls.vm_connector)
super().setUpClass()
def __init__(self, transaction=None, **kwargs):
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction()
self.locator = Locator(self.transaction)
for k, v in kwargs.items():
setattr(self, k, v)
def setUpClass(cls):
config.init_conf(package='spaceone.monitoring')
config.set_service_config()
config.set_global(MOCK_MODE=True)
config_path = os.environ.get('TEST_CONFIG')
test_config = utils.load_yaml_from_file(config_path)
cls.transaction = Transaction()
cls.connector_conf = test_config.get('MonitoringPluginConnector', {})
cls.dsp_connector = DataSourcePluginConnector(cls.transaction, {})
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.monitoring')
config_path = os.environ.get('TEST_CONFIG')
test_config = utils.load_yaml_from_file(config_path)
cls.schema = 'aws_access_key'
cls.aws_credentials = test_config.get('AWS_CREDENTIALS', {})
cls.resource = test_config.get('RESOURCE')
cls.metric = test_config.get('METRIC')
cls.aws_connector = AWSBotoConnector(Transaction(), {})
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.monitoring')
cls.secret_data = _get_credentials()
cls.azure_connector = AzureConnector(Transaction(), {})
cls.client = None
cls.subscription_id = cls.secret_data.get('subscription_id')
cls.resource_group = 'jhsong-resource-group'
cls.vm_name = 'jhsong-monitor-test-vm'
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.notification')
config_path = os.environ.get('TEST_CONFIG')
test_config = utils.load_yaml_from_file(config_path)
cls.transaction = Transaction(
{'token': test_config.get('access_token')})
cls.domain_id = test_config.get('domain_id')
cls.connector_conf = test_config.get('IdentityConnector')
cls.identity_connector = IdentityConnector(cls.transaction,
cls.connector_conf)
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.repository')
config.set_service_config()
config.set_global(MOCK_MODE=True)
connect('test', host='mongomock://localhost')
cls.repository_vo = RepositoryFactory(repository_type='local')
cls.repository_id = cls.repository_vo.repository_id
cls.domain_id = utils.generate_id('domain')
cls.transaction = Transaction({
'service': 'repository',
'api_class': 'Schema'
})
super().setUpClass()
def setUpClass(cls):
config.init_conf(package='spaceone.monitoring')
config.set_service_config()
config.set_global(MOCK_MODE=True)
config_path = os.environ.get('TEST_CONFIG')
test_config = utils.load_yaml_from_file(config_path)
cls.transaction = Transaction(
{'token': test_config.get('access_token')})
cls.domain_id = test_config.get('domain_id')
cls.connector_conf = test_config.get('SecretConnector')
cls.secret_connector = SecretConnector(cls.transaction,
cls.connector_conf)
super().setUpClass()
def __init__(self, *args, **kwargs):
self.transaction = Transaction()
self.locator = Locator(self.transaction)
if hasattr(current_app.conf, "spaceone_scheduler_service"):
self.service_name = current_app.conf.get("spaceone_scheduler_service")
else:
raise SpaceOneSchedulerError("can not find CELERY.spaceone_scheduler_service config")
self.Service = self.locator.get_service(self.service_name, metadata=self.metadata)
self._schedule = {}
self._last_updated = None
Scheduler.__init__(self, *args, **kwargs)
self.max_interval = (kwargs.get('max_interval')
or self.app.conf.CELERYBEAT_MAX_LOOP_INTERVAL or 5)
def __init__(self, metadata={}, transaction=None):
self.func_name = None
self.is_with_statement = False
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction(metadata)
set_logger(transaction=self.transaction)
self.locator = Locator(self.transaction)
self.handler = {
'authentication': {'handlers': [], 'methods': []},
'authorization': {'handlers': [], 'methods': []},
'event': {'handlers': [], 'methods': []},
}
def setUpClass(cls):
config.init_conf(package='spaceone.inventory')
config_path = os.environ.get('TEST_CONFIG')
test_config = utils.load_yaml_from_file(config_path)
cls.schema = 'azure_client_secret'
cls.azure_credentials = {
'secret_data': test_config.get('AZURE_CREDENTIALS', {})
}
cls.azure_connector = SnapshotConnector(transaction=Transaction(),
config={},
secret_data=test_config.get(
'AZURE_CREDENTIALS', {}))
# cls.azure_connector = DiskConnector(transaction=Transaction(), config={}, secret_data=cls.azure_credentials['secret_data'])
super().setUpClass()
def __init__(self, metadata: dict = None, transaction: Transaction = None, **kwargs):
self.func_name = None
self.is_with_statement = False
if metadata is None:
metadata = {}
if transaction:
self.transaction = transaction
else:
self.transaction = Transaction(metadata)
if config.get_global('SET_LOGGING', True):
set_logger(transaction=self.transaction)
self.locator = Locator(self.transaction)
self.handler = {
'authentication': {'handlers': [], 'methods': []},
'authorization': {'handlers': [], 'methods': []},
'mutation': {'handlers': [], 'methods': []},
'event': {'handlers': [], 'methods': []},
}
def setUp(self):
self.set_up_moto()
self.connector = self.connector_class(
Transaction(), self.connector_config, self.connector_options,
credentials=self.credentials, **self.connector_kwargs)
def setup_logging(**kwargs):
if config.get_global('CELERY', {}).get('mode') == 'BEAT':
set_logger()
else:
set_logger(transaction=Transaction())
}
if __name__ == "__main__":
import os
aki = os.environ.get('AWS_ACCESS_KEY_ID', "<YOUR_AWS_ACCESS_KEY_ID>")
sak = os.environ.get('AWS_SECRET_ACCESS_KEY',
"<YOUR_AWS_SECRET_ACCESS_KEY>")
secret_data = {
# 'region_name': 'ap-northeast-2',
'aws_access_key_id': aki,
'aws_secret_access_key': sak
}
conn = HealthConnector(Transaction(), secret_data)
#opts = conn.verify({}, secret_data)
#print(opts)
options = {
'eventStatusCodes': ['open', 'upcoming', 'closed'],
'all_events': True
}
query = {}
#query = {'region_name': ['ap-northeast-2', 'us-east-1']}
#query = {}
from datetime import datetime, timedelta
end = datetime.utcnow()
start = end - timedelta(days=7)
ec2_arn = 'arn:aws:ec2:ap-northeast-2:072548720675:instance/i-08c5592e084b24e20'
sort = ""
limit = 50
def _get_transaction(secret_data):
return Transaction({'token': secret_data.get('api_key', None)})
sak = os.environ.get('AWS_SECRET_ACCESS_KEY', None)
role_arn = os.environ.get('ROLE_ARN', None)
if role_arn:
secret_data = {
# 'region_name': 'ap-northeast-2',
'aws_access_key_id': aki,
'aws_secret_access_key': sak,
'role_arn': role_arn
}
else:
secret_data = {
# 'region_name': 'ap-northeast-2',
'aws_access_key_id': aki,
'aws_secret_access_key': sak
}
conn = EC2Connector(Transaction(), secret_data)
opts = conn.verify({}, secret_data)
#print(opts)
#query = {'region_name': ['ap-northeast-1']}
#query = {'instance_id': ['i-0745c928020bed89f'], 'region_name': ['ap-northeast-2']}
#query = {'instance_id': ['i-0873656da2e3af584', 'i-123'], 'region_name': ['ap-northeast-1', 'ap-northeast-2']}
# query = {'instance_id': ['i-0873656da2e3af584'], 'region_name': ['ap-northeast-2']}
query = {}
a = datetime.datetime.now()
resource_stream = conn.collect_info(query=query, secret_data=secret_data)
b = datetime.datetime.now()
c = b - a
print(f'Computing time: {c}')
def __init__(self, *args, **kwargs):
transaction = Transaction()
self.locator = Locator(transaction)
def response(self, transaction: Transaction, result):
user_type = transaction.get_meta('user_type')
pass
def request(self, transaction: Transaction, params):
user_type = transaction.get_meta('user_type')
pass
def setUpClass(cls):
config.init_conf(package='spaceone.monitoring')
cls.secret_data = _get_credentials() if _get_credentials() is not None else {}
cls.gcp_connector = GoogleCloudConnector(Transaction(), {})
super().setUpClass()
raise ERROR_REPOSITORY_BACKEND(host=params['host'])
def _get_aws_region_from_host(self, host):
# host = https://<account_id>.dkr.ecr.ap-northeast-2.amazonaws.com
item = host.split('.')
return item[3]
def _get_aws_ecr_token(self, region_name):
try:
sess = boto3.Session()
resp = sess.client('ecr', region_name=region_name).get_authorization_token()
token = resp['authorizationData'][0]['authorizationToken']
token = base64.b64decode(token).decode()
username, password = token.split(':')
return password
except Exception as e:
_LOGGER.error(f'[_get_aws_ecr_token] {e}')
raise ERROR_AWS_ECR_TOKEN()
if __name__ == "__main__":
from spaceone.core.transaction import Transaction
tnx = Transaction()
config = {'host': 'https://<account_id>.dkr.ecr.ap-northeast-2.amazonaws.com',
'verify_ssl': False,
'username': '******',
'api_version': 2}
r = RegistryConnector(tnx, config)
a = r.get_tags('spaceone/server-mockup')
print(a)
'result': {}
}
if __name__ == "__main__":
import os
aki = os.environ.get('AWS_ACCESS_KEY_ID', "<YOUR_AWS_ACCESS_KEY_ID>")
sak = os.environ.get('AWS_SECRET_ACCESS_KEY',
"<YOUR_AWS_SECRET_ACCESS_KEY>")
secret_data = {
# 'region_name': 'ap-northeast-2',
'aws_access_key_id': aki,
'aws_secret_access_key': sak
}
conn = CloudTrailConnector(Transaction(), secret_data)
#opts = conn.verify({}, secret_data)
#print(opts)
query = {}
#query = {'region_name': ['ap-northeast-2', 'us-east-1']}
#query = {}
from datetime import datetime
start = datetime(2020, 4, 9)
end = datetime(2020, 4, 10)
ec2_arn = 'arn:aws:ec2:ap-northeast-2:072548720675:instance/i-08c5592e084b24e20'
sort = ""
limit = 10
resource_stream = conn.collect_info(query=query,
secret_data=secret_data,
start=start,
end=end,
