Ejemplo n.º 1
0
 def accept_score(self, tx_hash):
     if not self._owner:
         die('Error: owner should be specified to invoke acceptScore')
     params = {
         "txHash": tx_hash
     }
     return self._invoke(self._owner, "acceptScore", params)
Ejemplo n.º 2
0
def main():

    parser = argparse.ArgumentParser()

    # parameter for the TLV.
    parser.add_argument(
            'TLV',
            help='TLV string (coded in hexadecimal).'
            )

    # doctest flag.
    parser.add_argument(
            '-t',
            '--test',
            help='run the doctests and exit.',
            action='store_true'
            )

    args = parser.parse_args()

    if args.test:
        doctest.testmod()
        return
    
    if not validate(args.TLV):
        util.die("A valid TLV value must be encoded in HEX and be an integer"\
                "multiple of Bytes greater then 0")


    print human(args.TLV)

    return
Ejemplo n.º 3
0
    def generate(self, _):
        method, x = self.parse_method(), None

        if method == "align":
            name, x = "DOT_ALIGN", self.parse_obj[1].eval()
        elif method == "ascii":
            name, x = "DOT_ASCII", self.parse_obj[1]
        elif method == "text":
            name, x = "DOT_TEXT", self.parse_obj[1]
        elif method == "breakpoint":
            name = "DOT_BREAKPOINT"
        elif method == "protect":
            name = "DOT_PROTECT"
        elif method == "unprotect":
            name = "DOT_UNPROTECT"
        elif method == "options":
            # TODO Do a better job of cleaning up the whitespace between these options.
            name, x = "OPTIONS", self.parse_obj[1].split(" ")[1:]
        elif method == "label":
            name, x = "LABEL", self.parse_obj[0].eval().name()
            # print name, x
            # if x == "start":
            #     import pdb;pdb.set_trace()
        elif method == "include":
            return []

        else:
            util.die("Unknown processor directive found: " +
                     self.parse_method())
        return [AssemblerInst(name, x)]
Ejemplo n.º 4
0
 def fetch_roster(self):
     try:
         xmpp.ClientXMPP.get_roster(self)
         logging.info("Roster: %s" % self.roster)
         return self.roster
     except Exception, exc:
         util.die("Couldn't fetch roster: %s" % exc)
Ejemplo n.º 5
0
def pushover(data, context):
	'''
	Sends alert to Pushovers API.
	
	data['token']: Application token
	data['user']: User token
	data['priority']: At what priority to send notification. https://pushover.net/api#priority
	context['title']: used to craft notification message
	context['message']: used to craft notification message
	pushmessage: Prettier updown message for notification
	'''
	if 'token' not in data or 'user' not in data or 'priority' not in data:
		util.die('alert_pushover: details missing!')
		return
	
	if context['updown'] == 'down':
		pushmessage = context['title'] + " - " + context['message']
	elif context['updown'] == 'up':
		pushmessage = context['title']

	import httplib, urllib
	conn = httplib.HTTPSConnection("api.pushover.net:443")
	conn.request("POST", "/1/messages.json",
		urllib.urlencode({
		"token": data['token'],
		"user": data['user'],
		"priority": data['priority'],
		"message": pushmessage,
		}), { "Content-type": "application/x-www-form-urlencoded" })
	
Ejemplo n.º 6
0
	def handle_change(self, thread_name, check_id, check_name, lock_uid, status, check_result):
		if status == 'offline':
			updown = 'down'
		elif status == 'online':
			updown = 'up'

		safe_print("[%s] ... confirmed, target is %s state now", (thread_name, status))
		update_result = Check.objects.raw("UPDATE checks SET status = %s, confirmations = 0, `lock` = '', last_checked = NOW() WHERE id = %s AND `lock` = %s", (status, check_id, lock_uid))

		if update_result.rowcount == 1:
			# we still had the lock at the point where status was toggled
			# then, send the alert
			alert_result = database.query("SELECT contacts.id, contacts.type, contacts.data FROM contacts, alerts WHERE contacts.id = alerts.contact_id AND alerts.check_id = %s AND alerts.type IN ('both', %s)", (check_id, updown))

			for alert_row in alert_result.fetchall():
				safe_print("[%s] ... alerting contact %d", (thread_name, alert_row['id']))
				alert_func = getattr(alerts, alert_row['type'], None)

				if not alert_func:
					util.die("Invalid alert handler [%s]!" % (alert_row['type']))

				# build context
				context = {}
				context['check_id'] = check_id
				context['check_name'] = check_name
				context['contact_id'] = alert_row['id']
				context['title'] = "Check %s: %s" % (status, check_name)
				context['status'] = status
				context['updown'] = updown
				context['message'] = check_result['message']

				alert_func(util.decode(alert_row['data']), context)

			# also add an event
			database.query("INSERT INTO check_events (check_id, type) VALUES (%s, %s)", (check_id, updown))
Ejemplo n.º 7
0
def sms_twilio(data, context):
    '''
	Sends an SMS message via Twilio to the given number.
	The message is "[title] message"
	config must include the strings twilio_accountsid, twilio_authtoken, and twilio_number

	data['number']: phone number to send SMS message to.
	data['twilio_accountsid'], data['twilio_authtoken'], data['twilio_number']: optional Twilio configuration
	context['title']: used in creating SMS message
	context['message']: used in creating SMS message
	'''
    from config import config
    from twilio.rest import TwilioRestClient

    if 'number' not in data:
        util.die('alert_sms_twilio: missing number')

    config_target = config

    if 'twilio_accountsid' in data and 'twilio_authtoken' in data and 'twilio_number' in data:
        config_target = data

    sms_message = "[%s] %s" % (context['title'], context['message'])
    client = TwilioRestClient(config_target['twilio_accountsid'],
                              config_target['twilio_authtoken'])

    message = client.messages.create(body=sms_message,
                                     to=data['number'],
                                     from_=config_target['twilio_number'])
