def create_db(self, name, character_set = "", collate = "", if_not_exists = True, retry = 1):
"""
creates new database using data base name, character_set, and collate
@param name: name of database to be created
@param character_set: character set of the database
@param collate: the collation of the database
@param if_not_exist: only creates the database if it does not exist
@param retry: The number of times to retry execution on error
@rtype: bool
@return: True on success
@raise InvalidParameterError: If method parameters are invalid in type.
@raise DbCreateError: if failed to create the database.
"""
if False == Validator.validate_non_empty_string(name):
raise InvalidParameterError('name', 'name should be a non-empty string')
if False == Validator.validate_string(character_set):
raise InvalidParameterError('character_set', 'character_set should be a string')
if False == Validator.validate_string(collate):
raise InvalidParameterError('collate', 'collate should be a string')
if False == Validator.validate_boolean(if_not_exists):
raise InvalidParameterError('if_not_exist', 'should be a boolean')
while True:
try:
statement = "CREATE DATABASE %s %s"
conn = MySQLdb.connect(host = self.__host, user = self.__username, passwd = self.__password, port = self.__port)
transaction = conn.cursor()
if True == if_not_exists:
statement = statement % ("IF NOT EXISTS", name)
else:
statement = statement % ("", name)
if 0 != len(character_set):
statement = statement + " CHARACTER SET = %s " % (character_set)
if 0 != len(collate):
statement = statement + " COLLATE = %s " % (collate)
AppLogger.debug('Executing SQL command "%s"' % (statement))
transaction.execute(statement)
return True
except Exception, e:
retry = retry - 1
if 0 == retry:
raise DbCreateError, str(e)
def __init__(self, match_pattern):
'''
@param match_pattern: regular expretion string
'''
if not Validator.validate_string(match_pattern):
raise InvalidParameterError("match_pattern", "Must be a string value")
self.match_pattern = match_pattern
def __init__(self, host, port, username = "", password = ""):
"""
"""
if not Validator.validate_non_empty_string(host):
raise InvalidParameterError("host", "Must be non-empty String")
if not Validator.validate_integer(port):
raise InvalidParameterError("port", "Must be an integer value")
if not Validator.validate_string(username):
raise InvalidParameterError("username", "Must be a string value")
if not Validator.validate_string(password):
raise InvalidParameterError("password", "Must be a string value")
super(SqlClient, self).__init__()
self.__host = host
self.__port = port
self.__username = username
self.__password = password
self.__platform = Platform.get_current()
def __init__(self, repository_path, username = '', password = ''):
"""
@param repository_path: path of the root of the repository
@param username: user name to access the subversion (if it was authenticated)
@param password: password to access the subversion (if it was authenticated)
"""
if not Validator.validate_non_empty_string(repository_path):
raise InvalidParameterError("repository_path", "Must be a non-empty string")
if not Validator.validate_string(username):
raise InvalidParameterError("username", "Must be a string")
if not Validator.validate_string(password):
raise InvalidParameterError("password", "Must be a string")
VersionControlSystemClient.__init__(self, repository_path, username, password)
self.__client = pysvn.Client()
if username and password:
self.set_user(username, password)
self.local_client = LocalClient()
def export(self, local_path, path = "/", revision = 0, retry = 1):
"""
export a directory from the subversion server that is spesified by path parameter
@param local_path: local path on local machine where the directory will be checked out.
@param path: path of directory on subversion servern that will be checked out.
@param replace: if true replaces the existing local working diretory.
@param revision: revision number to checkout, 0 to checkout the last revision.
@param retry: number of retries before fail.
@raise CheckOutError in case of failure
"""
if not Validator.validate_non_empty_string(local_path):
raise InvalidParameterError("local_path", "Must be non-empty string")
if not Validator.validate_string(path):
raise InvalidParameterError("path", "Must be a string value")
if not Validator.validate_integer(revision):
raise InvalidParameterError("revision", "Must be an integer value")
if not Validator.validate_integer(retry):
raise InvalidParameterError("retry", "Must be an integer value")
export_path = os.path.join(self.repository_path, path.lstrip("/"))
if os.path.exists(local_path):
raise FileExistsError, "the path where you check out is already exists"
while True:
try:
if 0 == revision:
return self.__client.export(
export_path,
local_path,
True,
)
else:
return self.__client.export(
export_path,
local_path,
True,
pysvn.Revision(pysvn.opt_revision_kind.number, revision)
)
except Exception, e:
retry -= 1
if 0 == retry:
raise CheckOutError(
'Failed to export "%s" to "%s"."' % (export_path, local_path)
)
else:
shutil.rmtree(local_path, True)
def match(self, match_string):
'''
matches pattern in body of response
@param match_string: string to be matched (body of response)
'''
if not Validator.validate_string(match_string):
raise InvalidParameterError("match_string", "Must be a string value")
matchs = re.findall(self.match_pattern, match_string)
if not matchs:
raise MatchDataError
data = matchs[0]
data_key = (re.findall('name[ ]*=[ ]*".*"',data))[0]
data_value = (re.findall('value[ ]*=[ ]*".*"',data))[0]
if not (data_key and data_value):
raise MatchDataError
return (data_key.split('"'))[1], (data_value.split('"'))[1]
def __init__(self, platform, root):
"""
This is an abstract class and cannot be instantiated directly.
@param __platform: the server's platform
"""
if self.__class__ == FileClient:
raise NotSupportedError()
if Platform != platform.__class__:
raise InvalidParameterError('platform', 'Must be instance of Platform')
# prepare the root
if False == Validator.validate_string(root):
raise InvalidParameterError('root', 'root should be a string')
if len(root) != 0 and (platform.get_platform() == Platform.PLATFORM_POSIX):
if root[0] != '/':
raise InvalidParameterError('root', "root should start with '/'")
elif len(root) != 0 and platform.get_platform() == Platform.PLATFORM_WINDOWS:
if not re.match(r'[a-zA-Z]:\\', root[0:3]):
raise InvalidParameterError('root', "root should start format like 'C:\\'")
#if len(root) != 0 and (platform.get_platform() == Platform.PLATFORM_POSIX) and root[-1] != '/':
#root += '/'
#elif len(root) != 0 and platform.get_platform() == Platform.PLATFORM_WINDOWS and root[-1] != '\\':
#root += '\\'
if len(root) == 0:
root = platform.get_root()
else:
root = root.rstrip(platform.get_separator()) + platform.get_separator()
self.__platform = platform
self.__root = root
def get_file_list(self, path, recursive = False, retry = 1):
"""
list file on subversion server given a spesified path
raise ListFileError on failure
"""
if not Validator.validate_string(path):
raise InvalidParameterError("local_path", "Must be a string value")
if not Validator.validate_boolean(recursive):
raise InvalidParameterError("recursive", "Must be a boolean value")
if not Validator.validate_integer(retry):
raise InvalidParameterError("retry", "Must be an integer value")
path = self.local_client.get_platform().trim_path(path)
while retry:
retry -= 1
try:
return self.__client.ls(self.repository_path + path, recurse = recursive)
except Exception, e:
if retry == 0:
raise ListFileError("Repository path: " + self.repository_path + path, str(e))
else:
break
