| # !/usr/bin/env python |
| |
| ''' |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| 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. |
| ''' |
| import getpass |
| import os |
| import random |
| import shlex |
| import subprocess |
| import sys |
| import tempfile |
| import time |
| import string |
| |
| import ctypes |
| |
| import msvcrt |
| |
| import pywintypes |
| import win32api |
| import win32con |
| import win32event |
| import win32file |
| import win32net |
| import win32netcon |
| import win32process |
| import win32security |
| import win32service |
| import win32serviceutil |
| import winerror |
| import winioctlcon |
| import wmi |
| |
| from ambari_commons.exceptions import FatalException |
| from ambari_commons.logging_utils import print_info_msg, print_warning_msg |
| |
| SERVICE_STATUS_UNKNOWN = "unknown" |
| SERVICE_STATUS_STARTING = "starting" |
| SERVICE_STATUS_RUNNING = "running" |
| SERVICE_STATUS_STOPPING = "stopping" |
| SERVICE_STATUS_STOPPED = "stopped" |
| SERVICE_STATUS_NOT_INSTALLED = "not installed" |
| |
| WHOAMI_GROUPS = "whoami /groups" |
| ADMIN_ACCOUNT = "BUILTIN\\Administrators" |
| |
| # |
| # os.symlink is not implemented in Windows. Patch it. |
| # |
| __CSL = None |
| def symlink(source, link_name): |
| '''symlink(source, link_name) |
| Creates a symbolic link pointing to source named link_name''' |
| global __CSL |
| if __CSL is None: |
| csl = ctypes.windll.kernel32.CreateSymbolicLinkW |
| csl.argtypes = (ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_uint32) |
| csl.restype = ctypes.c_ubyte |
| __CSL = csl |
| flags = 0 |
| if source is not None and os.path.isdir(source): |
| flags = 1 |
| if __CSL(link_name, source, flags) == 0: |
| raise ctypes.WinError() |
| |
| os.symlink = symlink |
| |
| # Win32file doesn't seem to have this attribute. |
| FILE_ATTRIBUTE_REPARSE_POINT = 1024 |
| # To make things easier. |
| REPARSE_FOLDER = (win32file.FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT) |
| |
| # For the parse_reparse_buffer function |
| SYMBOLIC_LINK = 'symbolic' |
| MOUNTPOINT = 'mountpoint' |
| GENERIC = 'generic' |
| |
| def islink(fpath): |
| """ Windows islink implementation. """ |
| if win32file.GetFileAttributes(fpath) & REPARSE_FOLDER == REPARSE_FOLDER: |
| return True |
| return False |
| |
| os.path.islink = islink |
| |
| def _parse_reparse_buffer(original, reparse_type=SYMBOLIC_LINK): |
| """ Implementing the below in Python: |
| |
| typedef struct _REPARSE_DATA_BUFFER { |
| ULONG ReparseTag; |
| USHORT ReparseDataLength; |
| USHORT Reserved; |
| union { |
| struct { |
| USHORT SubstituteNameOffset; |
| USHORT SubstituteNameLength; |
| USHORT PrintNameOffset; |
| USHORT PrintNameLength; |
| ULONG Flags; |
| WCHAR PathBuffer[1]; |
| } SymbolicLinkReparseBuffer; |
| struct { |
| USHORT SubstituteNameOffset; |
| USHORT SubstituteNameLength; |
| USHORT PrintNameOffset; |
| USHORT PrintNameLength; |
| WCHAR PathBuffer[1]; |
| } MountPointReparseBuffer; |
| struct { |
| UCHAR DataBuffer[1]; |
| } GenericReparseBuffer; |
| } DUMMYUNIONNAME; |
| } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER; |
| |
| """ |
| # Size of our data types |
| SZULONG = 4 # sizeof(ULONG) |
| SZUSHORT = 2 # sizeof(USHORT) |
| |
| # Our structure. |
| # Probably a better way to iterate a dictionary in a particular order, |
| # but I was in a hurry, unfortunately, so I used pkeys. |
| buffer = { |
| 'tag' : SZULONG, |
| 'data_length' : SZUSHORT, |
| 'reserved' : SZUSHORT, |
| SYMBOLIC_LINK : { |
| 'substitute_name_offset' : SZUSHORT, |
| 'substitute_name_length' : SZUSHORT, |
| 'print_name_offset' : SZUSHORT, |
| 'print_name_length' : SZUSHORT, |
| 'flags' : SZULONG, |
| 'buffer' : u'', |
| 'pkeys' : [ |
| 'substitute_name_offset', |
| 'substitute_name_length', |
| 'print_name_offset', |
| 'print_name_length', |
| 'flags', |
| ] |
| }, |
| MOUNTPOINT : { |
| 'substitute_name_offset' : SZUSHORT, |
| 'substitute_name_length' : SZUSHORT, |
| 'print_name_offset' : SZUSHORT, |
| 'print_name_length' : SZUSHORT, |
| 'buffer' : u'', |
| 'pkeys' : [ |
| 'substitute_name_offset', |
| 'substitute_name_length', |
| 'print_name_offset', |
| 'print_name_length', |
| ] |
| }, |
| GENERIC : { |
| 'pkeys' : [], |
| 'buffer': '' |
| } |
| } |
| |
| # Header stuff |
| buffer['tag'] = original[:SZULONG] |
| buffer['data_length'] = original[SZULONG:SZUSHORT] |
| buffer['reserved'] = original[SZULONG+SZUSHORT:SZUSHORT] |
| original = original[8:] |
| |
| # Parsing |
| k = reparse_type |
| for c in buffer[k]['pkeys']: |
| if type(buffer[k][c]) == int: |
| sz = buffer[k][c] |
| bytes = original[:sz] |
| buffer[k][c] = 0 |
| for b in bytes: |
| n = ord(b) |
| if n: |
| buffer[k][c] += n |
| original = original[sz:] |
| |
| # Using the offset and length's grabbed, we'll set the buffer. |
| buffer[k]['buffer'] = original |
| return buffer |
| |
| def readlink(fpath): |
| """ Windows readlink implementation. """ |
| # This wouldn't return true if the file didn't exist, as far as I know. |
| if not islink(fpath): |
| return None |
| |
| try: |
| # Open the file correctly depending on the string type. |
| if type(fpath) == unicode: |
| handle = win32file.CreateFileW(fpath, win32file.GENERIC_READ, 0, None, win32file.OPEN_EXISTING, win32file.FILE_FLAG_OPEN_REPARSE_POINT | win32file.FILE_FLAG_BACKUP_SEMANTICS, 0) |
| else: |
| handle = win32file.CreateFile(fpath, win32file.GENERIC_READ, 0, None, win32file.OPEN_EXISTING, win32file.FILE_FLAG_OPEN_REPARSE_POINT | win32file.FILE_FLAG_BACKUP_SEMANTICS, 0) |
| |
| # MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16384 = (16*1024) |
| buffer = win32file.DeviceIoControl(handle, winioctlcon.FSCTL_GET_REPARSE_POINT, None, 16*1024) |
| # Above will return an ugly string (byte array), so we'll need to parse it. |
| |
| # But first, we'll close the handle to our file so we're not locking it anymore. |
| win32file.CloseHandle(handle) |
| |
| # Minimum possible length (assuming that the length of the target is bigger than 0) |
| if len(buffer) < 9: |
| return None |
| # Parse and return our result. |
| result = _parse_reparse_buffer(buffer) |
| offset = result[SYMBOLIC_LINK]['substitute_name_offset'] |
| ending = offset + result[SYMBOLIC_LINK]['substitute_name_length'] |
| rpath = result[SYMBOLIC_LINK]['buffer'][offset:ending].replace('\x00','') |
| if len(rpath) > 4 and rpath[0:4] == '\\??\\': |
| rpath = rpath[4:] |
| return rpath |
| except pywintypes.error, e: |
| raise OSError(e.winerror, e.strerror, fpath) |
| |
| os.readlink = readlink |
| |
| |
| class OSVERSIONINFOEXW(ctypes.Structure): |
| _fields_ = [('dwOSVersionInfoSize', ctypes.c_ulong), |
| ('dwMajorVersion', ctypes.c_ulong), |
| ('dwMinorVersion', ctypes.c_ulong), |
| ('dwBuildNumber', ctypes.c_ulong), |
| ('dwPlatformId', ctypes.c_ulong), |
| ('szCSDVersion', ctypes.c_wchar*128), |
| ('wServicePackMajor', ctypes.c_ushort), |
| ('wServicePackMinor', ctypes.c_ushort), |
| ('wSuiteMask', ctypes.c_ushort), |
| ('wProductType', ctypes.c_byte), |
| ('wReserved', ctypes.c_byte)] |
| |
| def get_windows_version(): |
| """ |
| Gets the OS major and minor versions. Returns a tuple of |
| (OS_MAJOR, OS_MINOR). |
| """ |
| os_version = OSVERSIONINFOEXW() |
| os_version.dwOSVersionInfoSize = ctypes.sizeof(os_version) |
| retcode = ctypes.windll.Ntdll.RtlGetVersion(ctypes.byref(os_version)) |
| if retcode != 0: |
| raise Exception("Failed to get OS version") |
| |
| return os_version.dwMajorVersion, os_version.dwMinorVersion, os_version.dwBuildNumber |
| |
| CHECK_FIREWALL_SCRIPT = """[string]$CName = $env:computername |
| $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey("LocalMachine",$computer) |
| $domain = $reg.OpenSubKey("System\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\DomainProfile").GetValue("EnableFirewall") |
| $standart = $reg.OpenSubKey("System\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\StandardProfile").GetValue("EnableFirewall") |
| $public = $reg.OpenSubKey("System\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\PublicProfile").GetValue("EnableFirewall") |
| Write-Host $domain |
| Write-Host $standart |
| Write-Host $public |
| """ |
| |
| def _create_tmp_files(): |
| out_file = tempfile.TemporaryFile(mode="r+b") |
| err_file = tempfile.TemporaryFile(mode="r+b") |
| return (msvcrt.get_osfhandle(out_file.fileno()), |
| msvcrt.get_osfhandle(err_file.fileno()), |
| out_file, |
| err_file) |
| |
| |
| def _get_files_output(out, err): |
| out.seek(0) |
| err.seek(0) |
| return out.read().strip(), err.read().strip() |
| |
| |
| def _safe_duplicate_handle(h): |
| try: |
| h = win32api.DuplicateHandle(win32process.GetCurrentProcess(), |
| h, |
| win32process.GetCurrentProcess(), |
| 0, |
| True, |
| win32con.DUPLICATE_SAME_ACCESS) |
| return True, h |
| except Exception as exc: |
| if exc.winerror == winerror.ERROR_INVALID_HANDLE: |
| return True, None |
| return False, None |
| |
| |
| def run_os_command_impersonated(cmd, user, password, domain='.'): |
| si = win32process.STARTUPINFO() |
| |
| out_handle, err_handle, out_file, err_file = _create_tmp_files() |
| |
| ok, si.hStdInput = _safe_duplicate_handle(win32api.GetStdHandle(win32api.STD_INPUT_HANDLE)) |
| |
| if not ok: |
| raise Exception("Unable to create StdInput for child process") |
| ok, si.hStdOutput = _safe_duplicate_handle(out_handle) |
| if not ok: |
| raise Exception("Unable to create StdOut for child process") |
| ok, si.hStdError = _safe_duplicate_handle(err_handle) |
| if not ok: |
| raise Exception("Unable to create StdErr for child process") |
| |
| si.dwFlags = win32process.STARTF_USESTDHANDLES |
| si.lpDesktop = "" |
| |
| user_token = win32security.LogonUser(user, domain, password, |
| win32con.LOGON32_LOGON_SERVICE, win32con.LOGON32_PROVIDER_DEFAULT) |
| primary_token = win32security.DuplicateTokenEx(user_token, |
| win32security.SecurityImpersonation, 0, win32security.TokenPrimary) |
| info = win32process.CreateProcessAsUser(primary_token, None, cmd, None, None, 1, 0, None, None, si) |
| |
| hProcess, hThread, dwProcessId, dwThreadId = info |
| hThread.Close() |
| |
| try: |
| win32event.WaitForSingleObject(hProcess, win32event.INFINITE) |
| except KeyboardInterrupt: |
| pass |
| |
| out, err = _get_files_output(out_file, err_file) |
| exitcode = win32process.GetExitCodeProcess(hProcess) |
| |
| return exitcode, out, err |
| |
| def os_run_os_command(cmd, env=None, shell=False, cwd=None): |
| if isinstance(cmd,basestring): |
| cmd = cmd.replace("\\", "\\\\") |
| cmd = shlex.split(cmd) |
| process = subprocess.Popen(cmd, |
| stdout=subprocess.PIPE, |
| stdin=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| env=env, |
| cwd=cwd, |
| shell=shell |
| ) |
| (stdoutdata, stderrdata) = process.communicate() |
| return process.returncode, stdoutdata, stderrdata |
| |
| # execute powershell script passed in script_content. Script will be in temporary file to avoid different escape |
| # and formatting problems. |
| def run_powershell_script(script_content): |
| tmp_dir = tempfile.gettempdir() |
| random_filename = ''.join(random.choice(string.lowercase) for i in range(10)) |
| script_file = open(os.path.join(tmp_dir,random_filename+".ps1"),"w") |
| script_file.write(script_content) |
| script_file.close() |
| result = os_run_os_command("powershell -ExecutionPolicy unrestricted -File {0}".format(script_file.name)) |
| os.remove(script_file.name) |
| return result |
| |
| def os_change_owner(filePath, user, recursive): |
| cmd = ['icacls', filePath, '/setowner', user] |
| if recursive: |
| cmd = ['icacls', filePath, '/t', '/setowner', user] |
| retcode, outdata, errdata = os_run_os_command(cmd) |
| return retcode |
| |
| def os_is_root(): |
| ''' |
| Checks whether the current user is a member of the Administrators group |
| Returns True if yes, otherwise False |
| ''' |
| retcode, out, err = os_run_os_command(WHOAMI_GROUPS) |
| if retcode != 0: |
| err_msg = "Unable to check the current user's group memberships. " \ |
| "Command {0} returned exit code {1} with message: {2}".format(WHOAMI_GROUPS, retcode, err) |
| print_warning_msg(err_msg) |
| raise FatalException(retcode, err_msg) |
| |
| #Check for Administrators group membership |
| if -1 != out.find('\n' + ADMIN_ACCOUNT): |
| return True |
| |
| return False |
| |
| def os_set_file_permissions(file, mod, recursive, user): |
| retcode = 0 |
| |
| #WARN_MSG = "Command {0} returned exit code {1} with message: {2}" |
| #if recursive: |
| # params = " -R " |
| #else: |
| # params = "" |
| #command = NR_CHMOD_CMD.format(params, mod, file) |
| #retcode, out, err = os_run_os_command(command) |
| #if retcode != 0: |
| # print_warning_msg(WARN_MSG.format(command, file, err)) |
| #command = NR_CHOWN_CMD.format(params, user, file) |
| #retcode, out, err = os_run_os_command(command) |
| #if retcode != 0: |
| # print_warning_msg(WARN_MSG.format(command, file, err)) |
| |
| # rights = mod |
| # acls_remove_cmd = "icacls {0} /remove {1}".format(file, user) |
| # retcode, out, err = os_run_os_command(acls_remove_cmd) |
| # if retcode == 0: |
| # acls_modify_cmd = "icacls {0} /grant {1}:{2}".format(file, user, rights) |
| # retcode, out, err = os_run_os_command(acls_modify_cmd) |
| return retcode |
| |
| |
| def os_set_open_files_limit(maxOpenFiles): |
| # No open files limit in Windows. Not messing around with the System Resource Manager, at least for now. |
| pass |
| |
| |
| def os_getpass(prompt, stream=None): |
| """Prompt for password with echo off, using Windows getch().""" |
| if sys.stdin is not sys.__stdin__: |
| return getpass.fallback_getpass(prompt, stream) |
| |
| for c in prompt: |
| msvcrt.putch(c) |
| |
| pw = "" |
| while True: |
| c = msvcrt.getch() |
| if c == '\r' or c == '\n': |
| break |
| if c == '\003': |
| raise KeyboardInterrupt |
| if c == '\b': |
| if pw == '': |
| pass |
| else: |
| pw = pw[:-1] |
| msvcrt.putch('\b') |
| msvcrt.putch(" ") |
| msvcrt.putch('\b') |
| else: |
| pw = pw + c |
| msvcrt.putch("*") |
| |
| msvcrt.putch('\r') |
| msvcrt.putch('\n') |
| return pw |
| |
| #[fbarca] Not used for now, keep it around just in case |
| def wait_for_pid_wmi(processName, parentPid, pattern, timeout): |
| """ |
| Check pid for existence during timeout |
| """ |
| tstart = time.time() |
| pid_live = 0 |
| |
| c = wmi.WMI(find_classes=False) |
| qry = "select * from Win32_Process where Name=\"%s\" and ParentProcessId=%d" % (processName, parentPid) |
| |
| while int(time.time() - tstart) <= timeout: |
| for proc in c.query(qry): |
| cmdLine = proc.CommandLine |
| if cmdLine is not None and pattern in cmdLine: |
| return pid_live |
| time.sleep(1) |
| return 0 |
| |
| |
| #need this for redirecting output form python process to file |
| class SyncStreamWriter(object): |
| def __init__(self, stream, hMutexWrite): |
| self.stream = stream |
| self.hMutexWrite = hMutexWrite |
| |
| def write(self, data): |
| #Ensure that the output is thread-safe when writing from 2 separate streams into the same file |
| # (typical when redirecting both stdout and stderr to the same file). |
| win32event.WaitForSingleObject(self.hMutexWrite, win32event.INFINITE) |
| try: |
| self.stream.write(data) |
| self.stream.flush() |
| finally: |
| win32event.ReleaseMutex(self.hMutexWrite) |
| |
| def __getattr__(self, attr): |
| return getattr(self.stream, attr) |
| |
| |
| class SvcStatusCallback(object): |
| def __init__(self, svc): |
| self.svc = svc |
| |
| def reportStartPending(self): |
| self.svc.ReportServiceStatus(win32service.SERVICE_START_PENDING) |
| |
| def reportStarted(self): |
| self.svc.ReportServiceStatus(win32service.SERVICE_RUNNING) |
| |
| def reportStopPending(self): |
| self.svc.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) |
| |
| def reportStopped(self): |
| self.svc.ReportServiceStatus(win32service.SERVICE_STOPPED) |
| |
| |
| class WinServiceController: |
| @staticmethod |
| def Start(serviceName, waitSecs=30): |
| err = 0 |
| msg = '' |
| try: |
| win32serviceutil.StartService(serviceName) |
| if waitSecs: |
| win32serviceutil.WaitForServiceStatus(serviceName, win32service.SERVICE_RUNNING, waitSecs) |
| except win32service.error, exc: |
| if exc.winerror != 1056: |
| msg = "Error starting service: %s" % exc.strerror |
| err = exc.winerror |
| return err, msg |
| |
| @staticmethod |
| def Stop(serviceName, waitSecs=30): |
| err = 0 |
| msg = '' |
| try: |
| if waitSecs: |
| win32serviceutil.StopServiceWithDeps(serviceName, waitSecs=waitSecs) |
| else: |
| win32serviceutil.StopService(serviceName) |
| if waitSecs: |
| win32serviceutil.WaitForServiceStatus(serviceName, win32service.SERVICE_STOPPED, waitSecs) |
| except win32service.error, exc: |
| if exc.winerror != 1062: |
| msg = "Error stopping service: %s (%d)" % (exc.strerror, exc.winerror) |
| err = exc.winerror |
| return err, msg |
| |
| @staticmethod |
| def QueryStatus(serviceName): |
| statusString = SERVICE_STATUS_UNKNOWN |
| |
| try: |
| status = win32serviceutil.QueryServiceStatus(serviceName)[1] |
| |
| if status == win32service.SERVICE_STOPPED: |
| statusString = SERVICE_STATUS_STOPPED |
| elif status == win32service.SERVICE_START_PENDING: |
| statusString = SERVICE_STATUS_STARTING |
| elif status == win32service.SERVICE_RUNNING: |
| statusString = SERVICE_STATUS_RUNNING |
| elif status == win32service.SERVICE_STOP_PENDING: |
| statusString = SERVICE_STATUS_STOPPING |
| except win32api.error: |
| statusString = SERVICE_STATUS_NOT_INSTALLED |
| pass |
| |
| return statusString |
| |
| @staticmethod |
| def EnsureServiceIsStarted(serviceName, waitSecs=30): |
| err = 0 |
| try: |
| status = win32serviceutil.QueryServiceStatus(serviceName)[1] |
| if win32service.SERVICE_RUNNING != status: |
| if win32service.SERVICE_START_PENDING != status: |
| win32serviceutil.StartService(serviceName) |
| if waitSecs: |
| win32serviceutil.WaitForServiceStatus(serviceName, win32service.SERVICE_RUNNING, waitSecs) |
| except win32service.error, exc: |
| if exc.winerror != 1056: |
| err = exc.winerror |
| return err |
| |
| |
| class WinService(win32serviceutil.ServiceFramework): |
| # _svc_name_ = The service name |
| # _svc_display_name_ = The service display name |
| # _svc_description_ = The service description |
| |
| _heventSvcStop = win32event.CreateEvent(None, 1, 0, None) |
| _hmtxOut = win32event.CreateMutex(None, False, None) #[fbarca] Python doesn't support critical sections |
| |
| def __init__(self, *args): |
| win32serviceutil.ServiceFramework.__init__(self, *args) |
| |
| def SvcDoRun(self): |
| try: |
| self.ReportServiceStatus(win32service.SERVICE_RUNNING) |
| self.ServiceMain() |
| except Exception, x: |
| #TODO: Log exception |
| self.SvcStop() |
| |
| def SvcStop(self): |
| self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) |
| win32event.SetEvent(WinService._heventSvcStop) |
| |
| # Service code entry point. Override it to implement the intended functionality. |
| def ServiceMain(self): |
| #Default implementation, does nothing. |
| win32event.WaitForSingleObject(WinService._heventSvcStop, win32event.INFINITE) |
| pass |
| |
| @staticmethod |
| def DefCtrlCHandler(): |
| print_info_msg("Ctrl+C handler invoked. Stopping.") |
| win32event.SetEvent(WinService._heventSvcStop) |
| pass |
| |
| #username domain\\username : The Username the service is to run under |
| #password password : The password for the username |
| #startup [manual|auto|disabled|delayed] : How the service starts, default = auto |
| #interactive : Allow the service to interact with the desktop. |
| #perfmonini file: .ini file to use for registering performance monitor data |
| #perfmondll file: .dll file to use when querying the service for performance data, default = perfmondata.dll |
| @classmethod |
| def Install(cls, classPath = None, startupMode = "auto", username = None, password = None, interactive = False, |
| perfMonIni = None, perfMonDll = None): |
| installArgs = [sys.argv[0], "--startup=" + startupMode] |
| if username is not None and username: |
| if username.find('\\') == -1: |
| username = '.\\' + username |
| installArgs.append("--username=" + username) |
| if password is not None and password: |
| installArgs.append("--password=" + password) |
| if interactive: |
| installArgs.append("--interactive") |
| if perfMonIni is not None and perfMonIni: |
| installArgs.append("--perfmonini=" + perfMonIni) |
| if perfMonDll is not None and perfMonDll: |
| installArgs.append("--perfmondll=" + perfMonDll) |
| installArgs.append("install") |
| |
| return win32serviceutil.HandleCommandLine(cls, classPath, installArgs) |
| |
| @classmethod |
| def Start(cls, waitSecs = 30): |
| return WinServiceController.Start(cls._svc_name_, waitSecs) |
| |
| @classmethod |
| def Stop(cls, waitSecs = 30): |
| return WinServiceController.Stop(cls._svc_name_, waitSecs) |
| |
| @classmethod |
| def QueryStatus(cls): |
| return WinServiceController.QueryStatus(cls._svc_name_) |
| |
| @classmethod |
| def set_ctrl_c_handler(cls, ctrlHandler): |
| win32api.SetConsoleCtrlHandler(ctrlHandler, True) |
| pass |
| |
| def _RedirectOutputStreamsToFile(self, outFilePath): |
| outFileDir = os.path.dirname(outFilePath) |
| if not os.path.exists(outFileDir): |
| os.makedirs(outFileDir) |
| |
| out_writer = SyncStreamWriter(file(outFilePath, "w"), self._hmtxOut) |
| sys.stderr = out_writer |
| sys.stdout = out_writer |
| pass |
| |
| def CheckForStop(self): |
| #Check for stop event to be signaled |
| return win32event.WAIT_OBJECT_0 == win32event.WaitForSingleObject(WinService._heventSvcStop, 1) |
| |
| def _StopOrWaitForChildProcessToFinish(self, childProcess): |
| #Wait for the child process to finish or for the stop event to be signaled |
| if(win32event.WAIT_OBJECT_0 == win32event.WaitForMultipleObjects([WinService._heventSvcStop, childProcess._handle], |
| False, win32event.INFINITE)): |
| # The OS only detaches the child process when the master process exits. |
| # We must kill it manually. |
| try: |
| #Sending signal.CTRL_BREAK_EVENT doesn't work. It only detaches the child process from the master. |
| # Must brutally terminate the child process. Sorry Java. |
| childProcess.terminate() |
| except OSError, e: |
| print_info_msg("Unable to stop Ambari Server - " + str(e)) |
| return False |
| |
| return True |
| |
| class SystemWideLock(object): |
| |
| def __init__(self, name): |
| self._mutex = win32event.CreateMutex(None, 0, name) |
| |
| def lock(self, timeout=0): |
| result = win32event.WaitForSingleObject(self._mutex, timeout) |
| if result in [win32event.WAIT_TIMEOUT, win32event.WAIT_ABANDONED, win32event.WAIT_FAILED]: |
| return False |
| elif result == win32event.WAIT_OBJECT_0: |
| return True |
| |
| def unlock(self): |
| try: |
| win32event.ReleaseMutex(self._mutex) |
| return True |
| except: |
| return False |
| |
| def __del__(self): |
| win32api.CloseHandle(self._mutex) |
| |
| class UserHelper(object): |
| ACTION_OK = 0 |
| USER_EXISTS = 1 |
| ACTION_FAILED = -1 |
| |
| def __init__(self, userName): |
| self.domainName, self.userName = UserHelper.parse_user_name(userName) |
| if self.domainName: |
| self.dcName = win32net.NetGetDCName(None, self.domainName) |
| else: |
| self.dcName = None |
| self._policy = win32security.LsaOpenPolicy(self.dcName, |
| win32security.POLICY_CREATE_ACCOUNT | win32security.POLICY_LOOKUP_NAMES) |
| |
| @staticmethod |
| def parse_user_name(userName, defDomain=None): |
| domainName = defDomain |
| domainSepIndex = userName.find('\\') |
| if domainSepIndex != -1: |
| domainName = userName[0:domainSepIndex] |
| userName = userName[domainSepIndex + 1:] |
| if not domainName or domainName == '.' or domainName == win32api.GetComputerName(): |
| domainName = defDomain |
| return (domainName, userName) |
| |
| def create_user(self, password, comment="Ambari user"): |
| user_info = {} |
| user_info['name'] = self.userName |
| user_info['password'] = password |
| user_info['priv'] = win32netcon.USER_PRIV_USER |
| user_info['comment'] = comment |
| user_info['flags'] = win32netcon.UF_NORMAL_ACCOUNT | win32netcon.UF_SCRIPT |
| try: |
| win32net.NetUserAdd(self.dcName, 1, user_info) |
| except pywintypes.error as e: |
| if e.winerror == 2224: |
| return UserHelper.USER_EXISTS, e.strerror |
| else: |
| return UserHelper.ACTION_FAILED, e.strerror |
| return UserHelper.ACTION_OK, "User created." |
| |
| def find_user(self): |
| try: |
| user_info = win32net.NetUserGetInfo(self.dcName, self.userName, 0) |
| except pywintypes.error as e: |
| if e.winerror == 2221: |
| return False |
| else: |
| raise |
| return True |
| |
| def add_user_privilege(self, privilege): |
| try: |
| acc_sid = win32security.LookupAccountName(self.dcName, self.userName)[0] |
| win32security.LsaAddAccountRights(self._policy, acc_sid, (privilege,)) |
| except pywintypes.error as e: |
| return UserHelper.ACTION_FAILED, e.strerror |
| return UserHelper.ACTION_OK, "Privilege added." |
| |
| def remove_user_privilege(self, name, privilege): |
| try: |
| acc_sid = win32security.LookupAccountName(self.dcName, self.userName)[0] |
| win32security.LsaRemoveAccountRights(self._policy, acc_sid, 0, (privilege,)) |
| except pywintypes.error as e: |
| return UserHelper.ACTION_FAILED, e.strerror |
| return UserHelper.ACTION_OK, "Privilege removed." |