Ejemplo n.º 8
0
 def _get_new_delegations(self, result):
     delegations = self.convert_to_map(result['delegations'])
     voting_power = int(result['votingPower'], 16)
     self.print_delegations(delegations, voting_power)
     while True:
         try:
             confirm = input(
                 '\n==> The address you want to set (\'q\' for finish): ')
             if confirm == 'q':
                 return delegations
             address = address_type(confirm)
             self.print_prep_info(address)
             maximum = voting_power + int(delegations.get(address, '0x0'),
                                          16)
             amount = self._check_value(
                 input(f'Delegation amount (max: {maximum}): '), maximum)
             delegations[address] = hex(amount)
             voting_power = maximum - amount
             self.print_delegations(delegations, voting_power)
         except KeyboardInterrupt:
             die('exit')
         except argparse.ArgumentTypeError:
             print('Error: invalid address')
             continue
         except ValueError as e:
             print(e.__str__())
             continue
         except JSONRPCException:
             continue
Ejemplo n.º 9
0
    def __init__(self, logfile, prefs, lock_file,
                 ignore_offset=0, first_time=0,
                 noemail=0, daemon=0):
        self.__denied_hosts = {}
        self.__prefs = prefs
        self.__lock_file = lock_file
        self.__first_time = first_time
        self.__noemail = noemail
        self.__report = Report(prefs.get("HOSTNAME_LOOKUP"), is_true(prefs['SYSLOG_REPORT']))
        self.__daemon = daemon
        self.__sync_server = prefs.get('SYNC_SERVER')
        self.__sync_upload = is_true(prefs.get("SYNC_UPLOAD"))
        self.__sync_download = is_true(prefs.get("SYNC_DOWNLOAD"))


        r = Restricted(prefs)
        self.__restricted = r.get_restricted()
        info("restricted: %s", self.__restricted)
        self.init_regex()
        
        try:
            self.file_tracker = FileTracker(self.__prefs.get('WORK_DIR'),
                                            logfile)
        except Exception, e:
            self.__lock_file.remove()
            die("Can't read: %s" % logfile, e)
Ejemplo n.º 10
0
 def _generate_code_for_emit_action(self, bind_or_emit):
     """Emit code for emit action """
     if bind_or_emit == 'BIND':
         if self.emit_type == 'letters' or self.field_name == None:
             return ''
         elif self.emit_type == 'numeric':
             op_accessor = encutil.enc_strings['op_accessor']
             operand_setter = "%s_set_%s" % (op_accessor,
                                             self.field_name.lower())
             obj_name = encutil.enc_strings['obj_str']
             hex_val = hex(self.int_value)
             code = "%s(%s, %s);" % (operand_setter, obj_name, hex_val)
             return ['    ' + code]
         else:
             util.die("Unknown emit_type %s" % self.emit_type)
     else:  # EMIT
         emit_util_function = encutil.enc_strings['emit_util_function']
         obj_name = encutil.enc_strings['obj_str']
         nbits = self.nbits
         code = ''
         if self.field_name == None:
             if self.emit_type == 'numeric':
                 hex_val = hex(self.int_value)
                 code = "%s(%s, %d, %s);" % (emit_util_function, obj_name,
                                             nbits, hex_val)
             else:
                 util.die("must have field name for letter action")
         else:
             op_accessor = encutil.enc_strings['op_accessor']
             operand_getter = "%s_get_%s(%s)" % (
                 op_accessor, self.field_name.lower(), obj_name)
             code = "%s(%s, %d, %s);" % (emit_util_function, obj_name,
                                         nbits, operand_getter)
         return ['    ' + code]
Ejemplo n.º 11
0
def sms_twilio(data, context):
	'''
	Sends an SMS message via Twilio to the given number.
	The message is "[title] message"
	config must include the strings twilio_accountsid, twilio_authtoken, and twilio_number

	data['number']: phone number to send SMS message to.
	data['twilio_accountsid'], data['twilio_authtoken'], data['twilio_number']: optional Twilio configuration
	context['title']: used in creating SMS message
	context['message']: used in creating SMS message
	'''
	from config import config
	from twilio.rest import TwilioRestClient

	if 'number' not in data:
		util.die('alert_sms_twilio: missing number')

	config_target = config

	if 'twilio_accountsid' in data and 'twilio_authtoken' in data and 'twilio_number' in data:
		config_target = data

	sms_message = "[%s] %s" % (context['title'], context['message'])
	client = TwilioRestClient(config_target['twilio_accountsid'], config_target['twilio_authtoken'])

	message = client.messages.create(body = sms_message, to = data['number'], from_ = config_target['twilio_number'])
Ejemplo n.º 12
0
def main():

    parser = argparse.ArgumentParser()

    # parameter for the AFL.
    parser.add_argument(
        'AFL', help='Application File Locator value (coded in hexadecimal).')

    # doctest flag.
    parser.add_argument('-t',
                        '--test',
                        help='run the doctests and exit.',
                        action='store_true')

    args = parser.parse_args()

    test = args.test
    afl = args.AFL

    if test:
        doctest.testmod()
        return

    valid_in = validate(afl)

    if not valid_in:
        util.die("A valid AFL value should be a multiple of 4 Bytes.")

    print human(afl)

    return
Ejemplo n.º 13
0
def main():

    parser = argparse.ArgumentParser()

    # parameter for the CVM list.
    parser.add_argument(
        'CVM',
        help='Cardholder Verification Method list (coded in hexadecimal).')

    # doctest flag.
    parser.add_argument('-t',
                        '--test',
                        help='run the doctests and exit.',
                        action='store_true')

    args = parser.parse_args()

    if args.test:
        doctest.testmod()
        return

    valid_in = validate(args.CVM)

    if not valid_in:
        util.die("CVM list must contain 8 bytes for amount x and y and at least"\
                " 2 bytes for one CVM")

    print human(args.CVM)
    return
