def create_service(self):
""" Creates a WssServiceClient with the destination url"""
if ("url_destination" in self.configDict) and (self.configDict["url_destination"] != ""):
self.service = WssServiceClient(self.configDict["url_destination"], self.proxySetting)
else:
self.service = WssServiceClient("https://saas.whitesourcesoftware.com/agent", self.proxySetting)
logging.debug("The destination url is set to: " + self.service.to_string())
def create_service(self):
""" Creates a WssServiceClient with the destination url"""
if ('url_destination' in self.configDict) and (self.configDict['url_destination'] != ''):
self.service = WssServiceClient(self.configDict['url_destination'], self.proxySetting)
else:
self.service = WssServiceClient("https://saas.whitesourcesoftware.com/agent", self.proxySetting)
logging.debug("The destination url is set to: " + self.service.to_string())
class SetupToolsCommand(Command):
"""setuptools Command"""
description = "Setuptools WSS plugin"
user_options = [("pathConfig=", "p", "Configuration file path"), ("debug=", "d", "Show debugging output")]
def initialize_options(self):
self.debug = None
self.proxySetting = None
self.service = None
self.configDict = None
self.pathConfig = None
self.token = None
self.userEnvironment = None
self.distDepend = None
self.pkgIndex = PackageIndex()
self.dependencyList = []
self.projectCoordinates = None
self.tmpdir = tempfile.mkdtemp(prefix="wss_python_plugin-")
def finalize_options(self):
# log file activation and config
if self.debug == "y":
logging.basicConfig(
format="%(asctime)s%(levelname)s:%(message)s", level=logging.DEBUG, filename="wss_plugin.log"
)
# load and import config file
try:
sys.path.append(self.pathConfig)
self.configDict = __import__("config_file").config_info
logging.info("Loading config_file was successful")
except Exception as err:
sys.exit("Can't import the config file." + err.message)
# load proxy setting if exist
if "proxy" in self.configDict:
self.proxySetting = self.configDict["proxy"]
if "index_url" in self.configDict:
self.pkgIndex = PackageIndex(index_url=self.configDict["index_url"])
self.projectCoordinates = Coordinates.create_project_coordinates(self.distribution)
self.userEnvironment = pk_res.Environment(get_python_lib(), platform=None, python=None)
distribution_specification = self.distribution.get_name() + "==" + self.distribution.get_version()
distribution_requirement = pk_res.Requirement.parse(distribution_specification)
# resolve all dependencies
try:
self.distDepend = pk_res.working_set.resolve([distribution_requirement], env=self.userEnvironment)
self.distDepend.pop(0)
logging.info("Finished resolving dependencies")
except Exception as err:
print "distribution was not found on this system, and is required by this application", err.message
def run(self):
self.validate_config_file()
self.scan_modules()
self.create_service()
self.run_plugin()
def validate_config_file(self):
""" Validate content of config file params """
# org token
if "org_token" in self.configDict:
if self.configDict["org_token"] == "":
sys.exit("Organization token is empty")
else:
sys.exit("No organization token option exists")
logging.info("Validation of config file was successful")
# Todo: check existence of other keys in dict
def scan_modules(self):
""" Downloads all the dependencies calculates their sha1 and creates a list of dependencies info"""
if self.distDepend is not None:
for dist in self.distDepend:
try:
# create a dist instance from requirement instance
current_requirement = dist.as_requirement()
current_distribution = self.pkgIndex.fetch_distribution(
current_requirement, self.tmpdir, force_scan=True, source=True, develop_ok=True
)
# create dep. root
if current_distribution is not None:
self.dependencyList.append(create_dependency_record(current_distribution))
except Exception as err:
print "Error in fetching dists " + dist.key + " " + dist.version
logging.info("Finished calculation for all dependencies")
else:
logging.info("No dependencies were found")
shutil.rmtree(self.tmpdir)
def create_service(self):
""" Creates a WssServiceClient with the destination url"""
if ("url_destination" in self.configDict) and (self.configDict["url_destination"] != ""):
self.service = WssServiceClient(self.configDict["url_destination"], self.proxySetting)
else:
self.service = WssServiceClient("https://saas.whitesourcesoftware.com/agent", self.proxySetting)
logging.debug("The destination url is set to: " + self.service.to_string())
def run_plugin(self):
""" Initializes the plugin requests"""
org_token = self.configDict["org_token"]
project = self.create_project_obj()
product = ""
product_version = ""
if "product_name" in self.configDict:
product = self.configDict["product_name"]
if "product_version" in self.configDict:
product_version = self.configDict["product_version"]
self.check_policies(project, org_token, product, product_version)
self.update_inventory(project, org_token, product, product_version)
def create_project_obj(self):
""" create the actual project """
project_token = None
if "project_token" in self.configDict:
project_token = self.configDict["project_token"]
if project_token == "":
project_token = None
return AgentProjectInfo(self.projectCoordinates, self.dependencyList, project_token)
def check_policies(self, project_info, token, product_name, product_version):
""" Sends the check policies request to the agent according to the request type """
if ("check_policies" in self.configDict) and (self.configDict["check_policies"]):
logging.debug("Checking policies")
projects = [project_info]
request = CheckPoliciesRequest(token, product_name, product_version, projects)
result = self.service.check_policies(request)
try:
self.handle_policies_result(result)
except Exception as err:
sys.exit("Some dependencies do not conform with open source policies")
def handle_policies_result(self, result):
""" Checks if any policies rejected if so stops """
logging.debug("Creating policies report")
if result.has_rejections():
print_policies_rejection(result)
logging.info("Some dependencies do not conform with open source policies")
raise
else:
logging.debug("All dependencies conform with open source policies")
def update_inventory(self, project_info, token, product_name, product_version):
""" Sends the update request to the agent according to the request type """
logging.debug("Updating White Source")
projects = [project_info]
request = UpdateInventoryRequest(token, product_name, product_version, projects)
result = self.service.update_inventory(request)
print_update_result(result)
class SetupToolsCommand(Command):
"""setuptools Command"""
description = "Setuptools WSS plugin"
user_options = [
('offline=', 'o', 'Offline flag'),
('pathConfig=', 'p', 'Configuration file path'),
('debug=', 'd', 'Show debugging output'),
]
def initialize_options(self):
self.offline = None
self.debug = None
self.proxySetting = None
self.service = None
self.configDict = None
self.pathConfig = None
self.token = None
self.userEnvironment = None
self.distDepend = None
self.pkgIndex = PackageIndex()
self.dependencyList = []
self.projectCoordinates = None
self.tmpdir = tempfile.mkdtemp(prefix="wss_python_plugin-")
def finalize_options(self):
# log file activation and config
if self.debug == 'y':
logging.basicConfig(format='%(asctime)s%(levelname)s:%(message)s', level=logging.DEBUG,
filename='wss_plugin.log')
# load and import config file
try:
sys.path.append(self.pathConfig)
if sys.version_info.major >= 3:
config_file_spec = importlib.util.spec_from_file_location('config_file', self.pathConfig)
config_file_module = importlib.util.module_from_spec(config_file_spec)
config_file_spec.loader.exec_module(config_file_module)
self.configDict = config_file_module.config_info
else:
self.configDict = imp.load_source('config_file', self.pathConfig).config_info
logging.info('Loading config_file was successful')
except Exception as err:
print("Can't import the config file.")
sys.exit(err)
# load proxy setting if exist
if 'proxy' in self.configDict:
self.proxySetting = self.configDict['proxy']
if 'index_url' in self.configDict:
self.pkgIndex = PackageIndex(index_url=self.configDict['index_url'])
self.projectCoordinates = Coordinates.create_project_coordinates(self.distribution)
self.userEnvironment = pk_res.Environment([get_python_lib()], platform=None, python=None)
distribution_specification = self.distribution.get_name() + "==" + self.distribution.get_version()
distribution_requirement = pk_res.Requirement.parse(distribution_specification)
# resolve all dependencies
try:
self.distDepend = pk_res.working_set.resolve([distribution_requirement], env=self.userEnvironment)
self.distDepend.pop(0)
logging.info("Finished resolving dependencies")
except Exception as err:
print("distribution was not found on this system, and is required by this application", err.message)
def run(self):
self.validate_config_file()
self.scan_modules()
self.create_service()
self.run_plugin()
def validate_config_file(self):
""" Validate content of config file params """
# org token
if 'org_token' in self.configDict:
if self.configDict['org_token'] == '':
sys.exit("Organization token is empty")
else:
sys.exit("No organization token option exists")
logging.info("Validation of config file was successful")
# Todo: check existence of other keys in dict
def scan_modules(self):
""" Downloads all the dependencies calculates their sha1 and creates a list of dependencies info"""
if self.distDepend is not None:
for dist in self.distDepend:
try:
# create a dist instance from requirement instance
current_requirement = dist.as_requirement()
current_distribution = self.pkgIndex.fetch_distribution(
current_requirement, self.tmpdir, force_scan=True, source=True, develop_ok=True)
# create dep. root
if current_distribution is not None:
self.dependencyList.append(create_dependency_record(current_distribution))
except Exception as err:
print("Error in fetching dists " + dist.key + " " + dist.version)
logging.info("Finished calculation for all dependencies")
else:
logging.info("No dependencies were found")
shutil.rmtree(self.tmpdir)
def create_service(self):
""" Creates a WssServiceClient with the destination url"""
if ('url_destination' in self.configDict) and (self.configDict['url_destination'] != ''):
self.service = WssServiceClient(self.configDict['url_destination'], self.proxySetting)
else:
self.service = WssServiceClient("https://saas.whitesourcesoftware.com/agent", self.proxySetting)
logging.debug("The destination url is set to: " + self.service.to_string())
def run_plugin(self):
""" Initializes the plugin requests"""
org_token = self.configDict['org_token']
user_key = ''
project = self.create_project_obj()
product = ''
product_version = ''
self.connection_retries = 1
self.connection_retries_interval = 3
self.policy_violation = False
if 'product_name' in self.configDict:
product = self.configDict['product_name']
if 'user_key' in self.configDict:
user_key = self.configDict['user_key']
if 'product_version' in self.configDict:
product_version = self.configDict['product_version']
if 'connection_retries' in self.configDict:
self.connection_retries = self.configDict['connection_retries']
if 'connection_retries_interval' in self.configDict:
self.connection_retries_interval = self.configDict['connection_retries_interval']
if self.configDict.get('offline') or self.offline:
logging.debug("Offline request")
offline_request(project, org_token, user_key, product, product_version)
else:
if self.configDict.get('check_policies'):
logging.debug("Checking policies")
self.check_policies(project, org_token, user_key, product, product_version)
# no policy violations => send update and pass build
if not self.policy_violation:
logging.debug("Updating inventory")
self.update_inventory(project, org_token, user_key, product, product_version)
# policy violation AND force_update
elif self.configDict.get('force_update'):
print("However all dependencies will be force updated to project inventory.")
logging.debug("Updating inventory")
self.update_inventory(project, org_token, user_key, product, product_version)
# fail the build
if self.configDict.get('fail_on_error'):
print("Build failure due to policy violation (fail_on_error = True)")
sys.exit(1)
# policy violation AND (NOT force_update)
elif self.configDict.get('fail_on_error'):
# fail the build
print("Build failure due to policy violation (fail_on_error = True)")
sys.exit(1)
def create_project_obj(self):
""" create the actual project """
project_token = None
if 'project_token' in self.configDict:
project_token = self.configDict['project_token']
if project_token == '':
project_token = None
return AgentProjectInfo(coordinates=self.projectCoordinates, dependencies=self.dependencyList,
project_token=project_token)
def check_policies(self, project_info, token, user_key, product_name, product_version):
""" Sends the check policies request to the agent according to the request type """
projects = [project_info]
force_check_all_dependencies = self.configDict.get('force_check_all_dependencies')
request = CheckPoliciesRequest(token, user_key, product_name, product_version, projects, force_check_all_dependencies)
result = self.service.check_policies(request, self.connection_retries, self.connection_retries_interval)
try:
self.handle_policies_result(result)
except Exception:
logging.warning("Some dependencies do not conform with open source policies")
sys.exit(1)
def handle_policies_result(self, result):
""" Checks if any policies rejected if so stops """
logging.debug("Creating policies report")
if result.has_rejections():
self.policy_violation = True
print("Some dependencies do not conform with open source policies:")
print_policies_rejection(result)
else:
logging.debug("All dependencies conform with open source policies!")
def update_inventory(self, project_info, token, user_key, product_name, product_version):
""" Sends the update request to the agent according to the request type """
logging.debug("Updating White Source")
projects = [project_info]
request = UpdateInventoryRequest(token, user_key, product_name, product_version, projects)
result = self.service.update_inventory(request, self.connection_retries, self.connection_retries_interval)
print_update_result(result)
