def action_create(self):
path = self.resource.path
if sudo.path_lexists(path):
oldpath = os.path.realpath(path)
if oldpath == self.resource.to:
return
if not sudo.path_lexists(path):
raise Fail(
"%s trying to create a symlink with the same name as an existing file or directory" % self.resource)
Logger.info("%s replacing old symlink to %s" % (self.resource, oldpath))
sudo.unlink(path)
if self.resource.hard:
if not sudo.path_exists(self.resource.to):
raise Fail("Failed to apply %s, linking to nonexistent location %s" % (self.resource, self.resource.to))
if sudo.path_isdir(self.resource.to):
raise Fail("Failed to apply %s, cannot create hard link to a directory (%s)" % (self.resource, self.resource.to))
Logger.info("Creating hard %s" % self.resource)
sudo.link(self.resource.to, path)
else:
if not sudo.path_exists(self.resource.to):
Logger.info("Warning: linking to nonexistent location %s" % self.resource.to)
Logger.info("Creating symbolic %s to %s" % (self.resource, self.resource.to))
sudo.symlink(self.resource.to, path)
def action_create(self):
path = self.resource.path
if sudo.path_isdir(path):
raise Fail("Applying %s failed, directory with name %s exists" % (self.resource, path))
dirname = os.path.dirname(path)
if not sudo.path_isdir(dirname):
raise Fail("Applying %s failed, parent directory %s doesn't exist" % (self.resource, dirname))
write = False
content = self._get_content()
if not sudo.path_exists(path):
write = True
reason = "it doesn't exist"
elif self.resource.replace:
if content is not None:
old_content = sudo.read_file(path, encoding=self.resource.encoding)
if content != old_content:
write = True
reason = "contents don't match"
if self.resource.backup:
self.resource.env.backup_file(path)
if write:
Logger.info("Writing %s because %s" % (self.resource, reason))
sudo.create_file(path, content, encoding=self.resource.encoding)
_ensure_metadata(self.resource.path, self.resource.owner,
self.resource.group, mode=self.resource.mode, cd_access=self.resource.cd_access)
def action_create(self):
path = self.resource.path
if not sudo.path_exists(path):
Logger.info("Creating directory %s since it doesn't exist." % self.resource)
# dead links should be followed, else we gonna have failures on trying to create directories on top of them.
if self.resource.follow:
# Follow symlink until the tail.
followed_links = set()
while sudo.path_lexists(path):
if path in followed_links:
raise Fail("Applying %s failed, looped symbolic links found while resolving %s" % (self.resource, path))
followed_links.add(path)
path = sudo.readlink(path)
if path != self.resource.path:
Logger.info("Following the link {0} to {1} to create the directory".format(self.resource.path, path))
if self.resource.recursive:
sudo.makedirs(path, self.resource.mode or 0755)
else:
dirname = os.path.dirname(path)
if not sudo.path_isdir(dirname):
raise Fail("Applying %s failed, parent directory %s doesn't exist" % (self.resource, dirname))
sudo.makedir(path, self.resource.mode or 0755)
if not sudo.path_isdir(path):
raise Fail("Applying %s failed, file %s already exists" % (self.resource, path))
_ensure_metadata(path, self.resource.owner, self.resource.group,
mode=self.resource.mode, cd_access=self.resource.cd_access)
def run_command(self,
target,
operation,
method='POST',
assertable_result=True,
file_to_put=None,
ignore_status_codes=[],
**kwargs):
"""
assertable_result - some POST requests return '{"boolean":false}' or '{"boolean":true}'
depending on if query was successful or not, we can assert this for them
"""
target = self.parse_path(target)
url = format(
"{address}/webhdfs/v1{target}?op={operation}&user.name={run_user}",
address=self.address,
run_user=self.run_user)
for k, v in kwargs.iteritems():
url = format("{url}&{k}={v}")
if file_to_put and not os.path.exists(file_to_put):
raise Fail(format("File {file_to_put} is not found."))
cmd = ["curl", "-sS", "-L", "-w", "%{http_code}", "-X", method]
if file_to_put:
cmd += ["-T", file_to_put]
if self.security_enabled:
cmd += ["--negotiate", "-u", ":"]
if self.is_https_enabled:
cmd += ["-k"]
cmd.append(url)
_, out, err = shell.checked_call(cmd,
user=self.run_user,
logoutput=self.logoutput,
quiet=False,
stderr=subprocess.PIPE)
status_code = out[-3:]
out = out[:-3] # remove last line from output which is status code
try:
result_dict = json.loads(out)
except ValueError:
result_dict = out
if status_code not in WebHDFSUtil.valid_status_codes + ignore_status_codes or assertable_result and result_dict and not result_dict[
'boolean']:
formatted_output = json.dumps(result_dict, indent=2) if isinstance(
result_dict, dict) else result_dict
formatted_output = err + "\n" + formatted_output
err_msg = "Execution of '%s' returned status_code=%s. %s" % (
shell.string_cmd_from_args_list(cmd), status_code,
formatted_output)
raise Fail(err_msg)
return result_dict
def action_create(self):
path = self.resource.path
if not sudo.path_exists(path):
Logger.info("Creating directory %s since it doesn't exist." %
self.resource)
# dead links should be followed, else we gonna have failures on trying to create directories on top of them.
if self.resource.follow:
# Follow symlink until the tail.
followed_links = set()
while sudo.path_islink(path):
if path in followed_links:
raise Fail(
"Applying %s failed, looped symbolic links found while resolving %s"
% (self.resource, path))
followed_links.add(path)
path = sudo.readlink(path)
if path != self.resource.path:
Logger.info(
"Following the link {0} to {1} to create the directory"
.format(self.resource.path, path))
if self.resource.create_parents:
sudo.makedirs(path, self.resource.mode or 0755)
else:
dirname = os.path.dirname(path)
if not sudo.path_isdir(dirname):
raise Fail(
"Applying %s failed, parent directory %s doesn't exist"
% (self.resource, dirname))
try:
sudo.makedir(path, self.resource.mode or 0755)
except Exception as ex:
# race condition (somebody created the file before us)
if "File exists" in str(ex):
sudo.makedirs(path, self.resource.mode or 0755)
else:
raise
if not sudo.path_isdir(path):
raise Fail("Applying %s failed, file %s already exists" %
(self.resource, path))
_ensure_metadata(
path,
self.resource.owner,
self.resource.group,
mode=self.resource.mode,
cd_access=self.resource.cd_access,
recursive_ownership=self.resource.recursive_ownership,
recursive_mode_flags=self.resource.recursive_mode_flags,
recursion_follow_links=self.resource.recursion_follow_links,
safemode_folders=self.resource.safemode_folders)
def post_metrics_to_collector(ams_metrics_post_url,
metric_collector_host,
metric_collector_port,
metric_collector_https_enabled,
metric_json,
headers,
ca_certs,
tries=1,
connect_timeout=10):
for i in xrange(0, tries):
try:
Logger.info("Generated metrics for host %s :\n%s" %
(metric_collector_host, metric_json))
Logger.info("Connecting (POST) to %s:%s%s" %
(metric_collector_host, metric_collector_port,
ams_metrics_post_url))
conn = network.get_http_connection(
metric_collector_host,
int(metric_collector_port),
metric_collector_https_enabled,
ca_certs,
ssl_version=Script.get_force_https_protocol_value())
conn.request("POST", ams_metrics_post_url, metric_json, headers)
response = conn.getresponse()
Logger.info(
"Http response for host %s: %s %s" %
(metric_collector_host, response.status, response.reason))
except (httplib.HTTPException, socket.error) as ex:
if i < tries - 1: #range/xrange returns items from start to end-1
time.sleep(connect_timeout)
Logger.info(
"Connection failed for host %s. Next retry in %s seconds."
% (metric_collector_host, connect_timeout))
continue
else:
raise Fail("Metrics were not saved. Connection failed.")
data = response.read()
Logger.info("Http data: %s" % data)
conn.close()
if response.status == 200:
Logger.info("Metrics were saved.")
break
else:
Logger.info("Metrics were not saved.")
if i < tries - 1: #range/xrange returns items from start to end-1
time.sleep(tries)
Logger.info("Next retry in %s seconds." % (tries))
else:
raise Fail(
"Metrics were not saved. POST request status: %s %s \n%s" %
(response.status, response.reason, data))
def _set_file_acl(file, user, rights):
acls_modify_cmd = "icacls {0} /grant {1}:{2}".format(file, user, rights)
acls_remove_cmd = "icacls {0} /remove {1}".format(file, user)
code, out, err = _call_command(acls_remove_cmd)
if code != 0:
raise Fail("Can not remove rights for path {0} and user {1}".format(file, user))
code, out, err = _call_command(acls_modify_cmd)
if code != 0:
raise Fail("Can not set rights {0} for path {1} and user {2}".format(rights, file, user))
else:
return
def _coerce_uid(user):
try:
uid = int(user)
except ValueError:
if not IS_WINDOWS:
try:
uid = pwd.getpwnam(user).pw_uid
except KeyError:
raise Fail("User %s doesn't exist." % user)
else:
raise Fail("User %s doesn't exist." % user)
return uid
def _coerce_gid(group):
try:
gid = int(group)
except ValueError:
if not IS_WINDOWS:
try:
gid = grp.getgrnam(group).gr_gid
except KeyError:
raise Fail("Group %s doesn't exist." % group)
else:
raise Fail("User %s doesn't exist." % user)
return gid
def _run_command(self, target, operation, method='POST', assertable_result=True, file_to_put=None, ignore_status_codes=[], **kwargs):
"""
assertable_result - some POST requests return '{"boolean":false}' or '{"boolean":true}'
depending on if query was successful or not, we can assert this for them
"""
target = HdfsResourceProvider.parse_path(target)
if not target:
raise Fail("Target cannot be empty")
url = format("{address}/webhdfs/v1{target}?op={operation}", address=self.address)
request_args = kwargs
if not self.security_enabled:
request_args['user.name'] = self.run_user
for k,v in request_args.iteritems():
url = format("{url}&{k}={v}")
cmd = ["curl", "-sS","-L", "-w", "%{http_code}", "-X", method]
# When operation is "OPEN" the target is actually the DFS file to download and the file_to_put is actually the target see _download_file
if operation == "OPEN":
cmd += ["-o", file_to_put]
else:
if file_to_put and not os.path.exists(file_to_put):
raise Fail(format("File {file_to_put} is not found."))
if file_to_put:
cmd += ["--data-binary", "@"+file_to_put, "-H", "Content-Type: application/octet-stream"]
if self.security_enabled:
cmd += ["--negotiate", "-u", ":"]
if self.is_https_enabled:
cmd += ["-k"]
cmd.append(url)
_, out, err = get_user_call_output(cmd, user=self.run_user, logoutput=self.logoutput, quiet=False)
status_code = out[-3:]
out = out[:-3] # remove last line from output which is status code
try:
result_dict = json.loads(out)
except ValueError:
result_dict = out
if status_code not in WebHDFSUtil.valid_status_codes+ignore_status_codes or assertable_result and result_dict and not result_dict['boolean']:
formatted_output = json.dumps(result_dict, indent=2) if isinstance(result_dict, dict) else result_dict
formatted_output = err + "\n" + formatted_output
err_msg = "Execution of '%s' returned status_code=%s. %s" % (shell.string_cmd_from_args_list(cmd), status_code, formatted_output)
raise WebHDFSCallException(err_msg, result_dict)
return result_dict
def get_name_service_by_hostname(hdfs_site, host_name):
"""
Finds the name service which the name node belongs to in an HA or federated setup.
:param hdfs_site: the hdfs config
:param host_name: the host name of the name node, can be None if there is only 1 name service
:return: the name service
"""
#there has to be a name service - we are in HA at least
name_services_string = hdfs_site['dfs.internal.nameservices']
if not name_services_string:
raise Fail('Not a HA setup')
name_services = name_services_string.split(',')
if len(name_services) == 1:
return name_services[0]
if not host_name:
raise ValueError('Host name required when using namenode federation')
for ns in name_services:
ha_name_nodes = hdfs_site['dfs.ha.namenodes.{0}'.format(ns)].split(',')
for nn in ha_name_nodes:
nn_rpc_port = hdfs_site['dfs.namenode.rpc-address.{0}.{1}'.format(
ns, nn)]
nn_rpc = nn_rpc_port.split(':')[0]
if nn_rpc == host_name:
return ns
def check_zeppelin_server(self):
import params
path = params.conf_dir + "/interpreter.json"
if os.path.exists(path) and os.path.getsize(path):
Logger.info("interpreter.json found. Zeppelin server started.")
else:
raise Fail("interpreter.json not found. waiting for Zeppelin server to start...")
def action_delayed(self, action_name, main_resource):
dfs_type = main_resource.resource.dfs_type
if main_resource.resource.nameservices is None: # all nameservices
nameservices = namenode_ha_utils.get_nameservices(
main_resource.resource.hdfs_site)
else:
nameservices = main_resource.resource.nameservices
# non-federated cluster
if not nameservices:
self.action_delayed_for_nameservice(None, action_name,
main_resource)
else:
for nameservice in nameservices:
try:
if not dfs_type:
raise Fail(
"<serviceType> for fileSystem service should be set in metainfo.xml"
)
nameservice = dfs_type.lower() + "://" + nameservice
self.action_delayed_for_nameservice(
nameservice, action_name, main_resource)
except namenode_ha_utils.NoActiveNamenodeException as ex:
# one of ns can be down (during initial start forexample) no need to worry for federated cluster
if len(nameservices) > 1:
Logger.exception(
"Cannot run HdfsResource for nameservice {0}. Due to no active namenode present"
.format(nameservice))
else:
raise
def action_run(self):
if self.resource.creates:
if os.path.exists(self.resource.creates):
return
Logger.debug("Executing %s" % self.resource)
if self.resource.path != []:
if not self.resource.environment:
self.resource.environment = {}
self.resource.environment['PATH'] = os.pathsep.join(self.resource.path)
for i in range (0, self.resource.tries):
try:
shell.checked_call(self.resource.command, logoutput=self.resource.logoutput,
cwd=self.resource.cwd, env=self.resource.environment,
preexec_fn=_preexec_fn(self.resource), user=self.resource.user,
wait_for_finish=self.resource.wait_for_finish, timeout=self.resource.timeout)
break
except Fail as ex:
if i == self.resource.tries-1: # last try
raise ex
else:
Logger.info("Retrying after %d seconds. Reason: %s" % (self.resource.try_sleep, str(ex)))
time.sleep(self.resource.try_sleep)
except ExecuteTimeoutException:
err_msg = ("Execution of '%s' was killed due timeout after %d seconds") % (self.resource.command, self.resource.timeout)
if self.resource.on_timeout:
Logger.info("Executing '%s'. Reason: %s" % (self.resource.on_timeout, err_msg))
shell.checked_call(self.resource.on_timeout)
else:
raise Fail(err_msg)
def get_property_for_active_namenode(hdfs_site, property_name,
security_enabled, run_user):
"""
For dfs.namenode.rpc-address:
- In non-ha mode it will return hdfs_site[dfs.namenode.rpc-address]
- In ha-mode it will return hdfs_site[dfs.namenode.rpc-address.nnha.nn2], where nnha is the name of HA, and nn2 is id of active NN
"""
value = None
rpc_key = None
if is_ha_enabled(hdfs_site):
name_service = hdfs_site['dfs.nameservices']
active_namenodes = get_namenode_states(hdfs_site, security_enabled,
run_user)[0]
if not len(active_namenodes):
raise Fail("There is no active namenodes.")
active_namenode_id = active_namenodes[0][0]
value = hdfs_site[format(
"{property_name}.{name_service}.{active_namenode_id}")]
rpc_key = NAMENODE_RPC_FRAGMENT.format(name_service,
active_namenode_id)
else:
value = hdfs_site[property_name]
rpc_key = NAMENODE_RPC_NON_HA
if INADDR_ANY in value and rpc_key in hdfs_site:
rpc_value = str(hdfs_site[rpc_key])
if INADDR_ANY not in rpc_value:
rpc_host = rpc_value.split(":")[0]
value = value.replace(INADDR_ANY, rpc_host)
return value
def _ensure_metadata(path, user, group, mode=None, cd_access=None):
stat = sudo.stat(path)
if user:
uid = _coerce_uid(user)
if stat.st_uid != uid:
Logger.info("Changing owner for %s from %d to %s" %
(path, stat.st_uid, user))
sudo.chown(path, user, None)
if group:
gid = _coerce_gid(group)
if stat.st_gid != gid:
Logger.info("Changing group for %s from %d to %s" %
(path, stat.st_gid, group))
sudo.chown(path, None, group)
if mode:
if stat.st_mode != mode:
Logger.info("Changing permission for %s from %o to %o" %
(path, stat.st_mode, mode))
sudo.chmod(path, mode)
if cd_access:
if not re.match("^[ugoa]+$", cd_access):
raise Fail("'cd_acess' value '%s' is not valid" % (cd_access))
dir_path = path
while dir_path != os.sep:
if sudo.path_isdir(dir_path):
sudo.chmod_extended(dir_path, cd_access + "+x")
dir_path = os.path.split(dir_path)[0]
def action_install(self):
hSCM = safe_open_scmanager()
self._fix_start_type()
self._fix_user_name()
try:
hSvc = win32service.CreateService(
hSCM,
self.resource.service_name,
self.resource.display_name,
win32service.SERVICE_ALL_ACCESS, # desired access
win32service.SERVICE_WIN32_OWN_PROCESS, # service type
self.resource.start_type,
win32service.SERVICE_ERROR_NORMAL, # error control type
self.resource.exe_path,
None,
0,
None,
self.resource.userName,
self.resource.password)
if self.resource.description:
try:
win32service.ChangeServiceConfig2(
hSvc, win32service.SERVICE_CONFIG_DESCRIPTION,
self.description)
except NotImplementedError:
pass ## ChangeServiceConfig2 and description do not exist on NT
win32service.CloseServiceHandle(hSvc)
except win32api.error, details:
raise Fail("Error creating service {0}: {1}".format(
self.resource.service_name, details.winerror))
def action_configure(self):
hSCM = safe_open_scmanager()
try:
hSvc = safe_open_service(hSCM, self.resource.service_name)
self._fix_start_type()
try:
win32service.ChangeServiceConfig(
hSvc, win32service.SERVICE_NO_CHANGE,
self.resource.start_type, win32service.SERVICE_NO_CHANGE,
None, None, 0, None, None, None,
self.resource.display_name)
if self.resource.description:
try:
win32service.ChangeServiceConfig2(
hSvc, win32service.SERVICE_CONFIG_DESCRIPTION,
self.resource.description)
except NotImplementedError:
pass ## ChangeServiceConfig2 and description do not exist on NT
except win32api.error, details:
raise Fail("Error configuring service {0}: {1}".format(
self.resource.service_name, details.winerror))
finally:
win32service.CloseServiceHandle(hSvc)
def perform_grafana_put_call(url, id, payload, server):
response = None
data = None
userAndPass = b64encode('{0}:{1}'.format(server.user, server.password))
headers = {"Content-Type": "application/json",
'Authorization' : 'Basic %s' % userAndPass }
grafana_https_enabled = server.protocol.lower() == 'https'
for i in xrange(0, GRAFANA_CONNECT_TRIES):
try:
conn = network.get_http_connection(server.host, int(server.port), grafana_https_enabled)
conn.request("PUT", url + "/" + str(id), payload, headers)
response = conn.getresponse()
data = response.read()
Logger.info("Http data: %s" % data)
conn.close()
break
except (httplib.HTTPException, socket.error) as ex:
if i < GRAFANA_CONNECT_TRIES - 1:
time.sleep(GRAFANA_CONNECT_TIMEOUT)
Logger.info("Connection to Grafana failed. Next retry in %s seconds."
% (GRAFANA_CONNECT_TIMEOUT))
continue
else:
raise Fail("Ambari Metrics Grafana update failed due to: %s" % str(ex))
pass
return (response, data)
def perform_grafana_get_call(url, server):
grafana_https_enabled = server.protocol.lower() == 'https'
response = None
for i in xrange(0, GRAFANA_CONNECT_TRIES):
try:
conn = network.get_http_connection(server.host,
int(server.port),
grafana_https_enabled)
userAndPass = b64encode('{0}:{1}'.format(server.user, server.password))
headers = { 'Authorization' : 'Basic %s' % userAndPass }
Logger.info("Connecting (GET) to %s:%s%s" % (server.host, server.port, url))
conn.request("GET", url, headers = headers)
response = conn.getresponse()
Logger.info("Http response: %s %s" % (response.status, response.reason))
break
except (httplib.HTTPException, socket.error) as ex:
if i < GRAFANA_CONNECT_TRIES - 1:
time.sleep(GRAFANA_CONNECT_TIMEOUT)
Logger.info("Connection to Grafana failed. Next retry in %s seconds."
% (GRAFANA_CONNECT_TIMEOUT))
continue
else:
raise Fail("Ambari Metrics Grafana update failed due to: %s" % str(ex))
pass
return response
def service_check(self, env):
from resource_management.libraries.functions.windows_service_utils import check_windows_service_exists
import params
env.set_params(params)
#Just check that the services were correctly installed
#Check the monitor on all hosts
Logger.info("Metrics Monitor service check was started.")
if not check_windows_service_exists(params.ams_monitor_win_service_name):
raise Fail("Metrics Monitor service was not properly installed. Check the logs and retry the installation.")
#Check the collector only where installed
if params.ams_collector_home_dir and os.path.isdir(params.ams_collector_home_dir):
Logger.info("Metrics Collector service check was started.")
if not check_windows_service_exists(params.ams_collector_win_service_name):
raise Fail("Metrics Collector service was not properly installed. Check the logs and retry the installation.")
def get_mounted():
"""
:return: Return a list of mount objects (dictionary type) that contain the device, mount point, and other options.
"""
p = Popen("mount", stdout=PIPE, stderr=STDOUT, shell=True)
out = p.communicate()[0]
if p.wait() != 0:
raise Fail("Getting list of mounts (calling mount) failed")
mounts = [x.split(' ') for x in out.strip().split('\n')]
results = []
for m in mounts:
# Example of m:
# /dev/sda1 on / type ext4 (rw,barrier=0)
# /dev/sdb on /grid/0 type ext4 (rw,discard)
if len(m) >= 6 and m[1] == "on" and m[3] == "type":
x = dict(
device=m[0],
mount_point=m[2],
fstype=m[4],
options=m[5][1:-1].split(',') if len(m[5]) >= 2 else []
)
results.append(x)
return results
def assert_not_safemode_folder(path, safemode_folders):
if os.path.abspath(path) in safemode_folders:
raise Fail((
"Not performing recursive operation ('recursive_ownership' or 'recursive_mode_flags') on folder '%s'"
+
" as this can damage the system. Please pass changed safemode_folders parameter to Directory resource if you really intend to do this."
) % (path))
def _assert_valid(self):
source = self.main_resource.resource.source
type = self.main_resource.resource.type
target = self.main_resource.resource.target
if source:
if not os.path.exists(source):
raise Fail(format("Source {source} doesn't exist"))
if type == "directory" and os.path.isfile(source):
raise Fail(format("Source {source} is file but type is {type}"))
elif type == "file" and os.path.isdir(source):
raise Fail(format("Source {source} is directory but type is {type}"))
self.target_status = self._get_file_status(target)
if self.target_status and self.target_status['type'].lower() != type:
raise Fail(format("Trying to create file/directory but directory/file exists in the DFS on {target}"))
def safe_open_scmanager():
try:
_schSCManager = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_ALL_ACCESS)
except win32api.error, details:
raise Fail(
"Error opening Service Control Manager on the local machine: {0}".
format(details.winerror))
def create_grafana_admin_pwd():
import params
serverCall1 = Server(protocol=params.ams_grafana_protocol.strip(),
host=params.ams_grafana_host.strip(),
port=params.ams_grafana_port,
user=params.ams_grafana_admin_user,
password=params.ams_grafana_admin_pwd)
response = perform_grafana_get_call(GRAFANA_USER_URL, serverCall1)
if response and response.status != 200:
serverCall2 = Server(protocol=params.ams_grafana_protocol.strip(),
host=params.ams_grafana_host.strip(),
port=params.ams_grafana_port,
user=params.ams_grafana_admin_user,
password='******')
Logger.debug("Setting grafana admin password")
pwd_data = {
"oldPassword": "******",
"newPassword": params.ams_grafana_admin_pwd,
"confirmNew": params.ams_grafana_admin_pwd
}
password_json = json.dumps(pwd_data)
(response, data) = perform_grafana_put_call(GRAFANA_USER_URL,
'password', password_json,
serverCall2)
if response.status == 200:
Logger.info("Ambari Metrics Grafana password updated.")
elif response.status == 500:
Logger.info(
"Ambari Metrics Grafana password update failed. Not retrying.")
raise Fail(
"Ambari Metrics Grafana password update failed. PUT request status: %s %s \n%s"
% (response.status, response.reason, data))
else:
raise Fail("Ambari Metrics Grafana password creation failed. "
"PUT request status: %s %s \n%s" %
(response.status, response.reason, data))
else:
Logger.info("Grafana password update not required.")
pass
def action_delete(self):
path = self.resource.path
if os.path.exists(path):
if not os.path.isdir(path):
raise Fail("Applying %s failed, %s is not a directory" % (self.resource, path))
Logger.info("Removing directory %s and all its content" % self.resource)
shutil.rmtree(path)
def perform_grafana_post_call(url, payload, server):
import params
response = None
data = None
userAndPass = b64encode('{0}:{1}'.format(server.user, server.password))
Logger.debug('POST payload: %s' % payload)
headers = {
"Content-Type": "application/json",
"Content-Length": len(payload),
'Authorization': 'Basic %s' % userAndPass
}
grafana_https_enabled = server.protocol.lower() == 'https'
ca_certs = None
if grafana_https_enabled:
ca_certs = params.ams_grafana_ca_cert
for i in xrange(0, params.grafana_connect_attempts):
try:
Logger.info("Connecting (POST) to %s:%s%s" %
(server.host, server.port, url))
conn = network.get_http_connection(
server.host,
int(server.port),
grafana_https_enabled,
ca_certs,
ssl_version=Script.get_force_https_protocol_value())
conn.request("POST", url, payload, headers)
response = conn.getresponse()
Logger.info("Http response: %s %s" %
(response.status, response.reason))
if response.status == 401: #Intermittent error thrown from Grafana
if i < params.grafana_connect_attempts - 1:
Logger.info(
"Connection to Grafana failed. Next retry in %s seconds."
% (params.grafana_connect_retry_delay))
time.sleep(params.grafana_connect_retry_delay)
continue
data = response.read()
Logger.info("Http data: %s" % data)
conn.close()
break
except (httplib.HTTPException, socket.error) as ex:
if i < params.grafana_connect_attempts - 1:
Logger.info(
"Connection to Grafana failed. Next retry in %s seconds." %
(params.grafana_connect_retry_delay))
time.sleep(params.grafana_connect_retry_delay)
continue
else:
raise Fail("Ambari Metrics Grafana update failed due to: %s" %
str(ex))
pass
return (response, data)
def _get_content(self):
content = self.resource.content
if content is None:
return None
elif isinstance(content, basestring):
return content
elif hasattr(content, "__call__"):
return content()
raise Fail("Unknown source type for %s: %r" % (self, content))
def _coerce_gid(group):
try:
gid = int(group)
except ValueError:
try:
gid = grp.getgrnam(group).gr_gid
except KeyError:
raise Fail("Group %s doesn't exist." % group)
return gid
