class Mellon(application.YamlCliAppMixin):
logger = logging.getLogger(__name__)
app_zcml = (mellon, 'configure.zcml')
def go(self):
v_iter = component.getUtility(container.ISparcPyDictValueIterator)
self.logger.info(
u"searching for MellonFileProviderFactory entries in config file")
for d in v_iter.values(
self.get_config(), 'MellonFileProviderFactory'
): #d is dict of MellonFileProviderFactories keys
fprovider = component.createObject(
d['name'],
d) #assumes named factory provides IMellonFileProviderFactory
if not mellon.IMellonFileProvider.providedBy(fprovider):
self.logger.warn(
u"expected factory %s to create objects providing IMellonFileProvider, skipping"
% str(d['name']))
continue
self.logger.info(
u"found MellonFileProviderFactory config entry with name: {}".
format(d['name']))
try:
for f in fprovider: # iterate the files in the provider
wht_lstd = False
for wht_lst in component.subscribers((f, ),
mellon.IWhitelist):
for wht_lst_info in wht_lst:
self.logger.info(
u"skipping white-listed file: {} because {}".
format(f, wht_lst_info))
wht_lstd = True
if not wht_lstd:
self.logger.info(
u"searching for secrets in file: {}".format(f))
for s in f: # iterate the data snippets in the file (s provides ISnippet)
#App reporters should subscribe to this event feed. Each
#reporter is responsible to find/execute the sniffers and
#also to insure whitelisted secrets are not reported on.
event.notify(
SnippetAvailableForSecretsSniffEvent(s))
except Exception:
traceback.print_exc()
self.logger.info(
u"completed MellonFileProviderFactory config file entry search")
import transaction
from ZODB.POSException import ConflictError
from zope.component import adapts
from zope.component import queryAdapter
from zope.event import notify
from zope.interface import implements
from zc.queue.interfaces import IQueue
from sparc.publish import RecoverablePublishingError
from sparc.publish import IPublisher
from sparc.publish import IPublisherQueue
from sparc.publish.events import PublisherQueuePublishedEvent
from sparc.logging import logging
logger = logging.getLogger(__name__)
class PublisherQueueForZCQueue(object):
"""A queue of objects that can be published
This adapter allows for a thread-safe, concurrent-safe ZODB-based queue
"""
implements(IPublisherQueue)
adapts(IQueue)
def __init__(self, context):
self.context = context # concurrency-safe persistent queue implementation
# IPublisherQueue
def enqueue(self, item):
"""Add object into the queue"""
if not queryAdapter(item, IPublisher):
raise TypeError('could not adapt. expected item to be adaptable to IPublisher')
from entropy import shannon_entropy
from zope import component
from zope import interface
from sparc.configuration import container
import mellon
from sparc.logging import logging
logger = logging.getLogger(__name__)
@interface.implementer(mellon.ISecretSniffer)
@component.adapter(mellon.IUnicodeSnippet)
class EntropyUnicodeSecretSniffer(object):
@classmethod
def get_config(cls):
sm = component.getSiteManager()
config = sm.getUtility(mellon.IMellonApplication).get_config()
return container.IPyContainerConfigValue(config).\
get('MellonEntropySniffer')
config = None
def __init__(self, context):
self.context = context
if not EntropyUnicodeSecretSniffer.config:
logger.debug(u"Entropy config not yet loaded, initializing...")
EntropyUnicodeSecretSniffer.config = EntropyUnicodeSecretSniffer.get_config(
)
logger.debug(u"Entropy config initialization complete.")
def create_secret(self, score, matched_data):
def setLoggers(self, args):
logger = logging.getLogger() # root logger
if args.verbose:
logger.setLevel('INFO')
if args.debug:
logger.setLevel('DEBUG')
def setLoggers(self, args):
logger = logging.getLogger() # root logger
if args.verbose:
logger.setLevel('INFO')
if args.debug:
logger.setLevel('DEBUG')