#!/usr/bin/env python
'''Install P4V addins'''
# Copyright (c) 2006 Qualcomm
# Miki Tebeka <[email protected]>
from re import match
from user import home
from os.path import join, isfile, dirname, isdir
from sys import stdout, path, platform
from urllib import quote, unquote
from shutil import copy2
from os import mkdir, popen
from glob import glob
from elementtree.ElementTree import Element, XML, tostring
from install import InstallError, load_config, is_boolean, is_process_running
class Settings:
'''Settings in P4V config file'''
def __init__(self, name, value):
self.name = name
self.value = value
self.children = []
def indent_level(line):
'''Indent level of line (number of tabs at the beginning)'''
return match("^\t*", line).end()
def parse_line(line):
'''Parse settings line'''
fields = line.strip().split("=")
if len(fields) == 1:
fields.append("")
return Settings(fields[0], unquote(fields[1]))
# Parsing algorithm:
# As long as indentation level stays the same or increases we push items to
# the stack
# When indentation level decreases we group all items in same indentation
# level and add them to the children of the parent
def parse_settings(filename):
'''Parser P4V settings file. Return list of trees'''
stack = []
fo = open(filename, "rt")
for line in fo:
indent = indent_level(line)
new = parse_line(line)
# 1'st item
if not stack:
stack.append((new, indent))
continue
last_indent = stack[-1][1]
if indent >= last_indent:
stack.append((new, indent))
continue
items = []
while indent < last_indent:
if stack[-1][1] == last_indent:
items.insert(0, stack.pop()[0])
continue
stack[-1][0].children += items
items = []
last_indent = stack[-1][1]
stack.append((new, indent))
fo.close()
return [s[0] for s in stack]
def print_tree(tree, fo=stdout, indent=0):
'''Print tree of settings'''
if tree.value:
print >> fo, ("\t" * indent) + ("%s=%s" % (tree.name, tree.value))
else:
name = tree.name
if (indent == 0) and (not name.endswith(":")):
name += "="
elif name in ("directory", "prompttext"):
name += "="
print >> fo, ("\t" * indent) + name
for child in tree.children:
print_tree(child, fo, indent + 1)
def new_addin(id, args):
'''Create new adding setting tree'''
addin = Settings("macro%d" % id, "@")
for key, value in args.items():
if is_boolean(key) and (value not in ("yes", "no")):
raise InstallError("%s/%s - bad boolean value" % \
(addin["name"], key))
addin.children.append(Settings(key, quote(value)))
return addin
def find_node(name, nodes):
'''Find a node named "name" in list of noded'''
for node in nodes:
if node.name == name:
return node
return None
def find_macro(name, macros):
for mac in macros:
name_node = find_node("name", mac.children)
assert(name_node)
if name_node.value == name:
return mac
def config_path(name):
return join(home, ".p4qt", name)
def install_old(dest, addins):
cfg_file = config_path("settings")
settings = parse_settings(cfg_file)
# Find "Macros"
macros = find_node("Macros:", settings)
if not macros:
macros = find_node("Macros", settings)
if not macros:
raise InstallError("bad configuration file (no 'Macros')")
if macros.name.endswith(":"):
macros.name = macros.name[:-1]
macros.value = "@"
# Update addins
inst_count = 0
for addin in addins:
inst_count += 1
addin["command"] = join(dest, addin["command"])
if addin.get("directory", "") == "$install":
addin["directory"] = dest
# Is this just an update?
mac = find_macro(addin["name"], macros.children)
if not mac:
mac = new_addin(len(macros.children), addin)
macros.children.append(mac)
else:
for key in addin.keys():
find_node(key, mac.children).value = addin[key]
fo = open(cfg_file, "wt")
for s in settings:
print_tree(s, fo)
fo.close()
return inst_count
def yesno2truefalse(yesno):
return {
"yes" : "true",
"no" : "false"
}[yesno]
def node_with_text(name, text):
node = Element(name)
node.text = text
return node
def value(addin, name):
return addin[name[0].lower() + name[1:]]
def new_xml_tool(addin, dest):
tool = Element("CustomToolDef", {"varName" : "customtooldef"})
definition = Element("Definition")
tool.append(definition)
for name in ("Name", "Command", "Arguments"):
definition.append(node_with_text(name, value(addin, name)))
definition.append(node_with_text("InitDir", dest))
for name in ("AddToContext", "Refresh"):
tool.append(node_with_text(name, yesno2truefalse(value(addin, name))))
tool.append(node_with_text("IgnoreP4Config", "true"))
return tool
def update_xml_tool(tool, addin, dest):
definition = tool.find("Definition")
for attr in ("Command", "Arguments"):
node = definition.find(attr)
node.text = value(addin, attr)
node = definition.find("InitDir")
node.text = dest
for name in ("AddToContext", "Refresh"):
node = tool.find(name)
node.text = yesno2truefalse(value(addin, name))
node = tool.find("IgnoreP4Config")
node.text = "true"
def find_tool(xml, name):
tool_list = xml.findall("CustomToolDef")
for tool in tool_list:
definition = tool.find("Definition")
if definition.find("Name").text == name:
return tool
return None
def install_new(dest, addins):
cfg_file = config_path("customtools.xml")
tools = XML(open(cfg_file).read())
for addin in addins:
tool = find_tool(tools, addin["name"])
if not tool:
tools.append(new_xml_tool(addin, dest))
else:
update_xml_tool(tool, addin, dest)
fo = open(cfg_file, "wt")
fo.write('<?xml version="1.0" encoding="utf-8"?>\n')
fo.write(tostring(tools))
fo.close()
def install(dest, exclude=None, check_process=0):
'''Install new addins'''
if check_process and is_process_running("p4v"):
raise InstallError("P4V is running, close it")
all_addins = load_config()
if exclude:
addins = [addin for addin in all_addins if addin.name not in exclude]
else:
addins = all_addins
ok = 2
try:
install_old(dest, addins)
except IOError:
ok -= 1
try:
install_new(dest, addins)
except IOError:
ok -= 1
if not ok:
raise InstallError
if __name__ == "__main__":
from optparse import OptionParser
parser = OptionParser("usage: %prog [options] DESTINATION")
parser.add_option("-e", help="exclude addin from install", dest="exclude",
action="append", metavar="ADDIN")
parser.add_option("-c", help="check that p4win is not running",
dest="check", default=0, action="store_true")
opts, args = parser.parse_args()
if len(args) != 1:
parser.error("wrong number of arguments") # Will exit
dest = args[0]
try:
install(dest, opts.exclude, opts.check)
except InstallError, e:
raise SystemExit("error: %s" % e)