# 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 re

import tempfile

import shutil

from utilities import bash

class configFileOps:

class entry:

def __init__(self, name, value, op, separator):

self.name = name

self.value = value

self.state = "new"

self.op = op

self.separator = separator

def setState(self, state):

self.state = state

def getState(self):

return self.state

def __init__(self, fileName, cfg=None):

self.fileName = fileName

self.entries = []

self.backups = []

if cfg is not None:

cfg.cfoHandlers.append(self)

def addEntry(self, name, value, separator="="):

e = self.entry(name, value, "add", separator)

self.entries.append(e)

def rmEntry(self, name, value, separator="="):

entry = self.entry(name, value, "rm", separator)

self.entries.append(entry)

def getEntry(self, name, separator="="):

try:

ctx = file(self.fileName).read(-1)

match = re.search("^" + name + ".*", ctx, re.MULTILINE)

if match is None:

return ""

line = match.group(0).split(separator, 1)

return line[1]

except:

return ""

def save(self):

fp = open(self.fileName, "r")

newLines = []

for line in fp.readlines():

matched = False

for entry in self.entries:

if entry.op == "add":

if entry.separator == "=":

matchString = "^\ *" + entry.name + ".*"

elif entry.separator == " ":

matchString = "^\ *" + entry.name + "\ *" + entry.value

else:

if entry.separator == "=":

matchString = "^\ *" + entry.name + "\ *=\ *" + entry.value

else:

matchString = "^\ *" + entry.name + "\ *" + entry.value

match = re.match(matchString, line)

if match is not None:

if entry.op == "add" and entry.separator == "=":

newline = "\n" + entry.name + "=" + entry.value + "\n"

entry.setState("set")

newLines.append(newline)

self.backups.append([line, newline])

matched = True

break

elif entry.op == "rm":

entry.setState("set")

self.backups.append([line, None])

matched = True

break

if not matched:

newLines.append(line)

for entry in self.entries:

if entry.getState() != "set":

if entry.op == "add":

newline = entry.name + entry.separator + entry.value + "\n"

newLines.append(newline)

self.backups.append([None, newline])

entry.setState("set")

fp.close()

file(self.fileName, "w").writelines(newLines)

def replace_line(self, startswith,stanza,always_add=False):

lines = [ s.strip() for s in file(self.fileName).readlines() ]

newlines = []

replaced = False

for line in lines:

if re.search(startswith, line):

if stanza is not None:

newlines.append(stanza)

self.backups.append([line, stanza])

replaced = True

else: newlines.append(line)

if not replaced and always_add:

newlines.append(stanza)

self.backups.append([None, stanza])

newlines = [ s + '\n' for s in newlines ]

file(self.fileName,"w").writelines(newlines)

def replace_or_add_line(self, startswith,stanza):

return self.replace_line(startswith,stanza,always_add=True)

def add_lines(self, lines, addToBackup=True):

fp = file(self.fileName).read(-1)

sh = re.escape(lines)

match = re.search(sh, fp, re.MULTILINE)

if match is not None:

return

fp += lines

file(self.fileName, "w").write(fp)

self.backups.append([None, lines])

def replace_lines(self, src, dst, addToBackup=True):

fp = file(self.fileName).read(-1)

sh = re.escape(src)

if dst is None:

dst = ""

repl,nums = re.subn(sh, dst, fp)

if nums <=0:

return

file(self.fileName, "w").write(repl)

if addToBackup:

self.backups.append([src, dst])

def append_lines(self, match_lines, append_lines):

fp = file(self.fileName).read(-1)

sh = re.escape(match_lines)

match = re.search(sh, fp, re.MULTILINE)

if match is None:

return

sh = re.escape(append_lines)

if re.search(sh, fp, re.MULTILINE) is not None:

return

newlines = []

for line in file(self.fileName).readlines():

if re.search(match_lines, line) is not None:

newlines.append(line + append_lines)

self.backups.append([line, line + append_lines])

else:

newlines.append(line)

file(self.fileName, "w").writelines(newlines)

def backup(self):

for oldLine, newLine in self.backups:

if newLine is None:

self.add_lines(oldLine, False)

else:

self.replace_lines(newLine, oldLine, False)