Ejemplo n.º 14
0
    def check_required(self, path):
        ok = 1
        for name_reqd, val_reqd in self.reqd:
            if not self.__data.has_key(name_reqd):
                print "Missing configuration parameter: %s" % name_reqd
                if name_reqd == 'DENY_THRESHOLD_INVALID':
                    print "\nNote: The configuration parameter DENY_THRESHOLD has been renamed"
                    print "      DENY_THRESHOLD_INVALID.  Please update your DenyHosts configuration"
                    print "      file to reflect this change."

                    if self.__data.has_key('DENY_THRESHOLD'):
                        print "\n*** Using deprecated DENY_THRESHOLD value for DENY_THRESHOLD_INVALID ***"
                        self.__data['DENY_THRESHOLD_INVALID'] = self.__data['DENY_THRESHOLD']
                    else:
                        ok = 0                        
                elif name_reqd == 'DENY_THRESHOLD_RESTRICTED':
                    print "\nNote: DENY_THRESHOLD_RESTRICTED has not been defined. Setting this"
                    print "value to DENY_THRESHOLD_ROOT"
                    self.__data['DENY_THRESHOLD_RESTRICTED'] = self.__data['DENY_THRESHOLD_ROOT']
                else:
                    ok = 0
            #elif val_reqd and not self.__data[name_reqd]:
            elif val_reqd and not self.__data[name_reqd] and not name_reqd in self.to_int:
                print "Missing configuration value for: %s" % name_reqd
                ok = 0

        if not ok:
            die("You must correct these problems found in: %s" % path)
Ejemplo n.º 15
0
def main():

    parser = argparse.ArgumentParser()

    parser.add_argument("decline", help="value of the decline xIAC (e.g:FC0011AB00)")

    parser.add_argument("online", help="value of the online xIAC (e.g:FC0011AB00)")

    parser.add_argument("default", help="value of the decline xIAC (e.g:FC0011AB00)")

    parser.add_argument("-t", "--test", help="run the doctests", default=False, action="store_true")

    args = parser.parse_args()

    if args.test:
        import doctest

        doctest.testmod()
        return

    # xIAC
    decline = util.rm(args.decline)
    online = util.rm(args.online)
    default = util.rm(args.default)

    valid_in = validate(decline, online, default)

    if not valid_in:
        util.die("xIAC must all have the same length and be HEX values.")

    print human(decline, online, default)
    return
Ejemplo n.º 16
0
def main():

    parser = argparse.ArgumentParser()

    # parameter for the TLV.
    parser.add_argument('TLV', help='TLV string (coded in hexadecimal).')

    # doctest flag.
    parser.add_argument('-t',
                        '--test',
                        help='run the doctests and exit.',
                        action='store_true')

    args = parser.parse_args()

    if args.test:
        doctest.testmod()
        return

    if not validate(args.TLV):
        util.die("A valid TLV value must be encoded in HEX and be an integer"\
                "multiple of Bytes greater then 0")

    print human(args.TLV)

    return
Ejemplo n.º 17
0
def main():

    parser = argparse.ArgumentParser()

    # parameter for the AIP.
    parser.add_argument(
            'AIP',
            help='Application Interchange Profile (coded in hexadecimal).'
            )

    # doctest flag.
    parser.add_argument(
            '-t',
            '--test',
            help='run the doctests and exit.',
            action='store_true'
            )

    args = parser.parse_args()

    if args.test:
        doctest.testmod()
        return

    valid_in = validate(args.AIP)

    if not valid_in:
        util.die("a valid AIP has a lenght of 2 Bytes and is code in HEX")

    print human(args.AIP)

    return
Ejemplo n.º 18
0
def main():

    parser = argparse.ArgumentParser()

    # parameter for the AIP.
    parser.add_argument(
        'AIP', help='Application Interchange Profile (coded in hexadecimal).')

    # doctest flag.
    parser.add_argument('-t',
                        '--test',
                        help='run the doctests and exit.',
                        action='store_true')

    args = parser.parse_args()

    if args.test:
        doctest.testmod()
        return

    valid_in = validate(args.AIP)

    if not valid_in:
        util.die("a valid AIP has a lenght of 2 Bytes and is code in HEX")

    print human(args.AIP)

    return
Ejemplo n.º 19
0
    def check_required(self, path):
        ok = 1
        for name_reqd, val_reqd in self.reqd:
            if not self.__data.has_key(name_reqd):
                print "Missing configuration parameter: %s" % name_reqd
                if name_reqd == 'DENY_THRESHOLD_INVALID':
                    print "\nNote: The configuration parameter DENY_THRESHOLD has been renamed"
                    print "      DENY_THRESHOLD_INVALID.  Please update your DenyHosts configuration"
                    print "      file to reflect this change."

                    if self.__data.has_key('DENY_THRESHOLD'):
                        print "\n*** Using deprecated DENY_THRESHOLD value for DENY_THRESHOLD_INVALID ***"
                        self.__data['DENY_THRESHOLD_INVALID'] = self.__data[
                            'DENY_THRESHOLD']
                    else:
                        ok = 0
                elif name_reqd == 'DENY_THRESHOLD_RESTRICTED':
                    print "\nNote: DENY_THRESHOLD_RESTRICTED has not been defined. Setting this"
                    print "value to DENY_THRESHOLD_ROOT"
                    self.__data['DENY_THRESHOLD_RESTRICTED'] = self.__data[
                        'DENY_THRESHOLD_ROOT']
                else:
                    ok = 0
            elif val_reqd and not self.__data[name_reqd]:
                print "Missing configuration value for: %s" % name_reqd
                ok = 0

        if not ok:
            die("You must correct these problems found in: %s" % path)
