def load(self, properties):
alter = File(properties.get_property("alter.dir"))
if alter.exists():
files = Files()
for version in files.list(alter):
self.__versions.add(Version(version.tail()))
create = File(properties.get_property("create.dir"))
if create.exists():
self.__versions.add(
Version(properties.get_property("default_version")))
def load(self, properties):
"""
Find all versions on the current project and add them to the list.
:param properties: An instance of ``noora.system.Properties.Properties``.
"""
alter = File(properties.get("alter.dir"))
if alter.exists():
files = Files()
for version in files.list(alter):
self.__versions.add(Version(version.tail()))
create = File(properties.get("create.dir"))
if create.exists():
self.__versions.add(Version(properties.get("default_version")))
def execute(connector, executor, properties, folder):
filters = Filters()
excluded_folders = properties.get_property('excluded_folders')
for excluded_folder in excluded_folders:
ef = File(excluded_folder)
ff = FileFolderFilter(ef)
filters.add(ff)
excluded_extensions = properties.get_property('excluded_extensions')
for excluded_extension in excluded_extensions:
ef = File("*." + excluded_extension)
ff = FileExtensionFilter(ef)
filters.add(ff)
excluded_files = properties.get_property('excluded_files')
for excluded_file in excluded_files:
ef = File(excluded_file)
ff = FileFilter(ef)
filters.add(ff)
if folder.is_dir():
files = Files.list(folder)
for file in files:
if not filters.accept(file) and not file.is_dir():
url = file.get_url()
print url
executor['script'] = file
connector.execute(executor, properties)
def execute(connector, executor, properties, folder):
"""
Execute all applicable files in the specified folder.
:type connector: noora.connectors.Connector.Connector
:param connector: A connector instance;
:type executor: dict
:param executor: Settings and credentials for the connector;
:type properties: noora.system.Properties.Properties
:param properties: Project properties;
:param folder: The target folder to execute.
"""
filters = Filters()
excluded_folders = properties.get('excluded_folders')
for excluded_folder in excluded_folders:
ef = File(excluded_folder)
ff = FileFolderFilter(ef)
filters.add(ff)
excluded_extensions = properties.get('excluded_extensions')
for excluded_extension in excluded_extensions:
ef = File("*." + excluded_extension)
ff = FileExtensionFilter(ef)
filters.add(ff)
excluded_files = properties.get('excluded_files')
for excluded_file in excluded_files:
ef = File(excluded_file)
ff = FileFilter(ef)
filters.add(ff)
if folder.is_dir():
files = Files.list(folder)
for file in files:
if not filters.accept(file) and not file.is_dir():
url = file.get_url()
print(url)
executor['script'] = file
connector.execute(executor, properties)
def execute(self, arguments, properties):
project = ''
version = None
if arguments.v:
version = arguments.v
current_dir = properties.get_property('current.dir')
project_file = properties.get_property('project.file')
config_file = File(os.path.join(current_dir, project_file))
if not config_file.exists():
database = raw_input('database : ')
project = database + "-db"
host = raw_input('host [localhost] : ')
host = Ora.nvl(host, "localhost")
username = raw_input('username : '******'password : '******'version [1.0.0]: ')
version = Ora.nvl(version, "1.0.0")
os.mkdir(project)
template_dir = os.path.join(properties.get_property('plugin.dir'), 'mysql', 'generate', 'templates')
template_file = os.path.join(template_dir, project_file)
f = open(template_file)
stream = f.read()
f.close()
stream = stream.replace('{host}', host)
stream = stream.replace('{database}', database)
stream = stream.replace('{username}', username)
stream = stream.replace('{password}', password)
stream = stream.replace('{version}', version)
config_file = os.path.join(current_dir, project, project_file)
f = open(config_file, 'w')
f.write(stream)
f.close()
properties.set_property('alter.dir', os.path.join(current_dir, project, 'alter'))
properties.set_property('create.dir', os.path.join(current_dir, project, 'create'))
config_file = os.path.join(current_dir, project, project_file)
f = open(config_file)
data = json.load(f)
for key in data.keys():
properties.set_property(key, data[key])
f.close()
versions = Versions()
version_loader = VersionLoader(versions)
version_loader.load(properties)
versions.sort()
version_guesser = VersionGuesser(properties, versions)
next_version = version_guesser.guess(version).to_string()
version_dir = version_guesser.to_folder(next_version)
# create the version folder
os.makedirs(version_dir)
databases = properties.get_property('databases')
version_database = properties.get_property('version_database')
default_version = properties.get_property('default_version')
environments = properties.get_property('environments')
objects = properties.get_property('create_objects')
for database in databases:
# create the scheme folder
database_dir = os.path.join(version_dir, database)
os.mkdir(database_dir)
# create the dat folder
dat_dir = os.path.join(database_dir, 'dat')
os.mkdir(dat_dir)
# create the version script in the dat folder
if database == version_database:
version_file = os.path.join(dat_dir, 'version.sql')
f = open(version_file, 'w')
if next_version == default_version:
stream = properties.get_property('version_insert_statement')
else:
stream = properties.get_property('version_update_statement')
stream = stream.replace('<version>', next_version)
f.write(stream)
f.close()
# sqlScript=self.getSqlVersionStatement(versions, version)
# projectHelper.writeFile(datFolder+os.sep+'version.sql', sqlScript)
# create the environment folders in the dat folder
for environment in environments:
os.mkdir(os.path.join(dat_dir, environment))
# create the environment script in the dat folder.
if database == version_database and next_version == default_version:
environment_file = os.path.join(dat_dir, environment, 'environment.sql')
f = open(environment_file, 'w')
stream = properties.get_property('environment_insert_statement')
stream = stream.replace('<environment>', environment)
f.write(stream)
f.close()
# create the ddl folder
ddl_dir = os.path.join(database_dir, 'ddl')
os.mkdir(ddl_dir)
# create the object folders in the ddl folder
for object in objects:
os.mkdir(os.path.join(ddl_dir, object))
# create the template code on create.
if database == version_database and next_version == default_version:
for object in objects:
object_dir = os.path.join(template_dir, object)
if os.path.exists(object_dir):
files = Files.list(File(object_dir))
for file in files:
shutil.copyfile(file.get_url(), os.path.join(ddl_dir, object, file.tail()))
print "version " + next_version + " created."
def execute(self, arguments, properties):
properties.set_property('create.dir', os.path.join(properties.get_property('current.dir'), 'create'))
properties.set_property('alter.dir', os.path.join(properties.get_property('current.dir'), 'alter'))
version = arguments.v
Fail.fail_on_no_version(version)
Fail.fail_on_unknown_version(version, properties)
default_databases = properties.get_property('databases')
databases = Ora.nvl(arguments.d, default_databases)
Fail.fail_on_invalid_database(arguments.d, properties)
current_dir = properties.get_property('current.dir')
component_name = properties.get_property('component_name')
target_dir = os.path.join(current_dir, properties.get_property('component_target_folder'))
objects = properties.get_property('create_objects')
build_dir = App.build_dir(version, properties)
# exclude the file 'version.sql', this file is excluded from the dat listing below.
component_excluded_files = properties.get_property('component_excluded_files')
excluded_files = properties.get_property('excluded_files')
excluded_files.extend(component_excluded_files)
# create the target folder, if not present.
if not File(target_dir).exists():
os.makedirs(target_dir)
print "building component with version '" + version + "'"
zip_file = os.path.join(target_dir, component_name + '_' + version + '.zip')
zip_handle = ZipFile(zip_file, 'w')
for database in databases:
for object in objects:
if not object == 'lib':
# global ddl objects
folder = File(os.path.join(build_dir, database, 'ddl', object))
zip_dir = File(os.path.join(component_name + '_' + version, 'ddl', object))
files = Files.list_filtered(folder, properties)
for file in files:
print file.get_url()
target_file = File(os.path.join(zip_dir.get_url(), file.tail()))
zip_handle.write(file.get_url(), target_file.get_url(), ZIP_DEFLATED)
# global dat files
folder = File(os.path.join(build_dir, database, 'dat'))
zip_dir = File(os.path.join(component_name + '_' + version, 'dat'))
files = Files.list_filtered(folder, properties)
for file in files:
print file.get_url()
target_file = File(os.path.join(zip_dir.get_url(), file.tail()))
zip_handle.write(file.get_url(), target_file.get_url(), ZIP_DEFLATED)
# create the version script in the dat folder
version_statement = self.version_statement(version, properties)
version_statement = version_statement.replace('<version>', version)
version_statement = version_statement.replace('<name>', component_name)
f = open('version.sql', 'w')
f.write(version_statement)
f.close()
zip_dir = File(os.path.join(component_name + '_' + version, 'dat'))
target_file = File(os.path.join(zip_dir.get_url(), 'version.sql'))
zip_handle.write('version.sql', target_file.get_url())
# remove the version.sql file.
os.remove('version.sql')
# create the checkversion script in the root folder
# first retrieve the previous version for the checkversion script
versions = Versions()
version_loader = VersionLoader(versions)
version_loader.load(properties)
versions.sort()
previous = versions.previous(Version(version))
component_select_statement = properties.get_property("component_select_statement")
component_select_statement = component_select_statement.replace('<name>', component_name)
component_select_statement = component_select_statement.replace('<previous>', previous.get_value())
print component_select_statement
f = open('checkversion.sql', 'w')
f.write(component_select_statement)
f.close()
zip_dir = File(os.path.join(component_name + '_' + version))
target_file = File(os.path.join(zip_dir.get_url(), 'checkversion.sql'))
zip_handle.write('checkversion.sql', target_file.get_url())
# remove the version.sql file.
os.remove('checkversion.sql')
zip_handle.close()
print "component with version " + version + " created."
def execute(self, properties, arguments):
"""
Build the package after verifying version is valid, and database,
if provided.
:param properties: The project properties
:param arguments: A dict of {
'version': 'The version to package for'
'database': 'The database to package for (optional)'
}
"""
prepared_args = self._validate_and_prepare(properties, arguments)
version = prepared_args['version']
databases = prepared_args['databases']
current_dir = properties.get('current.dir')
component_name = properties.get('component_name')
target_dir = os.path.join(current_dir, properties.get('component_target_folder'))
objects = properties.get('create_objects')
if version == properties.get("default_version"):
build_dir = properties.get("create.dir")
else:
build_dir = os.path.join(properties.get("alter.dir"), version)
# exclude the file 'version.sql', this file is excluded from the dat listing below.
component_excluded_files = properties.get('component_excluded_files')
excluded_files = properties.get('excluded_files')
excluded_files.extend(component_excluded_files)
# create the target folder, if not present.
if not File(target_dir).exists():
os.makedirs(target_dir)
print("building component with version '{}'".format(version))
zip_file = os.path.join(target_dir, component_name + '_' + version + '.zip')
zip_handle = ZipFile(zip_file, 'w')
for database in databases:
for obj in objects:
if not obj == 'lib':
# global ddl objects
folder = File(os.path.join(build_dir, database, 'ddl', obj))
zip_dir = File(os.path.join(component_name + '_' + version, 'ddl', obj))
files = Files.list_filtered(folder, properties)
for file in files:
print(file.get_url())
target_file = File(os.path.join(zip_dir.get_url(), file.tail()))
zip_handle.write(file.get_url(), target_file.get_url(), ZIP_DEFLATED)
# global dat files
folder = File(os.path.join(build_dir, database, 'dat'))
zip_dir = File(os.path.join(component_name + '_' + version, 'dat'))
files = Files.list_filtered(folder, properties)
for file in files:
print(file.get_url())
target_file = File(os.path.join(zip_dir.get_url(), file.tail()))
zip_handle.write(file.get_url(), target_file.get_url(), ZIP_DEFLATED)
# create the version script in the dat folder
if version == properties.get("default_version"):
version_statement = properties.get("component_insert_statement")
else:
version_statement = properties.get("component_update_statement")
version_statement = version_statement.replace('<version>', version)
version_statement = version_statement.replace('<name>', component_name)
f = open('version.sql', 'w')
f.write(version_statement)
f.close()
zip_dir = File(os.path.join(component_name + '_' + version, 'dat'))
target_file = File(os.path.join(zip_dir.get_url(), 'version.sql'))
zip_handle.write('version.sql', target_file.get_url())
# remove the version.sql file.
os.remove('version.sql')
# create the checkversion script in the root folder
# first retrieve the previous version for the checkversion script
versions = Versions()
version_loader = VersionLoader(versions)
version_loader.load(properties)
versions.sort()
previous = versions.previous(Version(version))
component_select_statement = properties.get("component_select_statement")
component_select_statement = component_select_statement.replace('<name>', component_name)
component_select_statement = component_select_statement.replace(
'<previous>', previous.get_value())
print(component_select_statement)
f = open('checkversion.sql', 'w')
f.write(component_select_statement)
f.close()
zip_dir = File(os.path.join(component_name + '_' + version))
target_file = File(os.path.join(zip_dir.get_url(), 'checkversion.sql'))
zip_handle.write('checkversion.sql', target_file.get_url())
# remove the version.sql file.
os.remove('checkversion.sql')
zip_handle.close()
print("component with version {} created.".format(version))
def execute(self, properties, arguments):
"""
Create or upgrade a project. The version is always required, the rest
only when generating an entirely new project.
:type properties: system.Properties.Properties
:param properties: The project properties
:type arguments: dict
:param arguments: This dict contains the plugin arguments:
* **version**: (Initial) project version to generate for;
* **host**: The hostname for the new project. If not provided, an upgrade is assumed (optional);
* **port**: Port to connect to (optional);
* **database**: Name of the database (optional);
* **schema**: Name of the schema (optional);
* **username**: Database username (optional);
* **password**: Database password (optional).
"""
prepared_args = self._validate_and_prepare(properties, arguments)
template_dir = os.path.join(properties.get('plugin.dir'), 'mssql',
'generate', 'templates')
versions = Versions()
version_loader = VersionLoader(versions)
version_loader.load(properties)
versions.sort()
version_guesser = VersionGuesser(properties, versions)
next_version = version_guesser.guess(
prepared_args.get('version')).to_string()
version_dir = version_guesser.to_folder(next_version)
# create the version folder
os.makedirs(version_dir)
schemes = properties.get('schemes')
version_schema = properties.get('version_schema')
default_version = properties.get('default_version')
environments = properties.get('environments')
objects = properties.get('create_objects')
for schema in schemes:
# create the scheme folder
schema_dir = os.path.join(version_dir, schema)
os.mkdir(schema_dir)
# create the dat folder
dat_dir = os.path.join(schema_dir, 'dat')
os.mkdir(dat_dir)
# create the version script in the dat folder
if schema == version_schema:
version_file = os.path.join(dat_dir, 'version.sql')
f = open(version_file, 'w')
if next_version == default_version:
stream = properties.get('version_insert_statement')
else:
stream = properties.get('version_update_statement')
stream = stream.replace('<version>', next_version)
f.write(stream)
f.close()
# FIXME: remove?
# sqlScript=self.getSqlVersionStatement(versions, version)
# projectHelper.writeFile(datFolder+os.sep+'version.sql', sqlScript)
# create the environment folders in the dat folder
for environment in environments:
os.mkdir(os.path.join(dat_dir, environment))
# create the environment script in the dat folder.
if schema == version_schema and next_version == default_version:
environment_file = os.path.join(dat_dir, environment,
'environment.sql')
f = open(environment_file, 'w')
stream = properties.get('environment_insert_statement')
stream = stream.replace('<environment>', environment)
f.write(stream)
f.close()
# create the ddl folder
ddl_dir = os.path.join(schema_dir, 'ddl')
os.mkdir(ddl_dir)
# create the object folders in the ddl folder
for obj in objects:
os.mkdir(os.path.join(ddl_dir, obj))
# create the template code on create.
if schema == version_schema and next_version == default_version:
for obj in objects:
object_dir = os.path.join(template_dir, obj)
if os.path.exists(object_dir):
files = Files.list(File(object_dir))
for file in files:
shutil.copyfile(
file.get_url(),
os.path.join(ddl_dir, obj, file.tail()))
print("version {} created.".format(next_version))