/brz/remove-bazaar : revision 7502.3.1

29

)

30

from breezy.i18n import gettext

31

32

has_ctypes_win32 = False

33

if sys.platform == 'win32':

34

try:

35

import ctypes

36

except ImportError:

37

has_ctypes_win32 = False

38

39

32

40

33

# Special Win32 API constants

41

34

# Handles of std streams

61

54

62

55

def debug_memory_win32api(message='', short=True):

63

56

"""Use trace.note() to dump the running memory info."""

57

import ctypes

64

58

from breezy import trace

65

if has_ctypes_win32:

66

class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):

67

"""Used by GetProcessMemoryInfo"""

68

_fields_ = [('cb', ctypes.c_ulong),

69

('PageFaultCount', ctypes.c_ulong),

70

('PeakWorkingSetSize', ctypes.c_size_t),

71

('WorkingSetSize', ctypes.c_size_t),

72

('QuotaPeakPagedPoolUsage', ctypes.c_size_t),

73

('QuotaPagedPoolUsage', ctypes.c_size_t),

74

('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),

75

('QuotaNonPagedPoolUsage', ctypes.c_size_t),

76

('PagefileUsage', ctypes.c_size_t),

77

('PeakPagefileUsage', ctypes.c_size_t),

78

('PrivateUsage', ctypes.c_size_t),

79

]

80

cur_process = ctypes.windll.kernel32.GetCurrentProcess()

81

mem_struct = PROCESS_MEMORY_COUNTERS_EX()

82

ret = ctypes.windll.psapi.GetProcessMemoryInfo(

83

cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))

84

if not ret:

85

trace.note(gettext('Failed to GetProcessMemoryInfo()'))

86

return

87

info = {'PageFaultCount': mem_struct.PageFaultCount,

88

'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,

89

'WorkingSetSize': mem_struct.WorkingSetSize,

90

'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,

91

'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,

92

'QuotaPeakNonPagedPoolUsage':

93

mem_struct.QuotaPeakNonPagedPoolUsage,

94

'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,

95

'PagefileUsage': mem_struct.PagefileUsage,

96

'PeakPagefileUsage': mem_struct.PeakPagefileUsage,

97

'PrivateUsage': mem_struct.PrivateUsage,

98

}

99

else:

100

trace.note(gettext('Cannot debug memory on win32 without ctypes'

101

' or win32process'))

59

class PROCESS_MEMORY_COUNTERS_EX(ctypes.Structure):

60

"""Used by GetProcessMemoryInfo"""

61

_fields_ = [('cb', ctypes.c_ulong),

62

('PageFaultCount', ctypes.c_ulong),

63

('PeakWorkingSetSize', ctypes.c_size_t),

64

('WorkingSetSize', ctypes.c_size_t),

65

('QuotaPeakPagedPoolUsage', ctypes.c_size_t),

66

('QuotaPagedPoolUsage', ctypes.c_size_t),

67

('QuotaPeakNonPagedPoolUsage', ctypes.c_size_t),

68

('QuotaNonPagedPoolUsage', ctypes.c_size_t),

69

('PagefileUsage', ctypes.c_size_t),

70

('PeakPagefileUsage', ctypes.c_size_t),

71

('PrivateUsage', ctypes.c_size_t),

72

]

73

cur_process = ctypes.windll.kernel32.GetCurrentProcess()

74

mem_struct = PROCESS_MEMORY_COUNTERS_EX()

75

ret = ctypes.windll.psapi.GetProcessMemoryInfo(

76

cur_process, ctypes.byref(mem_struct), ctypes.sizeof(mem_struct))

77

if not ret:

78

trace.note(gettext('Failed to GetProcessMemoryInfo()'))

102

79

return

80

info = {'PageFaultCount': mem_struct.PageFaultCount,

81

'PeakWorkingSetSize': mem_struct.PeakWorkingSetSize,

82

'WorkingSetSize': mem_struct.WorkingSetSize,

83

'QuotaPeakPagedPoolUsage': mem_struct.QuotaPeakPagedPoolUsage,

84

'QuotaPagedPoolUsage': mem_struct.QuotaPagedPoolUsage,

85

'QuotaPeakNonPagedPoolUsage':

86

mem_struct.QuotaPeakNonPagedPoolUsage,

87

'QuotaNonPagedPoolUsage': mem_struct.QuotaNonPagedPoolUsage,

88

'PagefileUsage': mem_struct.PagefileUsage,

89

'PeakPagefileUsage': mem_struct.PeakPagefileUsage,

90

'PrivateUsage': mem_struct.PrivateUsage,

91

}

103

92

if short:

104

93

# using base-2 units (see HACKING.txt).

105

94

