def check_heal(nodes_to_monitor, depl_id):
if cooldown():
print('Exiting...\n')
exit(0)
c = CloudifyClient('localhost')
c_influx = InfluxDBClient(host='localhost', port=8086, database='cloudify')
f = open('/home/ubuntu/logfile', 'w')
f.write('in check heal\n')
c = CloudifyClient('localhost')
# compare influx data (monitoring) to cloudify desired state
for node_name in nodes_to_monitor:
instances = c.node_instances.list(depl_id, node_name)
# f.write('instances{0}\n'.format(instances))
for instance in instances:
q_string='SELECT MEAN(value) FROM /' + depl_id + '\.' + node_name + '\.' + instance.id + '\.cpu_total_system/ GROUP BY time(10s) '\
'WHERE time > now() - 40s'
f.write('query string is{0}\n'.format(q_string))
try:
result = c_influx.query(q_string)
f.write('result is {0} \n'.format(result))
if not result:
open('/home/ubuntu/cooldown', 'a').close()
utime('/home/ubuntu/cooldown', None)
execution_id = c.executions.start(depl_id, 'heal',
{'node_id': instance.id})
except InfluxDBClientError as ee:
f.write('DBClienterror {0}\n'.format(str(ee)))
f.write('instance id is {0}\n'.format(instance))
except Exception as e:
f.write(str(e))
def create_client(self, headers=None):
client = CloudifyClient(host='localhost',
headers=headers)
mock_http_client = MockHTTPClient(self.app,
headers=headers,
file_server=self.file_server)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
client.events.api = mock_http_client
# only exists in v2 and above
if CLIENT_API_VERSION != 'v1':
client.plugins.api = mock_http_client
client.snapshots.api = mock_http_client
# only exists in v2.1 and above
if CLIENT_API_VERSION != 'v2':
client.maintenance_mode.api = mock_http_client
client.deployment_updates.api = mock_http_client
return client
def create_client(self, headers=None):
client = CloudifyClient(host='localhost', headers=headers)
mock_http_client = MockHTTPClient(self.app, headers=headers)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
client.events.api = mock_http_client
# only exists in v2 and above
if CLIENT_API_VERSION != 'v1':
client.plugins.api = mock_http_client
client.snapshots.api = mock_http_client
# only exists in v2.1 and above
if CLIENT_API_VERSION != 'v2':
client.maintenance_mode.api = mock_http_client
client.deployment_updates.api = mock_http_client
return client
def create_client(cls, headers=None, app=None):
if app is None:
app = cls.app
client = CloudifyClient(host='localhost', headers=headers)
mock_http_client = MockHTTPClient(app,
headers=headers,
root_path=cls.tmpdir)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
client.events.api = mock_http_client
# only exists in v2 and above
if CLIENT_API_VERSION != 'v1':
client.plugins.api = mock_http_client
client.snapshots.api = mock_http_client
# only exists in v2.1 and above
if CLIENT_API_VERSION != 'v2':
client.maintenance_mode.api = mock_http_client
client.deployment_updates.api = mock_http_client
# only exists in v3 and above
if CLIENT_API_VERSION != 'v2.1':
client.tenants.api = mock_http_client
client.user_groups.api = mock_http_client
client.users.api = mock_http_client
client.ldap.api = mock_http_client
client.secrets.api = mock_http_client
# only exists in v3.1 and above
if CLIENT_API_VERSION != 'v3':
client.deployments.capabilities.api = mock_http_client
client.agents.api = mock_http_client
client.tasks_graphs.api = mock_http_client
client.operations.api = mock_http_client
client.plugins_update.api = mock_http_client
client.sites.api = mock_http_client
client.inter_deployment_dependencies.api = \
mock_http_client
client.deployments_labels.api = mock_http_client
client.blueprints_filters.api = mock_http_client
client.deployments_filters.api = mock_http_client
client.deployment_groups.api = mock_http_client
client.execution_groups.api = mock_http_client
client.execution_schedules.api = mock_http_client
client.blueprints_labels.api = mock_http_client
client.workflows.api = mock_http_client
return client
def setUp(self):
super(CliCommandTest, self).setUp()
logdir = os.path.dirname(env.DEFAULT_LOG_FILE)
env.profile = env.ProfileContext()
cfy.invoke('init -r')
# create log folder
if not os.path.exists(logdir):
os.makedirs(logdir)
self.client = CloudifyClient()
def get_mock_rest_client(*args, **kwargs):
if 'tenant_name' in kwargs:
self.client._client.headers[CLOUDIFY_TENANT_HEADER] = \
kwargs['tenant_name']
return self.client
self.original_utils_get_rest_client = env.get_rest_client
env.get_rest_client = get_mock_rest_client
self.original_utils_get_cwd = utils.get_cwd
utils.get_cwd = lambda: env.CLOUDIFY_WORKDIR
self.original_utils_os_getcwd = utils_os.getcwd
utils_os.getcwd = lambda: env.CLOUDIFY_WORKDIR
# reset in case a test set it
set_global_json_output(False)
def get_rest_client(rest_host,
rest_port,
rest_token,
rest_tenant,
ssl_cert_path,
bypass_maintenance_mode=False):
headers = {}
if bypass_maintenance_mode:
headers['X-BYPASS-MAINTENANCE'] = 'true'
for value, name in [(rest_token, 'auth token'),
(rest_tenant, 'tenant'),
(ssl_cert_path, 'SSL Cert path')]:
assert value, 'REST {0} is missing! It is required to ' \
'create a REST client for a secured ' \
'manager [{1}]'.format(name, rest_host)
return CloudifyClient(
host=rest_host,
protocol=SECURED_PROTOCOL,
port=rest_port,
headers=headers,
token=rest_token,
tenant=rest_tenant,
cert=ssl_cert_path
)
def create_rest_client(**kwargs):
# Doing it with kwargs instead of arguments with default values to allow
# not passing args (which will then use the default values), or explicitly
# passing None (or False) which will then be passed as-is to the Client
username = kwargs.get('username', get_manager_username())
password = kwargs.get('password', get_manager_password())
tenant = kwargs.get('tenant', get_manager_tenant())
token = kwargs.get('token')
rest_port = kwargs.get('rest_port',
os.environ.get(constants.CLOUDIFY_REST_PORT, 80))
rest_protocol = kwargs.get('rest_protocol',
'https' if rest_port == '443' else 'http')
cert_path = kwargs.get('cert_path', cli_env.get_ssl_cert())
trust_all = kwargs.get('trust_all', cli_env.get_ssl_trust_all())
headers = create_auth_header(username, password, token, tenant)
return CloudifyClient(
host=get_manager_ip(),
port=rest_port,
protocol=rest_protocol,
headers=headers,
trust_all=trust_all,
cert=cert_path)
def check_replationship(deployment):
client = CloudifyClient('185.98.149.80')
depl_id = client.deployments.get(deployment).id
print('<<< Deployment : ' + depl_id + ' >>>\n')
deployment_nodes = client.nodes.list(deployment_id=depl_id)
for node in deployment_nodes:
print('## node : ' + node.id + ' ##')
# if 'FortinetFireWall' in node.id:
instances = client.node_instances.list(deployment_id=depl_id,
node_name=node.id)
for instance in instances:
print('<< instance id : ' + instance.id + ' >>')
for relationship in instance.relationships:
# if 'connected_to_port' in relationship.get('type'):
print 'Node relationship --> ',
print relationship.get('target_name'), relationship.get(
'target_id'), '\n'
getTargetProps(client, depl_id, relationship.get('target_id'))
def __init__(self, port, file_server_dir, file_server_base_uri,
file_server_blueprints_folder, file_server_deployments_folder,
file_server_uploaded_blueprints_folder,
file_server_resources_uri, rest_service_log_level,
rest_service_log_path, rest_service_log_file_size_MB,
rest_service_log_files_backup_count, securest_log_level,
securest_log_file, securest_log_file_size_MB,
securest_log_files_backup_count, tempdir, amqp_username,
amqp_password, maintenance_folder):
self.process = None
self.port = port or MANAGER_REST_PORT
self.file_server_dir = file_server_dir
self.file_server_base_uri = file_server_base_uri
self.file_server_blueprints_folder = file_server_blueprints_folder
self.file_server_deployments_folder = file_server_deployments_folder
self.file_server_uploaded_blueprints_folder = \
file_server_uploaded_blueprints_folder
self.file_server_resources_uri = file_server_resources_uri
self.rest_service_log_level = rest_service_log_level
self.rest_service_log_path = rest_service_log_path
self.rest_service_log_file_size_MB = rest_service_log_file_size_MB
self.rest_service_log_files_backup_count = \
rest_service_log_files_backup_count
self.securest_log_level = securest_log_level
self.securest_log_file = securest_log_file
self.securest_log_file_size_MB = securest_log_file_size_MB
self.securest_log_files_backup_count = securest_log_files_backup_count
self.client = CloudifyClient('localhost', port=port)
self.tempdir = tempdir
self.amqp_username = amqp_username
self.amqp_password = amqp_password
self.maintenance_folder = maintenance_folder
def execute(self):
"""
Deploy Cloudify Manager.
"""
scpc = scp.SCPClient(self.ssh.get_transport())
scpc.put(self.cloudify_archive,
remote_path=os.path.basename(self.cloudify_archive))
(_, stdout, stderr) = self.ssh.exec_command(
"sudo wget https://get.docker.com/ -O script.sh && "
"sudo chmod +x script.sh && "
"sudo ./script.sh && "
"sudo docker load -i ~/{} && "
"sudo docker run --name cfy_manager_local -d "
"--restart unless-stopped -v /sys/fs/cgroup:/sys/fs/cgroup:ro "
"--tmpfs /run --tmpfs /run/lock --security-opt seccomp:unconfined "
"--cap-add SYS_ADMIN --network=host {}".format(
os.path.basename(self.cloudify_archive),
self.cloudify_container))
self.__logger.debug("output:\n%s", stdout.read().decode("utf-8"))
self.__logger.debug("error:\n%s", stderr.read().decode("utf-8"))
self.cfy_client = CloudifyClient(
host=self.fip.floating_ip_address if self.fip else
(self.sshvm.public_v4),
username='******',
password='******',
tenant='default_tenant')
self.__logger.info("Attemps running status of the Manager")
secret_key = "foo"
secret_value = "bar"
for loop in range(20):
try:
self.__logger.debug("status %s",
self.cfy_client.manager.get_status())
cfy_status = self.cfy_client.manager.get_status()['status']
self.__logger.info("The current manager status is %s",
cfy_status)
if str(cfy_status) != 'running':
raise Exception("Cloudify Manager isn't up and running")
for secret in iter(self.cfy_client.secrets.list()):
if secret_key == secret["key"]:
self.__logger.debug("Updating secrets: %s", secret_key)
self.cfy_client.secrets.update(secret_key,
secret_value)
break
else:
self.__logger.debug("Creating secrets: %s", secret_key)
self.cfy_client.secrets.create(secret_key, secret_value)
self.cfy_client.secrets.delete(secret_key)
self.__logger.info("Secrets API successfully reached")
break
except Exception: # pylint: disable=broad-except
self.__logger.debug(
"try %s: Cloudify Manager isn't up and running \n%s",
loop + 1, traceback.format_exc())
time.sleep(30)
else:
self.__logger.error("Cloudify Manager isn't up and running")
return 1
self.__logger.info("Cloudify Manager is up and running")
return 0
def get_rest_client():
"""
:returns: A REST client configured to connect to the manager in context
:rtype: cloudify_rest_client.CloudifyClient
"""
return CloudifyClient(utils.get_manager_ip(),
utils.get_manager_rest_service_port())
def create_client(self, headers=None):
client = CloudifyClient(host="localhost", headers=headers)
mock_http_client = MockHTTPClient(self.app, headers=headers)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
return client
def dep_list(host, tenant, user, password, ssl, cert, **kwargs):
cm_client = CloudifyClient(host=host,
tenant=tenant,
username=user,
password=password,
protocol=SECURED_PROTOCOL if ssl else DEFAULT_PROTOCOL,
cert=cert)
report = {}
offset = 0
while True:
all_node_instances = cm_client.node_instances.list(_size=1000, _offset=offset)
ni_count = len(all_node_instances)
if not ni_count:
break
for node_instance in all_node_instances:
dep_report = report.get(node_instance.deployment_id)
if dep_report is None:
dep_report = {'node_instances': list()}
report[node_instance.deployment_id] = dep_report
dep_node_instances = dep_report['node_instances']
dep_node_instances.append(node_instance.id)
offset += ni_count
print(json.dumps(report, indent=True))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--username', type=str, required=True)
parser.add_argument('-p', '--password', type=str, required=True)
parser.add_argument('--ssl', default=False, action='store_true')
subparsers = parser.add_subparsers()
config_parser = subparsers.add_parser('config')
config_parser.add_argument('-c', '--config', type=str, required=True)
config_parser.add_argument('-i',
'--iaas',
type=str,
required=True,
choices=['aws', 'azure', 'openstack'])
debug_parser = subparsers.add_parser('debug')
debug_parser.add_argument('--print-agent-env',
default=True,
action='store_true')
kwargs = parser.parse_args()
cfy_client = CloudifyClient(username=kwargs.username,
password=kwargs.password,
trust_all=kwargs.ssl,
tenant='default_tenant',
host='localhost',
port=(443 if kwargs.ssl else 80),
protocol=('https' if kwargs.ssl else 'http'))
if 'print_agent_env' in kwargs:
print_agent_env(cfy_client)
else:
configure_manager(cfy_client, kwargs.iaas, kwargs.config)
def execute(self):
"""
Deploy Cloudify Manager.
"""
self.cfy_client = CloudifyClient(host=self.fip.floating_ip_address,
username='******',
password='******',
tenant='default_tenant',
api_version='v3')
self.__logger.info("Attemps running status of the Manager")
for loop in range(10):
try:
self.__logger.debug("status %s",
self.cfy_client.manager.get_status())
cfy_status = self.cfy_client.manager.get_status()['status']
self.__logger.info("The current manager status is %s",
cfy_status)
if str(cfy_status) != 'running':
raise Exception("Cloudify Manager isn't up and running")
self.cfy_client.secrets.create("foo", "bar")
self.__logger.debug("List secrets: %s",
self.cfy_client.secrets.list())
self.cfy_client.secrets.delete("foo")
self.__logger.info("Secrets API successfully reached")
break
except Exception: # pylint: disable=broad-except
self.__logger.info(
"try %s: Cloudify Manager isn't up and running", loop + 1)
time.sleep(30)
else:
self.__logger.error("Cloudify Manager isn't up and running")
return 1
self.__logger.info("Cloudify Manager is up and running")
return 0
def _get_client():
# Configure Cloudify endpoint from configuration file
config = configparser.RawConfigParser()
config_file = str(os.path.dirname(os.path.realpath(__file__))) + '/cfi.cfg'
print('Reading Cloudify configuration from file {file}'.format(
file=config_file))
config.read(config_file)
client = None
try:
cloudify_server = config.get('Cloudify', 'host')
cloudify_username = config.get('Cloudify', 'username')
cloudify_password = config.get('Cloudify', 'password')
cloudify_tenant = config.get('Cloudify', 'tenant')
cloudify_protocol = config.get('Cloudify', 'protocol')
client = CloudifyClient(host=cloudify_server,
username=cloudify_username,
password=cloudify_password,
tenant=cloudify_tenant,
protocol=cloudify_protocol,
trust_all=True)
except configparser.NoSectionError:
pass
return client
def get_rest_client(manager_ip=None, rest_port=None, protocol=None):
if not manager_ip:
manager_ip = get_management_server_ip()
if not rest_port:
rest_port = get_rest_port()
if not protocol:
protocol = get_protocol()
username = get_username()
password = get_password()
headers = get_auth_header(username, password)
cert = get_ssl_cert()
trust_all = get_ssl_trust_all()
return CloudifyClient(host=manager_ip,
port=rest_port,
protocol=protocol,
headers=headers,
cert=cert,
trust_all=trust_all)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--username', type=str, required=True)
parser.add_argument('-p', '--password', type=str, required=True)
parser.add_argument('--ssl', default=False, action='store_true')
subparsers = parser.add_subparsers()
config_parser = subparsers.add_parser('config')
config_parser.add_argument('-c', '--config', type=str, required=True)
config_parser.add_argument('-i',
'--iaas',
type=str,
required=True,
choices=['aws', 'azure', 'openstack'])
debug_parser = subparsers.add_parser('debug')
debug_parser.add_argument('--print-agent-env',
default=True,
action='store_true')
kwargs = parser.parse_args()
headers = {'Authorization': 'Basic ' + base64_encode('{user}:{password}'.format(user=kwargs.username,password=kwargs.password))}
cfy_client = CloudifyClient(host='localhost', port=443, protocol='https', headers=headers, trust_all=True)
if 'print_agent_env' in kwargs:
print_agent_env(cfy_client)
else:
configure_manager(cfy_client,
kwargs.iaas,
kwargs.config)
def create_client(cls, headers=None):
client = CloudifyClient(host='localhost',
headers=headers)
mock_http_client = MockHTTPClient(cls.app,
headers=headers,
file_server=cls.file_server)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
client.events.api = mock_http_client
# only exists in v2 and above
if CLIENT_API_VERSION != 'v1':
client.plugins.api = mock_http_client
client.snapshots.api = mock_http_client
# only exists in v2.1 and above
if CLIENT_API_VERSION != 'v2':
client.maintenance_mode.api = mock_http_client
client.deployment_updates.api = mock_http_client
# only exists in v3 and above
if CLIENT_API_VERSION != 'v2.1':
client.tenants.api = mock_http_client
client.user_groups.api = mock_http_client
client.users.api = mock_http_client
client.ldap.api = mock_http_client
client.secrets.api = mock_http_client
# only exists in v3.1 and above
if CLIENT_API_VERSION != 'v3':
client.deployments.capabilities.api = mock_http_client
client.agents.api = mock_http_client
client.tasks_graphs.api = mock_http_client
client.operations.api = mock_http_client
client.plugins_update.api = mock_http_client
client.sites.api = mock_http_client
return client
def check_liveness(nodes_to_monitor, depl_id):
c = CloudifyClient('localhost')
c_influx = InfluxDBClient(host='localhost', port=8086, database='cloudify')
print('in check_liveness\n')
print('nodes_to_monitor: {0}\n'.format(nodes_to_monitor))
c = CloudifyClient('localhost')
# compare influx data (monitoring) to cloudify desired state
for node_name in nodes_to_monitor:
instances = c.node_instances.list(depl_id, node_name)
for instance in instances:
q_string='SELECT MEAN(value) FROM /' + depl_id + '\.' + node_name + '\.' + instance.id + '\.cpu_total_system/ GROUP BY time(10s) '\
'WHERE time > now() - 40s'
print('query string is {0}\n'.format(q_string))
try:
result = c_influx.query(q_string)
print('result is {0} \n'.format(result))
if not result:
executions = c.executions.list(depl_id)
has_pending_execution = False
if executions and len(executions) > 0:
for execution in executions:
# print("Execution {0} : {1}".format(execution.id, execution.status))
if execution.status not in execution.END_STATES:
has_pending_execution = True
if not has_pending_execution:
print(
'Setting state to error for instance {0} and its children'
.format(instance.id))
update_nodes_tree_state(c, depl_id, instance, 'error')
params = {'node_instance_id': instance.id}
print(
'Calling Auto-healing workflow for container instance {0}'
.format(instance.id))
c.executions.start(depl_id, 'a4c_heal', params)
else:
print(
'pendding executions on the deployment...waiting for their end before calling heal workfllow...'
)
except InfluxDBClientError as ee:
print('DBClienterror {0}\n'.format(str(ee)))
print('instance id is {0}\n'.format(instance))
except Exception as e:
print(str(e))
def create_client(self, headers=None):
client = CloudifyClient(host='localhost', headers=headers)
mock_http_client = MockHTTPClient(self.app,
headers=headers,
file_server=self.file_server)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
client.events.api = mock_http_client
# only exists in v2 and above
if CLIENT_API_VERSION != 'v1':
client.plugins.api = mock_http_client
client.snapshots.api = mock_http_client
# only exists in v2.1 and above
if CLIENT_API_VERSION != 'v2':
client.maintenance_mode.api = mock_http_client
client.deployment_updates.api = mock_http_client
# only exists in v3 and above
if CLIENT_API_VERSION != 'v2.1':
client.tenants.api = mock_http_client
client.user_groups.api = mock_http_client
client.users.api = mock_http_client
client.ldap.api = mock_http_client
client.secrets.api = mock_http_client
if CLIENT_API_VERSION != 'v3':
# support for ARIA was only added in V3.1
client.aria_service_templates.api = mock_http_client
client.aria_services.api = mock_http_client
client.aria_node_templates.api = mock_http_client
client.aria_nodes.api = mock_http_client
client.aria_executions.api = mock_http_client
client.aria_logs.api = mock_http_client
client.aria_plugins.api = mock_http_client
return client
def create_client(cls, headers=None):
client = CloudifyClient(host='localhost',
headers=headers)
mock_http_client = MockHTTPClient(cls.app,
headers=headers,
file_server=cls.file_server)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
client.events.api = mock_http_client
# only exists in v2 and above
if CLIENT_API_VERSION != 'v1':
client.plugins.api = mock_http_client
client.snapshots.api = mock_http_client
# only exists in v2.1 and above
if CLIENT_API_VERSION != 'v2':
client.maintenance_mode.api = mock_http_client
client.deployment_updates.api = mock_http_client
# only exists in v3 and above
if CLIENT_API_VERSION != 'v2.1':
client.tenants.api = mock_http_client
client.user_groups.api = mock_http_client
client.users.api = mock_http_client
client.ldap.api = mock_http_client
client.secrets.api = mock_http_client
# only exists in v3.1 and above
if CLIENT_API_VERSION != 'v3':
client.deployments.capabilities.api = mock_http_client
client.agents.api = mock_http_client
client.tasks_graphs.api = mock_http_client
client.operations.api = mock_http_client
client.sites.api = mock_http_client
return client
def test_use_with_verify(self):
host = 'localhost'
self.client = CloudifyClient(host=host, protocol='https')
self._test_use()
self.assertEqual(
self.request_url,
'https://{0}:{1}/api/{2}/status'.format(host, SSL_PORT,
API_VERSION))
self.assertTrue(self.verify)
def get_DashboardId():
host = parse_args(
'/Users/wecash/PycharmProjects/datasort/setting.conf') #读取配置文件
client = CloudifyClient(host)
blueprints = client.blueprints.list()
blueprints_list = []
for blueprint in blueprints:
blueprints_list.append(blueprint.id)
return blueprints_list
def get_rest_client(manager_ip=None, rest_port=None):
if not manager_ip:
manager_ip = get_management_server_ip()
if not rest_port:
rest_port = get_rest_port()
return CloudifyClient(manager_ip, rest_port)
def bootstrap(self):
self.cfy.bootstrap(blueprint_path=self.test_manager_blueprint_path,
inputs_file=self.test_inputs_path,
task_retries=5,
install_plugins=self.env.install_plugins)
# override the client instance to use the correct ip
self.client = CloudifyClient(self.cfy.get_management_ip())
self.addCleanup(self.cfy.teardown)
def test_use_with_authorization(self):
host = '127.0.0.1'
auth_header = utils.get_auth_header('test_username', 'test_password')
self.client = CloudifyClient(host=host, headers=auth_header)
self._test_use()
# assert Authorization in headers
eventual_request_headers = self.client._client.headers
self.assertEqual(self.do_request_headers, eventual_request_headers)
def test_use_trust_all(self):
host = 'localhost'
self.client = CloudifyClient(host=host,
protocol='https',
trust_all=True)
self._test_use()
self.assertEqual(
self.request_url,
'https://{0}:{1}/api/{2}/status'.format(host, SSL_PORT,
constants.API_VERSION))
self.assertFalse(self.verify)
def check_deployments(current_deployment_id, allowed_days, allowed_hours):
try:
cloudify_client = CloudifyClient('localhost')
blueprint_id = "sfsdfdxxxx"
deployment_inputs = {"xxx": "yyyxxx", "zzzxxx": "wwwxxx"}
child_deployment = cloudify_client.deployments.create(
blueprint_id, current_deployment_id, inputs=deployment_inputs)
cloudify_client.executions.start(current_deployment_id, 'install')
except Exception as e:
print str(e)
def _get_cloudify_http_client(self, host):
if self._ca_cert_valid:
return CloudifyClient(host=host,
username=self._cloudify_user_name,
headers={CLOUDIFY_API_AUTH_TOKEN_HEADER:
self._token},
cert=CA_DEFAULT_PATH,
tenant='default_tenant',
port=INTERNAL_REST_PORT,
protocol=SECURED_PROTOCOL,
timeout=self._request_timeout
)
else:
return CloudifyClient(host=host,
username=self._cloudify_user_name,
tenant='default_tenant',
port=DEFAULT_PORT,
protocol=DEFAULT_PROTOCOL,
timeout=self._request_timeout
)
def create_client(self, api_version=DEFAULT_API_VERSION, headers=None):
client = CloudifyClient(host='localhost',
api_version=api_version,
headers=headers)
mock_http_client = MockHTTPClient(self.app,
api_version=api_version,
headers=headers)
client._client = mock_http_client
client.blueprints.api = mock_http_client
client.deployments.api = mock_http_client
client.deployments.outputs.api = mock_http_client
client.deployment_modifications.api = mock_http_client
client.executions.api = mock_http_client
client.nodes.api = mock_http_client
client.node_instances.api = mock_http_client
client.manager.api = mock_http_client
client.evaluate.api = mock_http_client
client.tokens.api = mock_http_client
return client
def create_rest_client(
manager_ip,
username=None,
password=None,
tenant=None,
**kwargs):
return CloudifyClient(
host=manager_ip,
username=username or cli_env.get_username(),
password=password or cli_env.get_password(),
tenant=tenant or cli_env.get_tenant_name(),
**kwargs)
def get_rest_client(client_profile=None,
rest_host=None,
rest_port=None,
rest_protocol=None,
rest_cert=None,
username=None,
password=None,
tenant_name=None,
trust_all=False,
cluster=None,
kerberos_env=None):
if client_profile is None:
client_profile = profile
rest_host = rest_host or client_profile.manager_ip
rest_port = rest_port or client_profile.rest_port
rest_protocol = rest_protocol or client_profile.rest_protocol
rest_cert = rest_cert or get_ssl_cert(client_profile)
username = username or get_username(client_profile)
password = password or get_password(client_profile)
tenant_name = tenant_name or get_tenant_name(client_profile)
trust_all = trust_all or get_ssl_trust_all()
headers = get_auth_header(username, password)
headers[constants.CLOUDIFY_TENANT_HEADER] = tenant_name
cluster = cluster or is_cluster(client_profile)
kerberos_env = kerberos_env \
if kerberos_env is not None else client_profile.kerberos_env
if kerberos_env is False \
or (kerberos_env is None and not is_kerberos_env()):
if not username:
raise CloudifyCliError('Command failed: Missing Username')
if not password:
raise CloudifyCliError('Command failed: Missing password')
if cluster:
client = CloudifyClusterClient(host=rest_host,
port=rest_port,
protocol=rest_protocol,
headers=headers,
cert=rest_cert,
trust_all=trust_all,
profile=client_profile,
kerberos_env=kerberos_env)
else:
client = CloudifyClient(host=rest_host,
port=rest_port,
protocol=rest_protocol,
headers=headers,
cert=rest_cert,
trust_all=trust_all,
kerberos_env=kerberos_env)
return client
def check_blueprints(allowed_seconds):
cloudify_client = CloudifyClient('localhost')
for blueprint in cloudify_client.blueprints.list():
deployment_list = cloudify_client.deployments.list(
blueprint_id=blueprint.id)
if deployment_list is None or len(deployment_list) == 0:
print "There are no deployments for blueprint {0}".format(
blueprint.id)
time_diff = get_time_diff(blueprint.created_at)
seconds_diff = time_diff.total_seconds()
if allowed_seconds < seconds_diff:
print "Deleting blueprint {0} ...".format(blueprint.id)
cloudify_client.blueprints.delete(blueprint.id)