Ejemplo n.º 20
0
def main():

    parser = argparse.ArgumentParser()

    # parameter for the AFL.
    parser.add_argument(
            'AFL',
            help='Application File Locator value (coded in hexadecimal).'
            )

    # doctest flag.
    parser.add_argument(
            '-t',
            '--test',
            help='run the doctests and exit.',
            action='store_true'
            )

    args = parser.parse_args()

    test = args.test
    afl = args.AFL

    if test:
        doctest.testmod()
        return

    valid_in = validate(afl)

    if not valid_in:
        util.die("A valid AFL value should be a multiple of 4 Bytes.")

    print human(afl)

    return
Ejemplo n.º 21
0
    def __init__(self, logfile, prefs, lock_file,
                 ignore_offset=0, first_time=0,
                 noemail=0, daemon=0):
        self.__denied_hosts = {}
        self.__prefs = prefs
        self.__lock_file = lock_file
        self.__first_time = first_time
        self.__noemail = noemail
        self.__report = Report(prefs.get("HOSTNAME_LOOKUP"), is_true(prefs['SYSLOG_REPORT']))
        self.__daemon = daemon
        self.__sync_server = prefs.get('SYNC_SERVER')
        self.__sync_upload = is_true(prefs.get("SYNC_UPLOAD"))
        self.__sync_download = is_true(prefs.get("SYNC_DOWNLOAD"))


        r = Restricted(prefs)
        self.__restricted = r.get_restricted()
        info("restricted: %s", self.__restricted)
        self.init_regex()

        try:
            self.file_tracker = FileTracker(self.__prefs.get('WORK_DIR'),
                                            logfile)
        except Exception, e:
            self.__lock_file.remove()
            die("Can't read: %s" % logfile, e)
Ejemplo n.º 22
0
 def fetch_roster(self):
     try:
         xmpp.ClientXMPP.get_roster(self)
         logging.info("Roster: %s" % self.roster)
         return self.roster
     except Exception, exc:
         util.die("Couldn't fetch roster: %s" % exc)
Ejemplo n.º 23
0
def main():
    global projectshort

    # No emails for a repository in the process of being imported
    git_dir = git.rev_parse(git_dir=True, _quiet=True)
    if os.path.exists(os.path.join(git_dir, 'pending')):
        return

    projectshort = get_module_name()

    def get_config(hook, skip=False):
        hook_val = None
        try:
            hook_val = git.config(hook, _quiet=True)
        except CalledProcessError:
            pass

        if not hook_val and not skip:
            die("%s is not set" % hook)

        return hook_val

    global debug
    if (len(sys.argv) > 1):
        debug = True
        print "Debug Mode on"
    else:
        debug = False

    recipients = get_config("hooks.mailinglist", debug)
    smtp_host = get_config("hooks.smtp-host", debug)
    smtp_port = get_config("hooks.smtp-port", True)
    smtp_sender = get_config("hooks.smtp-sender", debug)
    smtp_sender_user = get_config("hooks.smtp-sender-username", True)
    smtp_sender_pass = get_config("hooks.smtp-sender-password", True)

    changes = []

    if len(sys.argv) > 1:
        # For testing purposes, allow passing in a ref update on the command line
        if len(sys.argv) != 4:
            die("Usage: generate-commit-mail OLDREV NEWREV REFNAME")
        changes.append(make_change(recipients, smtp_host, smtp_port, smtp_sender, smtp_sender_user, smtp_sender_pass,
                                   sys.argv[1], sys.argv[2], sys.argv[3]))
    else:
        for line in sys.stdin:
            items = line.strip().split()
            if len(items) != 3:
                die("Input line has unexpected number of items")
            changes.append(make_change(recipients, smtp_host, smtp_port, smtp_sender, smtp_sender_user, smtp_sender_pass,
                                       items[0], items[1], items[2]))

    for change in changes:
        all_changes[change.refname] = change

    for change in changes:
        change.prepare()
        change.send_emails()
        processed_changes[change.refname] = change
Ejemplo n.º 24
0
 def _check_value(value: str, maximum: int):
     try:
         amount = int(value)
         if 0 <= amount <= maximum:
             return amount
         die(f'Error: value should be 0 <= (value) <= {maximum}')
     except ValueError:
         die(f'Error: value should be integer')
Ejemplo n.º 25
0
 def environ_sub(self, value):
     while True:
         environ_match = ENVIRON_REGEX.search(value)
         if not environ_match: return value
         name = environ_match.group("environ")
         env = os.environ.get(name)
         if not env:
             die("Could not find environment variable: %s" % name)
         value = ENVIRON_REGEX.sub(env, value)
Ejemplo n.º 26
0
 def environ_sub(self, value):
     while True:
         environ_match = ENVIRON_REGEX.search(value)
         if not environ_match: return value
         name = environ_match.group("environ")
         env = os.environ.get(name)
         if not env:
             die("Could not find environment variable: %s" % name)
         value = ENVIRON_REGEX.sub(env, value)
Ejemplo n.º 27
0
def start():
    logging.info("Starting")
    secrets = lockerfs.loadJsonFile("secrets.json")
    app.client = client.Client(app.info, jid=secrets["jid"], password=secrets["password"])
    if app.client.connect():
        app.client.process(threaded=True)
        app.started = True
    else:
        util.die("XMPP connection failed")
Ejemplo n.º 28
0
def check_obsolete_arguments(args):
    """
    give helpful message for obsolete arguments then die
    """
    for (argument, parameter_name) in PARAMETERS_MATCHING_OBSOLETE_ARGUMENTS:
        if getattr(args, argument, None) is not None:
            print(getattr(args, argument))
            die(f"argument '{argument}' no longer supported, instead use -P to specify an equivalent value for parameter '{parameter_name}'"
                )
