def get_credentials(self): # Retrieve the credentials self.cred_tested = credentials.Credentials(CONF.tested_rc, pwd=CONF.tested_passwd, no_env=CONF.no_env) if CONF.testing_rc: self.cred_testing = credentials.Credentials( CONF.testing_rc, pwd=CONF.testing_passwd, no_env=CONF.no_env) else: self.cred_testing = None
class TopChans: max_retries = 10 wait_retry_sec = 5 url = "https://api.twitch.tv/kraken/streams" creds = creds.Credentials().creds # Return current top channels in JSON format, number of channels is num def top_channels(self, num): num_retries = 0 while num_retries < self.max_retries: try: print self.creds curr_url = self.url + "?limit=" + str(num) + "&stream_type=live" request = urllib2.Request(curr_url, headers={"Client-ID": self.creds['T_CLIENTID']}) req = urllib2.urlopen(request) data = req.read() res = self.data_to_json(data) return res except Exception, e: print e num_retries = num_retries + 1 if num_retries < self.max_retries: print "Will retry in %d seconds", self.wait_retry_sec sleep(self.wait_retry_sec) else: print "Final retry, won't retry again"
def __init__ (self, username, password): ''' Initialization method for a new client. ''' self.username = username self.password = password self.credential = credentials.Credentials()
def main(): if not os.environ.get('OS_CEILOMETER_URL'): print("ERROR: $OS_CEILOMETER_URL variable not set!") print( "Use this as an example: OS_CEILOMETER_URL=https://compute.datacentred.io:8777" ) exit(1) # get a token creds = credentials.Credentials() token = creds.get_token() ceilomar = ceilomarius.Ceilomarius( api_version=2, endpoint=os.environ['OS_CEILOMETER_URL'], token=token, verbose=False) query = [{ 'field': 'metadata.event_type', 'op': 'eq', 'value': 'compute.instance.exists' }] for l in xrange(1, 11): results = [] objects = [] for iter in xrange(1, 6): resp = ceilomar.get_metric(meter_name="instance", q=query, limit=l) objects = resp.json() elapsed = resp.elapsed.microseconds print("Objects retrieved: {}, us elapsed: {}, try no: {}".format( len(objects), elapsed, iter)) results.append(elapsed) print("Items: {}, avg response time: {}".format( len(objects), numpy.mean(results)))
def __init__(self, ip, port): self.credentials = credentials.Credentials() self.ip = ip self.port = port while True: self.start() time.sleep(0.3)
def __init__(self, appName, appVersion, deviceName, deviceId, capabilities=None, devicePixelRatio=None): log.info("Begin ConnectionManager constructor") self.credentialProvider = cred.Credentials() self.appName = appName self.appVersion = appVersion self.deviceName = deviceName self.deviceId = deviceId self.capabilities = capabilities self.devicePixelRatio = devicePixelRatio
def _create_target(target_config): now = datetime.datetime.utcnow() delta = int(target_config['delta']) creds = credentials.Credentials(target_config['credentials']) return ce_job.CostExplorerJob( name=target_config['name'], labels=target_config['metric_labels'], credentials=creds, metrics=target_config['metric'], granularity=target_config['granularity'].upper(), start=(now - datetime.timedelta(days=delta)).strftime('%Y-%m-%d'), end=now.strftime('%Y-%m-%d'), refresh=target_config['refresh'])
def private_query(self, method, data={}): cred = credentials.Credentials() data['nonce'] = int(1000 * time.time()) urlpath = "/{}/{}/{}".format(self.api_version, self.private, method) complete_url = self.uri + urlpath headers = cred.get_header(data, urlpath) response = requests.post(complete_url, data=data, headers=headers) if response.status_code == 200: js = json.loads(response.content.decode('utf-8')) return js else: return None
def __init__(self): if not os.environ.get('OS_HEAT_URL'): print("ERROR: $OS_HEAT_URL variable not set!") print( "Use this as an example: OS_HEAT_URL=https://compute.datacentred.io:8004/v1/`echo $OS_PROJECT_ID`" ) exit(1) # get a token creds = credentials.Credentials() token = creds.get_token() self.heat = heatclient.client.Client( 1, endpoint=os.environ['OS_HEAT_URL'], token=token)
def __init__(self, config, openstack_spec, config_plugin, factory, notifier=None): # the base config never changes for a given NFVbench instance self.base_config = config # this is the running config, updated at every run() self.config = None self.config_plugin = config_plugin self.factory = factory self.notifier = notifier self.cred = credentials.Credentials(config.openrc_file, None, False) \ if config.openrc_file else None self.chain_runner = None self.specs = Specs() self.specs.set_openstack_spec(openstack_spec) self.vni_ports = [] sys.stdout.flush()
def plugin_init(opts=None): # Parse the credentials of the OpenStack cloud if not opts: opts = OptionsHolder() cred = credentials.Credentials(opts) creds_nova = cred.get_nova_credentials_v2() # Create the nova and neutron instances nova_client = Client(**creds_nova) opts = {'all_tenants': 1} servers = nova_client.servers.list(detailed=True, search_opts=opts) count = 0 for server in servers: chain_id, nvf = decode_instance_name(server.name) if chain_id: full_name = '%s.%02d' % (nvf, chain_id) by_uuid[server.id] = full_name count += 1 print 'Plugin loaded with %d service chain names from Nova' % (count) return True
def main(): parser = argparse.ArgumentParser() parser.add_argument("instance_id", help="Instance ID to compare samples for.") parser.add_argument("--verbose", help="increase output verbosity", action="store_true") args = parser.parse_args() instance_id = args.instance_id verbose = False if args.verbose: print("INFO: Verbosity turned on.") verbose = True print("INFO: This will compare 2 weeks worth of samples for specified instance.") # get a token creds = credentials.Credentials() token = creds.get_token() # get config conf = config.Config() pag = paginator.Paginator(endpoint = conf.ceilometer_endpoint, token = token) mon = mongor.Mongor() time_end = datetime.utcnow() time_begin = time_end - timedelta(days=14) samples_api = pag.get_samples_for_instance(instance_id, time_begin, time_end) samples_db = mon.get_samples_for_instance(instance_id, time_begin, time_end) compare_samples(samples_api, samples_db, verbose) event_samples = extract_events_from_samples(samples_db) if verbose: print("INFO: All the event-based samples:") for event in event_samples: pprint.pprint(event) print("----------------") print( "INFO: There are {} event-based samples.".format(len(event_samples)) )
def __init__(self, config): cred = credentials.Credentials(config.openrc_file, None, False) session = cred.get_session() self.neutron_client = nclient.Client('2.0', session=session) self.nova_client = Client(2, session=session) network_names = [ inet['name'] for inet in config.internal_networks.values() ] network_names.extend( [inet['name'] for inet in config.edge_networks.values()]) router_names = [ rtr['router_name'] for rtr in config.edge_networks.values() ] # add idle networks as well if config.idle_networks.name: network_names.append(config.idle_networks.name) self.cleaners = [ ComputeCleaner(self.nova_client, config.loop_vm_name), FlavorCleaner(self.nova_client, config.flavor_type), NetworkCleaner(self.neutron_client, network_names), RouterCleaner(self.neutron_client, router_names) ]
anchors_ids = [] global News_channel_ids News_channel_ids = [] ld_hndlers = loading_handlers.Loading_Handlers() id_coll = ids_collector_module.ids_collector() tech = ld_hndlers.loading_handlers_in_array('techHandlers') politics = ld_hndlers.loading_handlers_in_array('politicsHANDLERS') sports = ld_hndlers.loading_handlers_in_array('sportsHANDLERS') entertainment = ld_hndlers.loading_handlers_in_array('entertainmentHANDLERS') anchor = ld_hndlers.loading_handlers_in_array('AnchorsHANDLERS') News_channel = ld_hndlers.loading_handlers_in_array('News_channelHANDLERS') api = credentials.Credentials().API() mongo = creatingConnection() Connection = mongo.run() tweet = Streaming_tweets.Tweets() save_Tweet = saveTweet.saveTweet() def ids_collect(api): tech_ids = id_coll.collector(tech, api) politics_ids = id_coll.collector(politics, api) sports_ids = id_coll.collector(sports, api) entertainment_ids = id_coll.collector(entertainment, api) anchors_ids = id_coll.collector(anchor, api) News_channel_ids = id_coll.collector(News_channel, api)
import requests import json import credentials params = (('expire_hours', '2'), ) creds = credentials.Credentials() data = '{"user":"******", "password":"******"}' print(data) resp_token = requests.post('https://pfa.foreca.com/authorize/token', params=params, data=data) print(resp_token) token_data = resp_token.json() resp_token_json = json.loads(json.dumps(token_data)) #NB. Original query string below. It seems impossible to parse and #reproduce query strings 100% accurately so the one below is given #in case the reproduced version is not "correct". # response = requests.post('https://pfa.foreca.com/authorize/token?expire_hours=2', data=data) access_token = resp_token_json['access_token'] headers = { 'Authorization': 'Bearer ' + access_token, } params = (('lang', 'es'), ) resp_tempe = requests.get('https://pfa.foreca.com/api/v1/current/100633679', headers=headers,
default=False, action='store_true', help='do not read env variables') parser.add_argument( '-d', '--debug', dest='debug', default=False, action='store_true', help='debug level', ) (opts, args) = parser.parse_known_args() config_api = configure.Configuration.from_file( default_cfg_file).configure() cred = credentials.Credentials(opts.rc, opts.pwd, opts.no_env) cpulse_log = logging.getLogger() # create formatter formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch = logging.StreamHandler() cpulse_log.addHandler(ch) ch.setFormatter(formatter) if opts.debug: cpulse_log.setLevel(logging.DEBUG) ch.setLevel(logging.DEBUG) health_check_start()
def setUp(self): self.settings = thread_settings.ThreadSettings( credentials.Credentials().access_token)
def main(): parser = argparse.ArgumentParser(description='KloudBuster Force Cleanup') parser.add_argument('-r', '--rc', dest='rc', action='store', required=False, help='openrc file', metavar='<file>') parser.add_argument('-f', '--file', dest='file', action='store', required=False, help='get resources to delete from cleanup log file ' '(default:discover from OpenStack)', metavar='<file>') parser.add_argument('-d', '--dryrun', dest='dryrun', action='store_true', default=False, help='check resources only - do not delete anything') parser.add_argument( '--filter', dest='filter', action='store', required=False, help='resource name regular expression filter (default:"KB")' ' - OpenStack discovery only', metavar='<any-python-regex>') opts = parser.parse_args() cred = credentials.Credentials(opts.rc) if opts.file: resources = get_resources_from_cleanup_log(opts.file) else: # None means try to find the resources from openstack directly by name resources = None global resource_name_re if opts.filter: try: resource_name_re = re.compile(opts.filter) except Exception as exc: print 'Provided filter is not a valid python regular expression: ' + opts.filter print str(exc) sys.exit(1) else: resource_name_re = re.compile('KB') cleaners = KbCleaners(cred, resources, opts.dryrun) if opts.dryrun: print print( '!!! DRY RUN - RESOURCES WILL BE CHECKED BUT WILL NOT BE DELETED !!!' ) print # Display resources to be deleted count = cleaners.show_resources() if not count: sys.exit(0) if not opts.file and not opts.dryrun: prompt_to_run() cleaners.clean()
import time import atexit from apscheduler.schedulers.background import BackgroundScheduler from apscheduler.triggers.cron import CronTrigger import credentials import callybot_database from datetime import datetime from MySQLdb import OperationalError import restart_VPN import logg import sys sys.stdout = logg.Logger(sys.stdout, open('log.txt', 'a')) # Writes to file and console app = Flask(__name__) credential = credentials.Credentials() db_credentials = credential.db_info db = callybot_database.CallybotDB(db_credentials[0], db_credentials[1], db_credentials[2], db_credentials[3]) replier = reply.Reply(credential.access_token, db) received_message = [] def init(): reminder_interrupt() restart_vpn_interrupt() clear_old_reminders() thread_handler = thread_settings.ThreadSettings(credential.access_token) thread_handler.whitelist("https://folk.ntnu.no/halvorkmTDT4140/") thread_handler.set_greeting( "Hi there {{user_first_name}}!\nWelcome to CallyBot. Press 'Get Started' to get started!"
def main(): if not os.environ.get('OS_CEILOMETER_URL'): print("ERROR: $OS_CEILOMETER_URL variable not set!") print( "Use this as an example: OS_CEILOMETER_URL=https://compute.datacentred.io:8777" ) exit(1) parser = argparse.ArgumentParser() parser.add_argument("stack_id", help="The ID or name of the stack with resources.") parser.add_argument("--verbose", help="increase output verbosity", action="store_true") args = parser.parse_args() verbose = False if args.verbose: print("INFO: Verbosity turned on.") verbose = True # get a token creds = credentials.Credentials() token = creds.get_token() # use the token with ceilometer's endpoint # NOTE: Sadly, the official client doesn't seem to work with the `limit` parameter. # NOTE: Use the new custom class. # #cclient = ceilometerclient.client.get_client(2, # os_endpoint=os.environ['OS_CEILOMETER_URL'], # os_token=token) #query_samples = [dict(field='meter', op='eq', value='instance')] #print( cclient.samples.list( q=query_samples, limit=1 ) ) ceilomar = ceilomarius.Ceilomarius( api_version=2, endpoint=os.environ['OS_CEILOMETER_URL'], token=token, verbose=verbose) stack_id = args.stack_id stack = stacker.Stacker() resources = stack.get_resources_in_stack(stack_id) # stores every meter associated with resources from this stack meters_all = dict() for res in resources: if verbose: print("INFO: Retrieved resource: %s" % res) meters_all.update(ceilomar.get_meters_for_resource(res, limit=1)) if verbose: for key in meters_all.keys(): print("INFO: All meters retrieved from the stack:") print("INFO: The main key: %s" % key) print("INFO: Values for this key:") for item in meters_all.get(key): print("INFO: counter_name: {}, resource_id: {}, timestamp: {}". format(item.get('counter_name'), item.get('resource_id'), item.get('timestamp'))) # variables for stats on the number of found meters n_required = 0 n_found = 0 # read required meters from a file with open('required_meters.txt', 'r') as f: for line in f: meter = line.strip() if meter in meters_all: for item in meters_all[meter]: print("meter: {meter} -> timestamp: {timestamp}".format( meter=item.get('counter_name'), timestamp=item.get('timestamp'))) if verbose: print("INFO: Resource metadata:") print("INFO: {}".format(item.get('resource_metadata'))) n_found += 1 n_required += 1 print("Found {} out of all {} meters!".format(n_found, n_required))
class ChanConn(threading.Thread): # Variable definitions creds = credentials.Credentials().creds NICK = creds['T_NICK'] PASS = creds['T_PASS'] HOST = "irc.twitch.tv" PORT = 6667 output_path = "data/" nickname = "brohunt" # Initialize the connection. def __init__(self, chan): reload(sys) sys.setdefaultencoding( 'utf8') # this is needed for the write to work with utf8 threading.Thread.__init__(self) # call superclass # Set default values self.logger = logging.getLogger('main_log') self.connected = False self.socket = None self.file_raw = None self.file_filtered = None self.active = True self.chan = chan self.database = Database() # Setup output files self.file_path = self.output_path + str(chan) self.file_raw = codecs.open(self.file_path+"_raw", 'w', \ encoding='utf8') self.file_filtered = codecs.open(self.file_path, 'w', \ encoding='utf8') self.socket = socket.socket() self.connect() self.join_chan(chan) # Connect to irc server def connect(self): try: self.socket.connect((self.HOST, self.PORT)) self.send("PASS %s" % self.PASS) self.send("NICK %s" % self.NICK) except socket.timeout: self.active = False self.logger.error("Socket timeout for server connect.\ Aborting this thread.") # Connect to a given channel def join_chan(self, channel): channel = "#" + channel self.send("JOIN %s" % channel) # Run thread and listen to the joined channel def run(self): while self.active: # Read message from connected channels try: buf = self.socket.recv(4096) except socket.timeout: self.logger.error( "Got timeout for channel %s when\ waiting for a message. Shutting down.", self.chan) self.stop() continue # Skip rest of loop so we shutdown nice. except socket.error: self.logger.error( "Got an error for channel %s when\ waiting for a message. Shutting down.", self.chan) self.stop() continue # Skip rest of loop so we shut down nice. lines = buf.split("\n") timestamp = datetime.datetime.now().strftime('%y-%m-%d %H:%M:%S') for data in lines: data = str(data).strip() if data == '': continue parsed = None try: msg = timestamp + data + "\n" self.file_raw.write(msg) parsed = self.parse_json(data, timestamp) print parsed self.database.insert(parsed) print parsed except UnicodeDecodeError: logging.error( "Could not write raw message: [ %s ], to file.", msg) if parsed != None: try: self.file_filtered.write(json.dumps(parsed) + "\n") except UnicodeDecodeError: logging.error("Could not write parsed [ %s ] to file.", parsed) self.stop() break # To skip the consequtive code # server ping/pong? if data.find('PING') != -1: n = data.split(':')[1] self.send('PONG :' + n) if self.connected == False: self.perform() self.connected = True args = data.split(None, 3) if len(args) != 4: continue ctx = {} ctx['sender'] = args[0][1:] ctx['type'] = args[1] ctx['target'] = args[2] ctx['msg'] = args[3][1:] # whom to reply? target = ctx['target'] if ctx['target'] == self.nickname: target = ctx['sender'].split("!")[0] self.handle_exit() # This will make the next while-loop to break and the thread to terminate def stop(self): self.active = False # Send a message through the socket def send(self, msg): self.socket.send(msg + "\r\n") def perform(self): self.send("PRIVMSG R : Login <>") self.send("MODE %s +x" % self.nickname) # Convert the read data into a json object def parse_json(self, data, time): if data.find('PRIVMSG') == -1: return None if data.find('jtv') != -1: return None exclam_index = data.find('!') # nickname starts at 1 since every message starts with ':' # which is not part of nickname nickname = data[1:exclam_index] hashtag_index = data.find('#') chan_end_index = hashtag_index + data[hashtag_index:].find(':') chan = data[hashtag_index:chan_end_index] msg_start_index = chan_end_index + data[chan_end_index:].find(':') msg = data[msg_start_index + 1:] if exclam_index == -1 \ or hashtag_index == -1 \ or msg_start_index == -1: return None json_dict = { 'nickname': nickname, 'channel': chan, 'message': msg, 'time': time } return json_dict def handle_exit(self): # This is where we are supposed to make calls to S3_handle to # Save away our chat logs self.socket.close() self.file_raw.close() self.file_filtered.close()
help='Specify branches name') env_data.add_argument('-rg', required=True, type=str, help='Specify AWS Region name') # endregion # region VARS args = vars(env_data.parse_args()) ENV = args['v'] REPO = args['r'] EMAIL = args['e'] BRANCH = args['b'] REG = args['rg'] repo_name = '{}/{}'.format(ENV, REPO) git_api = credentials.Credentials(cred_type='gitapi', region=REG).get_secret().get('api') username_cc = credentials.Credentials(cred_type='codecommit', region=REG).get_secret().get('username') password_cc = credentials.Credentials(cred_type='codecommit', region=REG).get_secret().get('password') check = check_list.Checklist(repo_name=repo_name, api_key=git_api) parsed_branch = [] bran = branches.Branch(repo_name=repo_name, api_key=git_api) # endregion for item in BRANCH.split(','): parsed_branch.append(item) if parsed_branch[0] == 'all': parsed_branch = bran.get_branches_list() parsed_branch = list(dict.fromkeys(parsed_branch))
from yowsup.layers.logger import YowLoggerLayer from yowsup.stacks import YowStack from yowsup.common import YowConstants from yowsup.layers import YowLayerEvent from yowsup.stacks import YowStack, YOWSUP_CORE_LAYERS from yowsup.layers.axolotl import YowAxolotlLayer from yowsup import env try: import credentials as crdntials except Exception: print '''Your phone nr credentials could not be loaded. Read the instructions in the credentials_todo.py file. Don't forget to rename the file to credentials.py''' crdntls = crdntials.Credentials() CREDENTIALS = (crdntls.getlogin(), crdntls.getpassword()) if __name__ == "__main__": layers = ( EchoLayer, # YowParallelLayer([YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer]),YowAxolotlLayer # ) + YOWSUP_CORE_LAYERS YowParallelLayer([ YowAuthenticationProtocolLayer, YowMessagesProtocolLayer, YowReceiptProtocolLayer, YowAckProtocolLayer, YowMediaProtocolLayer, YowIqProtocolLayer, YowCallsProtocolLayer ]), YowAxolotlLayer, YowLoggerLayer, YowCoderLayer,