trace.note(gettext('WorkingSize {0:>7}KiB'

130

119

console window and return tuple (sizex, sizey) if success,

131

120

or default size (defaultx, defaulty) otherwise.

132

121

"""

133

if not has_ctypes_win32:

134

# no ctypes is found

135

return (defaultx, defaulty)

136

122

import ctypes

137

123

# To avoid problem with redirecting output via pipe

138

124

# we need to use stderr instead of stdout

139

125

h = ctypes.windll.kernel32.GetStdHandle(WIN32_STDERR_HANDLE)

156

142

157

143

Result is always unicode (or None).

158

144

"""

159

if has_ctypes_win32:

160

try:

161

SHGetSpecialFolderPath = \

162

ctypes.windll.shell32.SHGetSpecialFolderPathW

163

except AttributeError:

164

pass

165

else:

166

buf = ctypes.create_unicode_buffer(MAX_PATH)

167

if SHGetSpecialFolderPath(None, buf, csidl, 0):

168

return buf.value

169

return None

145

import ctypes

146

try:

147

SHGetSpecialFolderPath = \

148

ctypes.windll.shell32.SHGetSpecialFolderPathW

149

except AttributeError:

150

pass

151

else:

152

buf = ctypes.create_unicode_buffer(MAX_PATH)

153

if SHGetSpecialFolderPath(None, buf, csidl, 0):

154

return buf.value

170

155

171

156

172

157

def get_appdata_location():

182

167

if appdata:

183

168

return appdata

184

169

# Use APPDATA if defined, will return None if not

185

return get_environ_unicode('APPDATA')

170

return os.environ.get('APPDATA')

186

171

187

172

188

173

def get_local_appdata_location():

199

184

if local:

200

185

return local

201

186

# Vista supplies LOCALAPPDATA, but XP and earlier do not.

202

local = get_environ_unicode('LOCALAPPDATA')

187

local = os.environ.get('LOCALAPPDATA')

203

188

if local:

204

189

return local

205

190

return get_appdata_location()

214

199

home = _get_sh_special_folder_path(CSIDL_PERSONAL)

215

200

if home:

216

201

return home

217

home = get_environ_unicode('HOME')

202

home = os.environ.get('HOME')

218

203

if home is not None:

219

204

return home

220

homepath = get_environ_unicode('HOMEPATH')

205

homepath = os.environ.get('HOMEPATH')

221

206

if homepath is not None:

222

return os.path.join(get_environ_unicode('HOMEDIR', ''), home)

207

return os.path.join(os.environ.get('HOMEDIR', ''), home)

223

208

# at least return windows root directory

224

windir = get_environ_unicode('WINDIR')

209

windir = os.environ.get('WINDIR')

225

210

if windir:

226

211

return os.path.splitdrive(windir)[0] + '/'

227

212

# otherwise C:\ is good enough for 98% users

232

217

"""Return user name as login name.

233

218

If name cannot be obtained return None.

234

219

"""

235

if has_ctypes_win32:

236

try:

237

advapi32 = ctypes.windll.advapi32

238

GetUserName = getattr(advapi32, 'GetUserNameW')

239

except AttributeError:

240

pass

241

else:

242

buf = ctypes.create_unicode_buffer(UNLEN + 1)

243

n = ctypes.c_int(UNLEN + 1)

244

if GetUserName(buf, ctypes.byref(n)):

245

return buf.value

220

try:

221

advapi32 = ctypes.windll.advapi32

222

GetUserName = getattr(advapi32, 'GetUserNameW')

223

except AttributeError:

224

pass

225

else:

226

buf = ctypes.create_unicode_buffer(UNLEN + 1)

227

n = ctypes.c_int(UNLEN + 1)

228

if GetUserName(buf, ctypes.byref(n)):

229

return buf.value

246

230

# otherwise try env variables

247

return get_environ_unicode('USERNAME')

231

return os.environ.get('USERNAME')

248

232

249

233

250

234

# 1 == ComputerNameDnsHostname, which returns "The DNS host name of the local

258

242

259

243

:return: A unicode string representing the host name.

260

244

"""

261

if has_ctypes_win32:

262

try:

263

kernel32 = ctypes.windll.kernel32

264

except AttributeError:

265

pass # Missing the module we need

266

else:

267

buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)

268

n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)

245

import ctypes

246

buf = ctypes.create_unicode_buffer(MAX_COMPUTERNAME_LENGTH + 1)

247

n = ctypes.c_int(MAX_COMPUTERNAME_LENGTH + 1)

269

248

270

# Try GetComputerNameEx which gives a proper Unicode hostname

271

GetComputerNameEx = getattr(kernel32, 'GetComputerNameExW', None)

272

if (GetComputerNameEx is not None

273

and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,

274

buf, ctypes.byref(n))):

275

return buf.value

276

return get_environ_unicode('COMPUTERNAME')

249

# Try GetComputerNameEx which gives a proper Unicode hostname

250

GetComputerNameEx = getattr(

251

ctypes.windll.kernel32, 'GetComputerNameExW', None)

252

if (GetComputerNameEx is not None

253

and GetComputerNameEx(_WIN32_ComputerNameDnsHostname,

254

buf, ctypes.byref(n))):

255

return buf.value

256

return os.environ.get('COMPUTERNAME')

277

257

278

258

279

259

def _ensure_with_dir(path):

363

343

364

344

if type_id == REG_SZ:

365

345

return path

366

if type_id == REG_EXPAND_SZ and has_win32api:

367

fullpath = win32api.ExpandEnvironmentStrings(path)

368

if len(fullpath) > 1 and fullpath[0] == '"' and fullpath[-1] == '"':

369

fullpath = fullpath[1:-1] # remove quotes around value

370

return fullpath

371

346

return appname

372

347

373

348

374

349

def set_file_attr_hidden(path):

375

350

"""Set file attributes to hidden if possible"""

376

if not has_ctypes_win32:

377

return

378

from ctypes.wintypes import BOOL, DWORD, LPCWSTR

379

_kernel32 = ctypes.windll.kernel32

351

from ctypes.wintypes import BOOL, DWORD, LPWSTR

352

import ctypes

380

353

# <https://docs.microsoft.com/windows/desktop/api/fileapi/nf-fileapi-setfileattributesw>

381

_SetFileAttributesW = ctypes.WINFUNCTYPE(BOOL, LPCWSTR, DWORD)(

382

("SetFileAttributesW", _kernel32))

354

SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW

355

SetFileAttributes.argtypes = LPWSTR, DWORD

356

SetFileAttributes.restype = BOOL

383

357

FILE_ATTRIBUTE_HIDDEN = 2

384

358

if not SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN):

385

359

e = ctypes.WinError()

429

403

return args

430

404

431

405

432

if has_ctypes_win32:

433

def get_unicode_argv():

434

prototype = ctypes.WINFUNCTYPE(ctypes.c_wchar_p)

435

GetCommandLineW = prototype(("GetCommandLineW",

436

ctypes.windll.kernel32))

437

command_line = GetCommandLineW()

438

if command_line is None:

439

raise ctypes.WinError()

440

# Skip the first argument, since we only care about parameters

441

argv = _command_line_to_argv(command_line, sys.argv)[1:]

442

return argv

443

444

def get_environ_unicode(key, default=None):

445

"""Get `key` from environment as unicode or `default` if unset

446

447

The environment is natively unicode on modern windows versions but

448

Python 2 only accesses it through the legacy bytestring api.

449

450

Environmental variable names are case insenstive on Windows.

451

452

A large enough buffer will be allocated to retrieve the value, though

453

it may take two calls to the underlying library function.

454

"""

455

cfunc = getattr(get_environ_unicode, "_c_function", None)

456

if cfunc is None:

457

from ctypes.wintypes import DWORD, LPCWSTR, LPWSTR

458

cfunc = ctypes.WINFUNCTYPE(DWORD, LPCWSTR, LPWSTR, DWORD)(

459

("GetEnvironmentVariableW", ctypes.windll.kernel32))

460

get_environ_unicode._c_function = cfunc

461

buffer_size = 256 # heuristic, 256 characters often enough

462

while True:

463

buf = ctypes.create_unicode_buffer(buffer_size)

464

length = cfunc(key, buf, buffer_size)

465

if not length:

466

code = ctypes.GetLastError()

467

if code == 203: # ERROR_ENVVAR_NOT_FOUND

468

return default

469

raise ctypes.WinError(code)

470

if buffer_size > length:

471

return buf[:length]

472

buffer_size = length

473

474

475

if has_ctypes_win32:

476

from ctypes.wintypes import BOOL, DWORD, HANDLE

477

_kernel32 = ctypes.windll.kernel32

478

_CloseHandle = ctypes.WINFUNCTYPE(BOOL, HANDLE)(

479

("CloseHandle", _kernel32))

480

_OpenProcess = ctypes.WINFUNCTYPE(HANDLE, DWORD, BOOL, DWORD)(

481

("OpenProcess", _kernel32))

482

483

def _ctypes_is_local_pid_dead(pid):

484

"""True if pid doesn't correspond to live process on this machine"""

485

handle = _OpenProcess(1, False, pid) # PROCESS_TERMINATE

486

if not handle:

487

errorcode = ctypes.GetLastError()

488

if errorcode == 5: # ERROR_ACCESS_DENIED

489

# Probably something alive we're not allowed to kill

490

return False

491

elif errorcode == 87: # ERROR_INVALID_PARAMETER

492

return True

493

raise ctypes.WinError(errorcode)

494

_CloseHandle(handle)

495

return False

496

497

is_local_pid_dead = _ctypes_is_local_pid_dead

406

def _ctypes_is_local_pid_dead(pid):

407

import ctypes

408

kernel32 = ctypes.wintypes.windll.kernel32

409

"""True if pid doesn't correspond to live process on this machine"""

410

handle = kernel32.OpenProcess(1, False, pid)

411

if not handle:

412

errorcode = ctypes.GetLastError()

413

if errorcode == 5: # ERROR_ACCESS_DENIED

414

# Probably something alive we're not allowed to kill

415

return False

416

elif errorcode == 87: # ERROR_INVALID_PARAMETER

417

return True

418

raise ctypes.WinError(errorcode)

419

Kernel32.CloseHandle(handle)

420

return False

421

422

is_local_pid_dead = _ctypes_is_local_pid_dead