Ejemplo n.º 29
0
def main():
    """
    Handle command line arguments and launch curses display, then enter
    curses_main()
    """

    epilog = """
    Reads MSAs in any format supported by BioPython. Autodetects alignments in
    FASTA, Stockholm, Phylip and Nexus formats.

    Current does not autodetect PIR format correctly.

    By default, all gaps are displayed as '.'

    To preserve the original gap symbols from the alignment file, use the
    --gapsym option.
    """

    description = """
    Terminal-based multiple sequence alignment viewer.
    """

    parser = argparse.ArgumentParser(epilog=epilog, description=description)
    parser.add_argument('aln_file', help="Path to alignment file.")
    parser.add_argument('--format', '-f', help="MSA format (skip autodetection)")
    parser.add_argument('--gapsym', help="Preserve gap symbols from file.",
            action='store_true', default=False)
    parser.add_argument('--nucleotide', '-n', action='store_true',
            default=False, help="Nucleotide alignment.")
    args = parser.parse_args()

    if args.format is None:
        args.format = guess_format(args.aln_file)
        if args.format is None:
            die( "FATAL: can't determine format of %s. Try specifying the "
                    "alignment format manually.\n" % args.aln_file, None)
    try:
        stdscr=curses.initscr()
        curses.noecho()
        curses.cbreak()
        stdscr.keypad(1)
        if curses.has_colors():
            curses.start_color()
        curses_main(stdscr, args)
    # don't print a stack trace if killed by, e.g, SIGINT
    # we just want to clean up the environment and quit
    except KilledException: 
        pass 
    finally:
        stdscr.erase()
        stdscr.refresh()
        stdscr.keypad(0)
        curses.echo()
        curses.nocbreak()
        curses.endwin()
    return 0
Ejemplo n.º 30
0
def ssl_expire(data):
    # keys: hostname, optional port (default 443), days (default 7), and timeout (default 10)
    from config import config

    if 'hostname' not in data:
        util.die('checks.ssl_expire: missing hostname')

    hostname = data['hostname']
    port = int(extract(data, 'port', 443))
    days = int(extract(data, 'days', 7))
    timeout = float(extract(data, 'timeout', 10))

    import ssl
    from datetime import datetime
    import socket

    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(timeout)
        sock.connect((hostname, port))
        ssl_sock = ssl.wrap_socket(
            sock,
            cert_reqs=ssl.CERT_REQUIRED,
            ca_certs='/etc/ssl/certs/ca-certificates.crt',
            ciphers=("HIGH:-aNULL:-eNULL:-PSK:RC4-SHA:RC4-MD5"))
        cert = ssl_sock.getpeercert()
        ssl_sock.close()
    except ssl.SSLError as e:
        return {
            'status': 'fail',
            'message': 'SSL connection failure: %s' % (e.strerror)
        }

    try:
        expire_date = datetime.strptime(cert['notAfter'],
                                        '%b %d %H:%M:%S %Y %Z')
    except:
        return {
            'status':
            'fail',
            'message':
            'Certificate has unknown date format: %s' % (cert['notAfter'])
        }

    expire_in = expire_date - datetime.now()

    if expire_in.days < days:
        return {
            'status':
            'fail',
            'message':
            'SSL certificate will expire in %d hours' %
            (expire_in.total_seconds() / 3600, )
        }
    else:
        return {'status': 'success'}
Ejemplo n.º 31
0
def balance(args):
    icon_service = get_icon_service(args.endpoint)
    if args.keystore:
        address = get_address_from_keystore(args.keystore)
    elif args.address:
        address = args.address
    else:
        die('Error: keystore or address should be specified')
    _balance = icon_service.get_balance(address)
    print('ICX =', in_icx(_balance))
Ejemplo n.º 32
0
    def get_str_value(self):
        if self.is_field_binding() or self.is_return():
            return self.value
        if self.is_nonterminal():
            return self.nt
        if self.is_ntluf():
            return self.ntluf

        err = "unsupported type: %s for function get_str_value" % self.type
        util.die(err)
Ejemplo n.º 33
0
 def _claim_iscore(self, wallet, address):
     print('\n>>> Claim IScore:')
     iscore = IScore(self._icon_service)
     result = iscore.query(address)
     iscore.print_status(address, result)
     estimated_icx = in_icx(int(result['estimatedICX'], 16))
     if (estimated_icx - 1.0) <= 0:
         die('Error: EstimatedICX should be larger than 1.0')
     tx_hash = iscore.claim(wallet)
     self._ensure_tx_result(tx_hash, True)
Ejemplo n.º 34
0
    def get_config(hook, skip=False):
        hook_val = None
        try:
            hook_val = git.config(hook, _quiet=True)
        except CalledProcessError:
            pass

        if not hook_val and not skip:
            die("%s is not set" % hook)

        return hook_val
Ejemplo n.º 35
0
    def get_config(hook, skip=False):
        hook_val = None
        try:
            hook_val = git.config(hook, _quiet=True)
        except CalledProcessError:
            pass

        if not hook_val and not skip:
            die("%s is not set" % hook)

        return hook_val
Ejemplo n.º 36
0
    def __init__(self,
                 name,
                 aggtype,
                 ctype,
                 bitwidth,
                 default_visibility=None,
                 default_initializer=None,
                 xprint='NOPRINT',
                 internal_or_public="INTERNAL",
                 dio="DO",
                 eio="EO",):

        self.name = name
        self.aggtype = aggtype
        self.ctype = ctype
        self.bitwidth = int(bitwidth)
        self.default_visibility = default_visibility
        self.xprint = xprint
        self.internal_or_public = internal_or_public
        self.dio = dio
        self.eio = eio

        if self.eio in ['EI', 'EO']:
            pass
        else:
            err = "Bad Encoder IO value: %s -- need one of {EI,EO}"
            util.die(err % self.eio)

        if self.dio in ['DI', 'DO', 'DS']:
            pass
        else:
            err = "Bad decoder IO value: %s -- need one of {DI,DO,DS}"
            util.die(err % self.eio)

        if self.eio == 'EI':
            self.encoder_input = True
        else:
            self.encoder_input = False

        if self.dio == 'DS':
            self.decoder_skip = True
        else:
            self.decoder_skip = False

        # NOTE: this next field is only used if initialize_each_field is True.
        self.default_initializer = default_initializer
        self.is_enum = 'enum' in self.ctype

        # this is the C type that will be used in the operand storage struct.
        self.storage_type = None

        # if True using bit fields
        self.compressed = False
