def _get_metrics_api(server):
assert server['server_properties']['scalarizr.key'], \
"Server %s doesn't have a scalarizr key" % server['server_id']
host = {
'public':server['remote_ip'],
'local':server['local_ip'],
'auto':server['remote_ip'] if server['remote_ip'] else server['local_ip'],
}[CONFIG['instances_connection_policy']]
port = server['server_properties']['scalarizr.api_port']
headers = None
if 'vpc_ip' in server:
if server['remote_ip']:
host = server['remote_ip']
else:
host = server['vpc_ip']
port = 80
headers = {
'X-Receiver-Host':server['local_ip'],
'X-Receiver-Port':server['server_properties']['scalarizr.api_port'],
}
key = cryptotool.decrypt_key(server['server_properties']['scalarizr.key'])
api_type = server['os_type']
metrics = server['metrics']
timeout = CONFIG['instances_connection_timeout']
return szr_api.get_metrics(host, port, key, api_type, metrics, headers=headers, timeout=timeout)
def _get_metrics_api(server):
assert server['server_properties']['scalarizr.key'], \
"Server %s doesn't have a scalarizr key" % server['server_id']
host = {
'public': server['remote_ip'],
'local': server['local_ip'],
'auto':
server['remote_ip'] if server['remote_ip'] else server['local_ip'],
}[CONFIG['instances_connection_policy']]
port = server['server_properties']['scalarizr.api_port']
headers = None
if 'vpc_ip' in server:
if server['remote_ip']:
host = server['remote_ip']
else:
host = server['vpc_ip']
port = 80
headers = {
'X-Receiver-Host':
server['local_ip'],
'X-Receiver-Port':
server['server_properties']['scalarizr.api_port'],
}
key = cryptotool.decrypt_key(server['server_properties']['scalarizr.key'])
api_type = server['os_type']
metrics = server['metrics']
timeout = CONFIG['instances_connection_timeout']
return szr_api.get_metrics(host,
port,
key,
api_type,
metrics,
headers=headers,
timeout=timeout)
def _get_metrics_api(self, server):
assert_msg = "Server: '%s' doesn't have a scalarizr key" % server[
'server_id']
assert server['scalarizr.key'], assert_msg
headers = {'X-Server-Id': server['server_id']}
instances_connection_policy = self.scalr_config.get(
server['platform'],
{}).get('instances_connection_policy',
self.scalr_config['instances_connection_policy'])
ip, port, proxy_headers = helper.get_szr_api_conn_info(
server, instances_connection_policy)
headers.update(proxy_headers)
key = cryptotool.decrypt_key(server['scalarizr.key'])
api_type = server['os_type']
metrics = server['metrics']
timeout = self.config['instances_connection_timeout']
return szr_api.get_metrics(ip,
port,
key,
api_type,
metrics,
headers=headers,
timeout=timeout)
def _get_szr_upd_client(self, server):
key = cryptotool.decrypt_key(server['scalarizr.key'])
headers = {'X-Server-Id': server['server_id']}
instances_connection_policy = self.scalr_config.get(server['platform'], {}).get(
'instances_connection_policy', self.scalr_config['instances_connection_policy'])
ip, port, proxy_headers = helper.get_szr_updc_conn_info(server, instances_connection_policy)
headers.update(proxy_headers)
szr_upd_client = SzrUpdClient(ip, port, key, headers=headers)
return szr_upd_client
def answer(environ, start_response):
data = environ['wsgi.input'].readline()
msg = cryptotool.decrypt(CRYPTO_ALGO, data, cryptotool.decrypt_key(CRYPTO_KEY))
if msg != MSG:
start_response('400 NOT OK', [('Content-Type', 'text/html')])
else:
time.sleep(1)
start_response('201 OK', [('Content-Type', 'text/html')])
yield '<b>Hello world!</b>\n'
def _encrypt(self, server_id, key, data, headers=None):
assert server_id
assert key
assert data
crypto_algo = dict(name="des_ede3_cbc", key_size=24, iv_size=8)
data = cryptotool.encrypt(crypto_algo, data, cryptotool.decrypt_key(key))
headers = headers or dict()
headers['X-Signature'], headers['Date'] = cryptotool.sign(data, key)
headers['X-Server-Id'] = server_id
return data, headers
def _get_szr_upd_client(self, server):
key = cryptotool.decrypt_key(server["scalarizr.key"])
headers = {"X-Server-Id": server["server_id"]}
instances_connection_policy = self.scalr_config.get(server["platform"], {}).get(
"instances_connection_policy", self.scalr_config["instances_connection_policy"]
)
ip, port, proxy_headers = helper.get_szr_updc_conn_info(server, instances_connection_policy)
headers.update(proxy_headers)
szr_upd_client = SzrUpdClient(ip, port, key, headers=headers)
return szr_upd_client
def _encrypt(self, server_id, crypto_key, data, headers=None):
assert server_id, 'server_id'
assert crypto_key, 'scalarizr.key'
assert data, 'data to encrypt'
crypto_algo = dict(name="des_ede3_cbc", key_size=24, iv_size=8)
data = cryptotool.encrypt_scalarizr(crypto_algo, data, cryptotool.decrypt_key(crypto_key))
headers = headers or dict()
headers['X-Signature'], headers['Date'] = cryptotool.sign(data, crypto_key)
headers['X-Server-Id'] = server_id
return data, headers
def answer(environ, start_response):
server_id = environ['HTTP_X_SERVER_ID']
data = environ['wsgi.input'].readline()
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
msg = cryptotool.decrypt_scalarizr(CRYPTO_ALGO, data, cryptotool.decrypt_key(crypto_key))
if msg != 'Carrot':
start_response('400 NOT OK', [('Content-Type', 'text/html')])
else:
time.sleep(0.4)
start_response('201 OK', [('Content-Type', 'text/html')])
yield '<b>Hello world!</b>\n'
def _encrypt(self, server_id, key, data, headers=None):
assert server_id
assert key
assert data
crypto_algo = dict(name="des_ede3_cbc", key_size=24, iv_size=8)
data = cryptotool.encrypt(crypto_algo, data,
cryptotool.decrypt_key(key))
headers = headers or dict()
headers['X-Signature'], headers['Date'] = cryptotool.sign(data, key)
headers['X-Server-Id'] = server_id
return data, headers
def _encrypt(self, server_id, crypto_key, data, headers=None):
assert server_id, 'server_id'
assert crypto_key, 'scalarizr.key'
assert data, 'data to encrypt'
crypto_algo = dict(name="des_ede3_cbc", key_size=24, iv_size=8)
data = cryptotool.encrypt_scalarizr(crypto_algo, data, cryptotool.decrypt_key(crypto_key))
headers = headers or dict()
headers['X-Signature'], headers['Date'] = cryptotool.sign(data, crypto_key)
headers['X-Server-Id'] = server_id
msg = "Server: {0}, key: {1} ... {2}".format(server_id, crypto_key[0:5], crypto_key[-5:])
LOG.debug(msg)
return data, headers
def get(host=None,
port=None,
key=None,
os_type=None,
metrics=None,
proxy=None):
assert (host or proxy) and port and key and os_type and metrics
if proxy:
host = proxy['host']
port = proxy['port']
headers = proxy['headers']
else:
headers = None
endpoint = 'http://%s:%s' % (host, port)
security = rpc.Security(cryptotool.decrypt_key(key))
hsp = rpc.HttpServiceProxy(endpoint,
security=security,
headers=headers)
data = dict()
if 'cpu' in metrics:
try:
data.update(ScalarizrAPI._get_cpu_stat(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api CPU failed: %s' %
(host, port, helper.exc_info()))
if 'la' in metrics:
try:
data.update(ScalarizrAPI._get_la_stat(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api LA failed: %s' %
(host, port, helper.exc_info()))
if 'mem' in metrics:
try:
data.update(ScalarizrAPI._get_mem_info(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api MEM failed: %s' %
(host, port, helper.exc_info()))
if 'net' in metrics:
try:
data.update(ScalarizrAPI._get_net_stat(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api NET failed: %s' %
(host, port, helper.exc_info()))
return data
def answer(environ, start_response):
server_id = environ['HTTP_X_SERVER_ID']
data = environ['wsgi.input'].readline()
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
msg = cryptotool.decrypt_scalarizr(CRYPTO_ALGO, data,
cryptotool.decrypt_key(crypto_key))
if msg != 'Carrot':
start_response('400 NOT OK', [('Content-Type', 'text/html')])
else:
time.sleep(0.4)
start_response('201 OK', [('Content-Type', 'text/html')])
yield '<b>Hello world!</b>\n'
def answer(environ, start_response):
try:
data = environ['wsgi.input'].readline()
key = cryptotool.decrypt_key(scalrpytests.scalarizr_key)
msg = cryptotool.decrypt_scalarizr(scalrpytests.crypto_algo, data, key)
if msg == '400':
start_response('400 NOT OK', [('Content-Type', 'text/html')])
else:
time.sleep(random.randint(3, 40) / 10.0)
start_response('201 OK', [('Content-Type', 'text/html')])
yield '<b>Hello world!</b>\n'
except:
LOG.exception('Answer exception')
def _get_metrics_api(server):
assert_msg = "Server:'%s' doesn't have a scalarizr key" % server['server_id']
assert server['scalarizr.key'], assert_msg
instances_connection_policy = SCALR_CONFIG.get(server['platform'], {}).get(
'instances_connection_policy', SCALR_CONFIG['instances_connection_policy'])
ip, port, headers = helper.get_szr_api_conn_info(server, instances_connection_policy)
key = cryptotool.decrypt_key(server['scalarizr.key'])
api_type = server['os_type']
metrics = server['metrics']
timeout = CONFIG['instances_connection_timeout']
return szr_api.get_metrics(
ip, port, key, api_type, metrics, headers=headers, timeout=timeout)
def answer_error(environ, start_response):
try:
server_id = environ['HTTP_X_SERVER_ID']
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
security = rpc.Security(cryptotool.decrypt_key(crypto_key))
data = json.loads(
security.decrypt_data(environ['wsgi.input'].readline()))
server = lib.world.servers[server_id]
assert 'params' in data
assert 'method' in data
assert 'id' in data, 'id'
if data['method'] == 'status':
assert 'cached' in data['params'], 'cached'
repos = {
'latest': {
'linux': 'http://repo.scalr.net/apt-plain latest/',
'windows': 'http://repo.scalr.net/win/latest',
},
'stable': {
'linux': 'http://repo.scalr.net/apt-plain stable/',
'windows': 'http://repo.scalr.net/win/stable',
}
}
utcnow = datetime.utcnow()
status = {
'server_id': server_id,
'repository': 'stable',
'repo_url': repos['stable'][server['os_type']],
'executed_at': utcnow.strftime('%a %d %b %Y %H:%M:%S UTC'),
'state': u'error',
'error': u'Cool error',
}
answer = {'result': status}
elif data['method'] == 'update':
answer = {'result': 777}
lib.update_count.setdefault(server_id, 0)
lib.update_count[server_id] += 1
else:
assert False, 'method'
response = security.encrypt_data(json.dumps(answer))
start_response('201 OK', [('Content-Type', 'text/html')])
yield response
except:
yield str(sys.exc_info())
def answer_error(environ, start_response):
try:
server_id = environ['HTTP_X_SERVER_ID']
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
security = rpc.Security(cryptotool.decrypt_key(crypto_key))
data = json.loads(security.decrypt_data(environ['wsgi.input'].readline()))
server = lib.world.servers["'%s'" % server_id]
assert 'params' in data
assert 'method' in data
assert 'id' in data, 'id'
if data['method'] == 'status':
assert 'cached' in data['params'], 'cached'
repos = {
'latest': {
'linux': 'http://repo.scalr.net/apt-plain latest/',
'windows': 'http://repo.scalr.net/win/latest',
},
'stable': {
'linux': 'http://repo.scalr.net/apt-plain stable/',
'windows': 'http://repo.scalr.net/win/stable',
}
}
utcnow = datetime.utcnow()
status = {
'server_id': server_id,
'repository': 'stable',
'repo_url': repos['stable'][server['os_type'].strip("'")],
'executed_at': utcnow.strftime('%a %d %b %Y %H:%M:%S UTC'),
'state': u'error',
'error': u'Cool error',
}
answer = {'result': status}
elif data['method'] == 'update':
answer = {'result': 777}
lib.update_count.setdefault(server_id, 0)
lib.update_count[server_id] += 1
else:
assert False, 'method'
response = security.encrypt_data(json.dumps(answer))
start_response('201 OK', [('Content-Type', 'text/html')])
yield response
except:
yield str(sys.exc_info())
def answer(environ, start_response):
try:
server_id = environ['HTTP_X_SERVER_ID']
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
security = rpc.Security(cryptotool.decrypt_key(crypto_key))
data = json.loads(
security.decrypt_data(environ['wsgi.input'].readline()))
server = lib.world.servers[server_id]
assert 'params' in data
assert 'method' in data
assert 'id' in data, 'id'
if data['method'] == 'status':
assert 'cached' in data['params'], 'cached'
repos = {
'latest': {
'linux': 'http://apt.scalr.net/debian scalr/',
'windows': 'http://win.scalr.net',
},
'stable': {
'linux': 'http://apt-delayed.scalr.net/debian scalr/',
'windows': 'http://win-delayed.scalr.net',
}
}
status = {
'server_id': server_id,
'repository': 'stable',
'repo_url': repos['stable'][server['os_type']],
'executed_at': 'Mon 22 Sep 2014 12:00:00 UTC',
'state': '',
'error': '',
}
answer = {'result': status}
elif data['method'] == 'update':
answer = {'result': 777}
lib.update_ok[server_id] = True
else:
assert False, 'method'
response = security.encrypt_data(json.dumps(answer))
start_response('201 OK', [('Content-Type', 'text/html')])
yield response
except:
yield str(sys.exc_info())
def _get_metrics_api(self, server):
assert_msg = "Server: '%s' doesn't have a scalarizr key" % server['server_id']
assert server['scalarizr.key'], assert_msg
headers = {'X-Server-Id': server['server_id']}
instances_connection_policy = self.scalr_config.get(server['platform'], {}).get(
'instances_connection_policy', self.scalr_config['instances_connection_policy'])
ip, port, proxy_headers = helper.get_szr_api_conn_info(server, instances_connection_policy)
headers.update(proxy_headers)
key = cryptotool.decrypt_key(server['scalarizr.key'])
api_type = server['os_type']
metrics = server['metrics']
timeout = self.config['instances_connection_timeout']
return szr_api.get_metrics(
ip, port, key, api_type, metrics, headers=headers, timeout=timeout)
def _encrypt(self, server_id, crypto_key, data, headers=None):
assert server_id, 'server_id'
assert crypto_key, 'scalarizr.key'
assert data, 'data to encrypt'
crypto_algo = dict(name="des_ede3_cbc", key_size=24, iv_size=8)
data = cryptotool.encrypt_scalarizr(crypto_algo, data,
cryptotool.decrypt_key(crypto_key))
headers = headers or dict()
headers['X-Signature'], headers['Date'] = cryptotool.sign(
data, crypto_key)
headers['X-Server-Id'] = server_id
msg = "Server: {0}, key: {1} ... {2}".format(server_id,
crypto_key[0:5],
crypto_key[-5:])
LOG.debug(msg)
return data, headers
def answer(environ, start_response):
try:
server_id = environ['HTTP_X_SERVER_ID']
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
security = rpc.Security(cryptotool.decrypt_key(crypto_key))
data = json.loads(security.decrypt_data(environ['wsgi.input'].readline()))
server = lib.world.servers[server_id]
assert 'params' in data
assert 'method' in data
assert 'id' in data, 'id'
if data['method'] == 'status':
assert 'cached' in data['params'], 'cached'
repos = {
'latest': {
'linux': 'http://apt.scalr.net/debian scalr/',
'windows': 'http://win.scalr.net',
},
'stable': {
'linux': 'http://apt-delayed.scalr.net/debian scalr/',
'windows': 'http://win-delayed.scalr.net',
}
}
status = {
'server_id': server_id,
'repository': 'stable',
'repo_url': repos['stable'][server['os_type']],
'executed_at': 'Mon 22 Sep 2014 12:00:00 UTC',
'state': '',
'error': '',
}
answer = {'result': status}
elif data['method'] == 'update':
answer = {'result': 777}
lib.update_ok[server_id] = True
else:
assert False, 'method'
response = security.encrypt_data(json.dumps(answer))
start_response('201 OK', [('Content-Type', 'text/html')])
yield response
except:
yield str(sys.exc_info())
def get(host=None, port=None, key=None, os_type=None, metrics=None, proxy=None):
assert (host or proxy) and port and key and os_type and metrics
if proxy:
host = proxy['host']
port = proxy['port']
headers = proxy['headers']
else:
headers = None
endpoint = 'http://%s:%s' % (host, port)
security = rpc.Security(cryptotool.decrypt_key(key))
hsp = rpc.HttpServiceProxy(endpoint, security=security, headers=headers)
data = dict()
if 'cpu' in metrics:
try:
data.update(ScalarizrAPI._get_cpu_stat(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api CPU failed: %s'
% (host, port, helper.exc_info()))
if 'la' in metrics:
try:
data.update(ScalarizrAPI._get_la_stat(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api LA failed: %s'
% (host, port, helper.exc_info()))
if 'mem' in metrics:
try:
data.update(ScalarizrAPI._get_mem_info(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api MEM failed: %s'
% (host, port, helper.exc_info()))
if 'net' in metrics:
try:
data.update(ScalarizrAPI._get_net_stat(hsp, os_type))
except Exception as e:
if type(e) in (urllib2.URLError, socket.timeout): raise e
LOG.warning('%s:%s scalarizr api NET failed: %s'
% (host, port, helper.exc_info()))
return data
def answer(environ, start_response):
server_id = environ['HTTP_X_SERVER_ID']
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
security = rpc.Security(cryptotool.decrypt_key(crypto_key))
data = json.loads(security.decrypt_data(environ['wsgi.input'].readline()))
responses = {
'cpu_stat': {
'user': 10,
'nice': 10,
'system': 10,
'idle': 10,
},
'load_average': [
1,
1,
1,
],
'mem_info': {
'total_swap': 1024,
'avail_swap': 1024,
'total_real': 1024,
'total_free': 1024,
'shared': 1024,
'buffer': 1024,
'cached': 1024,
},
'net_stats': {
'eth0': {
'receive': {
'bytes': 1024,
'packets': 1024,
'errors': 0,
},
'transmit': {
'bytes': 1024,
'packets': 1024,
'errors': 0,
},
},
},
'disk_stats': {
'sda1': {
'read': {
'num': 10,
'sectors': 10,
'bytes': 10,
},
'write': {
'num': 10,
'sectors': 10,
'bytes': 10,
},
},
},
}
result = {'result': responses[data['method']]}
response = security.encrypt_data(json.dumps(result))
start_response('201 OK', [('Content-Type', 'text/html')])
yield response
def answer(environ, start_response):
server_id = environ['HTTP_X_SERVER_ID']
crypto_key = lib.world.server_properties[server_id]['scalarizr.key']
security = rpc.Security(cryptotool.decrypt_key(crypto_key))
data = json.loads(security.decrypt_data(environ['wsgi.input'].readline()))
responses = {
'cpu_stat': {
'user': 10,
'nice': 10,
'system': 10,
'idle': 10,
},
'load_average': [
1,
1,
1,
],
'mem_info': {
'total_swap': 1024,
'avail_swap': 1024,
'total_real': 1024,
'total_free': 1024,
'shared': 1024,
'buffer': 1024,
'cached': 1024,
},
'net_stats': {
'eth0': {
'receive': {
'bytes': 1024,
'packets': 1024,
'errors': 0,
},
'transmit': {
'bytes': 1024,
'packets': 1024,
'errors': 0,
},
},
},
'disk_stats': {
'sda1': {
'read': {
'num': 10,
'sectors': 10,
'bytes': 10,
},
'write': {
'num': 10,
'sectors': 10,
'bytes': 10,
},
},
},
}
result = {'result': responses[data['method']]}
response = security.encrypt_data(json.dumps(result))
start_response('201 OK', [('Content-Type', 'text/html')])
yield response