Ejemplo n.º 37
0
 def remove(self, die_=True):
     try:
         if self.fd: os.close(self.fd)
     except:
         pass
     
     self.fd = None
     try:
         os.unlink(self.lockpath)
     except Exception, e:
         if die_:
             die("Error deleting DenyHosts lock file: %s" % self.lockpath, e)
Ejemplo n.º 38
0
def start(secrets):
    logging.info("Starting")
    app.client = client.Client(app.info, jid=secrets["jid"], password=secrets["password"])
    address = (secrets["host"], secrets["port"]) if (secrets.has_key("host") and secrets.has_key("port")) else ()
    logging.info("XMPP connecting with address " + str(address))
    if app.client.connect(address):
        app.client.process(threaded=True)
        app.started = True
    else:
        # XXX We shouldn't die here, we should still serve existing data and try again.  
        # We could also prompt for credentials again
        util.die("XMPP connection failed")
Ejemplo n.º 39
0
    def create(self):
        try:
            self.fd = os.open(self.lockpath,
                              os.O_CREAT |  # create file
                              os.O_TRUNC |  # truncate it, if it exists
                              os.O_WRONLY | # write-only
                              os.O_EXCL,    # exclusive access
                              0644)         # file mode

        except Exception, e:
            pid = self.get_pid()
            die("DenyHosts could not obtain lock (pid: %s)" % pid, e)
Ejemplo n.º 40
0
def ch_def():
    """ Returns the default channel with which communication with
    the card will occur. """
        
    try:
        reader_def = reader_name_def()
        t = terminal_select(reader_def)
        card = t.connect(PROTO_DEF)
        ch = card.getBasicChannel()
        return ch
    except:
        util.die("could not get a connection to the card with the default terminal.")
Ejemplo n.º 41
0
    def create(self):
        try:
            self.fd = os.open(self.lockpath,
                              os.O_CREAT |  # create file
                              os.O_TRUNC |  # truncate it, if it exists
                              os.O_WRONLY | # write-only
                              os.O_EXCL,    # exclusive access
                              0644)         # file mode

        except Exception, e:
            pid = self.get_pid()
            die("DenyHosts could not obtain lock (pid: %s)" % pid, e)
Ejemplo n.º 42
0
    def handle_change(self, thread_name, check_id, check_name, lock_uid,
                      status, check_result):
        if status == 'offline':
            import subprocess
            googleResult = subprocess.Popen(
                ['ping', 'ipv4.google.com', '-c', '3', '-w', '3'],
                stdout=subprocess.PIPE).stdout.read()
            if '100% packet loss' in googleResult:
                print "What?! Google down? Aborting alert sending as it seems like the monitor host has no connectivity"
                return
            updown = 'down'
        elif status == 'online':
            updown = 'up'

        safe_print("[%s] ... confirmed, target is %s state now",
                   (thread_name, status))
        update_result = database.query(
            "UPDATE checks SET status = %s, confirmations = 0, `lock` = '', last_checked = NOW() WHERE id = %s AND `lock` = %s",
            (status, check_id, lock_uid))

        if update_result.rowcount == 1:
            # we still had the lock at the point where status was toggled
            # then, send the alert
            alert_result = database.query(
                "SELECT contacts.id, contacts.type, contacts.data FROM contacts, alerts WHERE contacts.id = alerts.contact_id AND alerts.check_id = %s AND alerts.type IN ('both', %s)",
                (check_id, updown))

            for alert_row in alert_result.fetchall():
                safe_print("[%s] ... alerting contact %d",
                           (thread_name, alert_row['id']))
                alert_func = getattr(alerts, alert_row['type'], None)

                if not alert_func:
                    util.die("Invalid alert handler [%s]!" %
                             (alert_row['type']))

                # build context
                context = {}
                context['check_id'] = check_id
                context['check_name'] = check_name
                context['contact_id'] = alert_row['id']
                context['title'] = "Check %s: %s" % (status, check_name)
                context['status'] = status
                context['updown'] = updown
                context['message'] = check_result['message']

                alert_func(util.decode(alert_row['data']), context)

            # also add an event
            database.query(
                "INSERT INTO check_events (check_id, type) VALUES (%s, %s)",
                (check_id, updown))
Ejemplo n.º 43
0
def http_status(data):
	# keys: status, url (also http_helper params)
	if 'status' not in data or 'url' not in data:
		util.die('checks.http_status: missing status')

	result = http_helper(data)

	if result['status'] == 'fail':
		return result
	elif str(result['code']) == data['status']:
		return {'status': 'success'}
	else:
		return {'status': 'fail', 'message': "target [%s] returned unexpected status [%s], expected [%s]" % (data['url'], str(result['code']), data['status'])}
Ejemplo n.º 44
0
def http_contains(data):
	# keys: substring, url (also http_helper params)
	if 'substring' not in data or 'url' not in data:
		util.die('checks.http_contains: missing substring')

	result = http_helper(data)

	if result['status'] == 'fail':
		return result
	elif data['substring'] in result['content']:
		return {'status': 'success'}
	else:
		return {'status': 'fail', 'message': "target [%s] does not contain string [%s]" % (data['url'], data['substring'])}
Ejemplo n.º 45
0
    def classify(self, doc):
        model_file_path = self.path + "svm_model"

        model_file = '%ssvm_model' % self.path
        if not self.feats: util.die('Incomplete model')
        if not os.path.isfile(model_file):
            util.die('no model [%s]' % model_file)

        ## testing data file
        sys.stderr.write('SVM classifying... ')
        lines = []
        frag = doc.frag
        while frag:
            if frag.label == None: svm_label = '0'
            elif frag.label: svm_label = '+1'
            else: svm_label = '-1'
            line = '%s ' % svm_label
            feats = [f + '_' + v for f, v in frag.features.items()]
            svm_feats = [self.feats[f] for f in feats if f in self.feats]
            svm_feats.sort(lambda x, y: x - y)
            line += ' '.join(['%d:1' % x for x in svm_feats])
            lines.append(line)
            frag = frag.next

        unused, test_file = tempfile.mkstemp()
        fh = open(test_file, 'w')
        fh.write('\n'.join(lines) + '\n')
        fh.close()

        ## classify test data
        unused, pred_file = tempfile.mkstemp()
        options = '-v 0'

        #cmd = '%s %s %s %s %s' %(SVM_CLASSIFY, options, test_file, model_file, pred_file)
        #cmd = SVM_CLASSIFY + " " +options + " " +test_file + " " + model_file + " " + pred_file
        cmd = "\"" + SVM_CLASSIFY + "\" " + options + " \"" + test_file + "\" \"" + model_file_path + "\" \"" + pred_file + "\""
        print cmd
        os.system(cmd)
        ## get predictions
        total = 0
        preds = map(float, open(pred_file).read().splitlines())
        frag = doc.frag
        while frag:
            frag.pred = util.logit(preds[total])
            frag = frag.next
            total += 1

        ## clean up
        #os.remove(test_file)
        #os.remove(pred_file)
        sys.stderr.write('done!\n')
Ejemplo n.º 46
0
def telegram_sender(data, context):
	'''
	Notifies a web hook over HTTP regarding alert.
	All context parameters are sent, via GET.

	data['url']: the target web hook
	context: encoded as GET parameters
	'''
	if 'token' not in data and 'chat_id' not in data:
		util.die('telegram_sender: missing token or chat_id')

        from telegram import Bot
        bot = Bot(data['token'])
        bot.sendMessage(chat_id=data['chat_id'], text=context['message'])
Ejemplo n.º 47
0
def ch_def():
    """ Returns the default channel with which communication with
    the card will occur. """

    try:
        reader_def = reader_name_def()
        t = terminal_select(reader_def)
        card = t.connect(PROTO_DEF)
        ch = card.getBasicChannel()
        return ch
    except:
        util.die(
            "could not get a connection to the card with the default terminal."
        )
Ejemplo n.º 48
0
def ping(data):
	# keys: target
	if 'target' not in data:
		util.die('checks.ping: missing target')

	import subprocess

	target = data['target']
	result = subprocess.Popen(['ping', target, '-c', '3', '-w', '3'], stdout=subprocess.PIPE).stdout.read()

	if '100% packet loss' in result:
		return {'status': 'fail', 'message': "No response from %s" % (target,)}
	else:
		return {'status': 'success'}
Ejemplo n.º 49
0
    def classify(self, doc):
        model_file_path = self.path + "svm_model"
     
        model_file = '%ssvm_model' %self.path
        if not self.feats: util.die('Incomplete model')
        if not os.path.isfile(model_file): util.die('no model [%s]' %model_file)

        ## testing data file
        sys.stderr.write('SVM classifying... ')
        lines = []
        frag = doc.frag
        while frag:
            if frag.label == None: svm_label = '0'
            elif frag.label: svm_label = '+1'
            else: svm_label = '-1'
            line = '%s ' %svm_label
            feats = [f+'_'+v for f,v in frag.features.items()]
            svm_feats = [self.feats[f] for f in feats if f in self.feats]
            svm_feats.sort(lambda x,y: x-y)
            line += ' '.join(['%d:1' %x for x in svm_feats])
            lines.append(line)
            frag = frag.next

        unused, test_file = tempfile.mkstemp()
        fh = open(test_file, 'w')
        fh.write('\n'.join(lines) + '\n')
        fh.close()
    
        ## classify test data
        unused, pred_file = tempfile.mkstemp()
        options = '-v 0'
        
        #cmd = '%s %s %s %s %s' %(SVM_CLASSIFY, options, test_file, model_file, pred_file)
        #cmd = SVM_CLASSIFY + " " +options + " " +test_file + " " + model_file + " " + pred_file
        cmd = "\""+SVM_CLASSIFY + "\" " +options + " \"" +test_file + "\" \"" + model_file_path + "\" \"" + pred_file+"\""
        print cmd
        os.system(cmd)
        ## get predictions
        total = 0
        preds = map(float, open(pred_file).read().splitlines())
        frag = doc.frag
        while frag:
            frag.pred = util.logit(preds[total])
            frag = frag.next
            total += 1

        ## clean up
        #os.remove(test_file)
        #os.remove(pred_file)
        sys.stderr.write('done!\n')
Ejemplo n.º 50
0
def get_module_name():
    try:
        git_dir = git.rev_parse(git_dir=True, _quiet=True)
    except CalledProcessError:
        die("GIT_DIR not set")

    # Use the directory name with .git stripped as a short identifier
    absdir = os.path.abspath(git_dir)
    if absdir.endswith(os.sep + '.git'):
        absdir = os.path.dirname(absdir)
    projectshort = os.path.basename(absdir)
    if projectshort.endswith(".git"):
        projectshort = projectshort[:-4]

    return projectshort
Ejemplo n.º 51
0
def _guess_os():
    s = platform.system()
    bits = platform.architecture()[0]
    if s == 'Darwin':
        return OSX
    elif s == 'Linux':
        if bits == '32bit': return LINUX32
        elif bits == '64bit': return LINUX64
        else: die(u"Unrecognized Linux bit information; " + \
                      u"expected '32bit' or '64bit' but got: %s" % bits)
    elif s == 'Windows':
        # tons of people use windows 7, and some of them might figure
        # out what to do, so pretend we're on win32 and let them try.
        # TODO some warning would be good
        return WINXP32
Ejemplo n.º 52
0
def tcp_connect(data):
	# keys: target, port; optional: timeout
	if 'target' not in data or 'port' not in data:
		util.die('checks.tcp_connect: missing target or port')

	target = data['target']
	port = int(data['port'])
	timeout = float(extract(data, 'timeout', 5))

	import socket
	sock = socket.socket()
	sock.settimeout(timeout)
	sock.connect((target, port))
	sock.close()
	return {'status': 'success'}
Ejemplo n.º 53
0
    def train(self, doc):
        """
        takes training data and a path and creates an svm model
        """

        model_file = '%ssvm_model' %self.path

        ## need integer dictionary for features
        sys.stderr.write('training. making feat dict... ')
        feat_list = set()
        frag = doc.frag
        while frag:
            feats = [f+'_'+v for f,v in frag.features.items()]
            for feat in feats: feat_list.add(feat)
            frag = frag.next
        self.feats = dict(zip(feat_list, range(1,len(feat_list)+1)))

        ## training data file
        sys.stderr.write('writing... ')
        lines = []
        frag = doc.frag
        while frag:
            if frag.label == None: util.die('expecting labeled data')
            elif frag.label > 0.5: svm_label = '+1'
            elif frag.label < 0.5: svm_label = '-1'
            else: continue
            line = '%s ' %svm_label
            feats = [f+'_'+v for f,v in frag.features.items()]
            svm_feats = [self.feats[f] for f in feats]
            svm_feats.sort(lambda x,y: x-y)
            line += ' '.join(['%d:1' %x for x in svm_feats])
            lines.append(line)
            frag = frag.next

        unused, train_file = tempfile.mkstemp()
        fh = open(train_file, 'w')
        fh.write('\n'.join(lines) + '\n')
        fh.close()
    
        ## train an svm model
        sys.stderr.write('running svm... ')
        options = '-c 1 -v 0'
        cmd = '%s %s %s %s' %(SVM_LEARN, options, train_file, model_file)
        os.system(cmd)
        sys.stderr.write('done!\n')

        ## clean up
        os.remove(train_file)
Ejemplo n.º 54
0
	def worker(self):
		thread_name = threading.currentThread().getName()

		while True:
			check_id, check_name, check_type, check_data, status, max_confirmations, confirmations, lock_uid = self.q.get()

			safe_print("[%s] processing check %d: calling checks.%s", (thread_name, check_id, check_type))
			check_result = checks.run_check(check_type, util.decode(check_data), check_id)

			safe_print("[%s] check %d result: %s", (thread_name, check_id, str(check_result)))

			if not type(check_result) is dict or 'status' not in check_result:
				util.die("[%s] bad check handler [%s]: returned non-dict or missing status" % (thread_name, check_type))
			elif 'message' not in check_result:
				if check_result['status'] == 'fail':
					check_result['message'] = "Check offline: %s" % (check_name)
				else:
					check_result['message'] = "Check online: %s" % (check_name)

			if check_result['status'] == 'fail':
				safe_print("[%s] ... got failure!", (thread_name))

				if status == 'online':
					with recent_failures_lock:
						recent_failures.add((check_id, util.time()))

					if confirmations + 1 >= max_confirmations:
						# target has failed
						self.handle_change(thread_name, check_id, check_name, lock_uid, 'offline', check_result)
					else:
						# increase confirmations
						database.query("UPDATE checks SET confirmations = confirmations + 1, `lock` = '', last_checked = NOW() WHERE id = %s AND `lock` = %s", (check_id, lock_uid))
				else:
					database.query("UPDATE checks SET confirmations = 0, `lock` = '', last_checked = NOW() WHERE id = %s AND `lock` = %s", (check_id, lock_uid))
			elif check_result['status'] == 'success':
				safe_print("[%s] ... got success", (thread_name))

				if status == 'offline':
					if confirmations + 1 >= max_confirmations:
						# target has come back online
						self.handle_change(thread_name, check_id, check_name, lock_uid, 'online', check_result)
					else:
						# increase confirmations
						database.query("UPDATE checks SET confirmations = confirmations + 1, `lock` = '', last_checked = NOW() WHERE id = %s AND `lock` = %s", (check_id, lock_uid))
				else:
					database.query("UPDATE checks SET confirmations = 0, `lock` = '', last_checked = NOW() WHERE id = %s AND `lock` = %s", (check_id, lock_uid))
			else:
				util.die("Check handler [%s] returned invalid status code [%s]!") % (check_type, check_result['status'])
Ejemplo n.º 55
0
def get_committer_email(rev):
    try:
        git_email = git.show('--raw', '--pretty=format:%an <%aE>', rev)
    except CalledProcessError:
        die("GIT_ERROR retrieving email")

    if git_email is None:
        return None
    if len(git_email.strip()) == 0:
        return None

    array = git_email.strip().splitlines()
    if len(array) == 0:
        return None

    return array[0]
Ejemplo n.º 56
0
def get_project_description():
    try:
        git_dir = git.rev_parse(git_dir=True, _quiet=True)
    except CalledProcessError:
        die("GIT_DIR not set")

    projectdesc = ''
    description = os.path.join(git_dir, 'description')
    if os.path.exists(description):
        try:
            projectdesc = open(description).read().strip()
        except:
            pass
    if projectdesc.startswith('Unnamed repository;'):
        projectdesc = ''

    return projectdesc
Ejemplo n.º 57
0
def http_helper(data):
	from config import config

	# keys: url, timeout
	if 'url' not in data:
		util.die('checks.http_helper: missing url')

	import httplib2

	try:
		handle = httplib2.Http(timeout = float(extract(data, 'timeout', 10)))
		resp, content = handle.request(data['url'], 'GET', headers={'User-Agent': config['user_agent']})
		return {'status': 'success', 'code': resp.status, 'content': content}
	except httplib2.RelativeURIError as e:
		return {'status': 'fail', 'message': 'RelativeURIError (possibly invalid URI: %s)' % (data['url'])}
	except httplib2.HttpLib2Error as e:
		return {'status': 'fail', 'message': e.strerror}