def setClient(self, instagramAC):
logging.info(" Connecting Instagram")
try:
keyring.set_keyring(keyrings.alt.file.PlaintextKeyring())
username = instagramAC
self.user = instagramAC
server = 'instagram'
password = keyring.get_password(server,username)
if not password:
logging.info("[%s,%s] New account. Setting password" % (server, username))
password = getpass.getpass()
keyring.set_password(server, username, password)
try:
api = InstagramAPI(username, password)
api.login() # login
logging.info(" Logging OK")
except:
logging.warning("Instagram authentication failed!")
logging.warning("Unexpected error:", sys.exc_info()[0])
except:
logging.warning("Account not configured")
api = None
self.client = api
def test_crypted_keyring_migration_add(self):
'''Test CryptedFileKeyring Migration by adding'''
self._create_old_keyrings()
keyring.set_keyring(StubbedCryptedFileKeyring())
self._password_test()
self._check_file_permissions(self.crypted)
def run(self, argv):
opts, args = self.parser.parse_args(argv)
try:
kind, service, username = args
except ValueError:
if len(args) == 0:
# Be nice with the user if he just tries to launch the tool
self.parser.print_help()
return 1
else:
self.parser.error("Wrong number of arguments")
if opts.keyring_backend is not None:
try:
backend = keyring.core.load_keyring(opts.keyring_path,
opts.keyring_backend)
keyring.set_keyring(backend)
except Exception, e:
# Tons of things can go wrong here:
# ImportError when using "fjkljfljkl"
# AttributeError when using "os.path.bar"
# TypeError when using "__builtins__.str"
# So, we play on the safe side, and catch everything.
self.parser.error("Unable to load specified keyring: %s" % e)
def test_uncrypted_keyring_migration_add(self):
'''Test UncryptedFileKeyring Migration by adding'''
self._create_old_keyrings()
keyring.set_keyring(keyring.backend.UncryptedFileKeyring())
self._password_test()
self._check_file_permissions(self.uncrypted)
def main():
parser = \
argparse.ArgumentParser(description='Store a secret in local keychain')
parser.add_argument('--backend',
type=str,
nargs='?',
help='Keyring backend to use')
parser.add_argument('service',
type=str,
help='service to log into (e.g., URL)')
parser.add_argument('username', type=str, help='Username to use')
args = parser.parse_args()
service: str = args.service
username: str = args.username
backend: str = args.backend
if sys.stdin.isatty():
password: str = input('Password: ')
else:
password = input()
if backend is not None:
keyring.set_keyring(core.load_keyring(backend))
keyring.set_password(service, username, password)
def check_keyring_support():
"""
Check if the UserNamePassword class can be used,
else raise ImportError with an explanatory error message.
"""
global keyring
# if gnomekeyring exists, block kde libraries
old_pykde4 = sys.modules.get('PyKDE4')
try:
import gnomekeyring
except ImportError:
pass
else:
sys.modules['PyKDE4'] = None
try:
import keyring
except ImportError:
global UserNamePassword
class UserNamePassword (object):
pass
raise
else:
# Configure the fallback keyring's configuration file if used
import keyring.backend
kr = keyring.get_keyring()
if hasattr(kr, "crypted_password"):
keyring.set_keyring(keyring.backend.UncryptedFileKeyring())
kr = keyring.get_keyring()
if hasattr(kr, "file_path"):
kr.file_path = config.save_config_file("keyring.cfg")
finally:
# now unblock kde libraries again
if old_pykde4:
sys.modules['PyKDE4'] = old_pykde4
def keyring_backend():
"""Temporary set in-memory keyring as current backend."""
prev_backend = keyring.get_keyring()
keyring.set_keyring(_InmemoryKeyring())
yield keyring.get_keyring()
keyring.set_keyring(prev_backend)
def set_keyring_in_runtime():
"""This function shows how to create a keyring manully and use it
in runtime
"""
# define a new keyring class which extends the KeyringBackend
import keyring.backend
class TestKeyring(keyring.backend.KeyringBackend):
"""A test keyring which always outputs same password
"""
def supported(self):
return 0
def set_password(self, servicename, username, password):
return 0
def get_password(self, servicename, username):
return "password from TestKeyring"
# set the keyring for keyring lib
import keyring
keyring.set_keyring(TestKeyring())
# invoke the keyring lib
try:
keyring.set_password("demo-service", "tarek", "passexample")
print "password stored sucessfully"
except keyring.backend.PasswordSetError:
print "failed to store password"
print "password", keyring.get_password("demo-service", "tarek")
def setUp(self, autoload_discovery=True):
yield super(TestAsServer, self).setUp(annotate=False)
self.setUpPreSession()
# We don't use the system keychain but a PlainText keyring for performance during tests
for new_keyring in keyring.backend.get_all_keyring():
if isinstance(new_keyring, PlaintextKeyring):
keyring.set_keyring(new_keyring)
self.quitting = False
self.seeding_deferred = Deferred()
self.seeder_session = None
self.seed_config = None
self.session = Session(self.config)
self.session.upgrader_enabled = False
self.tribler_started_deferred = self.session.start()
yield self.tribler_started_deferred
self.assertTrue(self.session.lm.initComplete)
self.hisport = self.session.config.get_libtorrent_port()
self.annotate(self._testMethodName, start=True)
def main():
parser: ArgumentParser =\
ArgumentParser(description='Retrieve a secret in local keychain')
parser.add_argument('--backend',
type=str,
nargs='?',
help='Keyring backend to use')
parser.add_argument('service',
type=str,
help='service to log into (e.g., URL)')
parser.add_argument('username', type=str, help='Username to use')
args: Namespace = parser.parse_args()
service: str = args.service
username: str = args.username
backend: str = args.backend
if backend is not None:
keyring.set_keyring(core.load_keyring(backend))
password: str = keyring.get_password(service, username)
if password is None:
exit(1)
else:
print(password)
def instantiate(cls):
keyring.set_keyring(keyring.backend.CryptedFileKeyring())
if cls.keyring_password is not None:
return
cls.load_keyring_password()
if cls.keyring_password is None:
cls.prompt_keyring_password()
def __init__(self, name, config):
self.name = name
self._config = config
# The pycrypto encrypted keyring asks for a password in every launch
# if isinstance(keyring.get_keyring(), keyrings.alt.file.EncryptedKeyring):
keyring.set_keyring(keyrings.alt.file.PlaintextKeyring())
def set_keyring_in_runtime():
"""This function shows how to create a keyring manully and use it
in runtime
"""
# define a new keyring class which extends the KeyringBackend
import keyring.backend
class TestKeyring(keyring.backend.KeyringBackend):
"""A test keyring which always outputs same password
"""
def supported(self): return 0
def set_password(self, servicename, username, password): return 0
def get_password(self, servicename, username):
return "password from TestKeyring"
# set the keyring for keyring lib
import keyring
keyring.set_keyring(TestKeyring())
# invoke the keyring lib
try:
keyring.set_password("demo-service", "tarek", "passexample")
print "password stored sucessfully"
except keyring.backend.PasswordSetError:
print "failed to store password"
print "password", keyring.get_password("demo-service", "tarek")
def setUp(self):
if keyring is None:
self.skipTest(
'optional package keyring or pickle is not installed')
class MemoryKeyring(keyring.backend.KeyringBackend):
"""Simple memory keyring with support for multiple keys."""
def __init__(self):
self.passwords = {}
def supported(self):
return 1
def get_password(self, service, username):
key = username + '@' + service
if key not in self.passwords:
return None
return self.passwords[key]
def set_password(self, service, username, password):
key = username + '@' + service
self.passwords[key] = password
super(KeyringTest, self).setUp()
keyring.set_keyring(MemoryKeyring())
def keyring_backend():
saved_backend = keyring.get_keyring()
try:
keyring.set_keyring(MockKeyringBackend())
yield
finally:
keyring.set_keyring(saved_backend)
def run(self, argv):
opts, args = self.parser.parse_args(argv)
try:
kind, service, username = args
except ValueError:
if len(args) == 0:
# Be nice with the user if he just tries to launch the tool
self.parser.print_help()
return 1
else:
self.parser.error("Wrong number of arguments")
if opts.keyring_backend is not None:
try:
backend = keyring.core.load_keyring(opts.keyring_path,
opts.keyring_backend)
keyring.set_keyring(backend)
except Exception, e:
# Tons of things can go wrong here:
# ImportError when using "fjkljfljkl"
# AttributeError when using "os.path.bar"
# TypeError when using "__builtins__.str"
# So, we play on the safe side, and catch everything.
self.parser.error("Unable to load specified keyring: %s" % e)
def setUp(self):
if keyring is None:
self.skipTest(
'optional package keyring or pickle is not installed')
class MemoryKeyring(keyring.backend.KeyringBackend):
"""Simple memory keyring with support for multiple keys"""
def __init__(self):
self.passwords = {}
def supported(self):
return 1
def get_password(self, service, username):
key = username + '@' + service
if key not in self.passwords:
return None
return self.passwords[key]
def set_password(self, service, username, password):
key = username + '@' + service
self.passwords[key] = password
super(KeyringTest, self).setUp()
keyring.set_keyring(MemoryKeyring())
def main(argv=None):
"""Main command line interface."""
parser = optparse.OptionParser(usage="%prog [get|set] SERVICE USERNAME")
parser.add_option("-p", "--keyring-path", dest="keyring_path", default=None,
help="Path to the keyring backend")
parser.add_option("-b", "--keyring-backend", dest="keyring_backend", default=None,
help="Name of the keyring backend")
if argv is None:
argv = sys.argv[1:]
opts, args = parser.parse_args(argv)
try:
kind, service, username = args
except ValueError:
if len(args) == 0:
# Be nice with the user if he just tries to launch the tool
parser.print_help()
return 1
else:
parser.error("Wrong number of arguments")
if opts.keyring_backend is not None:
try:
backend = keyring.core.load_keyring(opts.keyring_path, opts.keyring_backend)
keyring.set_keyring(backend)
except Exception, e:
# Tons of things can go wrong here:
# ImportError when using "fjkljfljkl"
# AttributeError when using "os.path.bar"
# TypeError when using "__builtins__.str"
# So, we play on the safe side, and catch everything.
parser.error("Unable to load specified keyring: %s" % e)
def initialize_keychain():
# NB: keyring has a config file, but it only allows a single keyring to be
# selected, instead of reusing it's supported() method check against a list
# of backend implementations to try.
keyring_backends = []
with load_config(sections=AUTH_SECTIONS, defaults=AUTH_CONFIG_DEFAULTS) as config:
if config.get(KEYCHAIN_SECTION, 'crypted-keychain.enable'):
keyring_backends.insert(0, CryptedFileKeyring())
if config.get(KEYCHAIN_SECTION, 'kde-keychain.enable'):
keyring_backends.insert(0, KDEKWallet())
if config.get(KEYCHAIN_SECTION, 'gnome-keychain.enable'):
keyring_backends.insert(0, GnomeKeyring())
keyring_backends.insert(0, FixedOSXKeychain())
keyring_backends.sort(key=lambda x: -x.supported())
keyring.set_keyring(keyring_backends[0])
# Return True if there are any supported keychains.
return not all(i.supported() == -1 for i in keyring_backends)
def add_credentials(user, password, hostname, account_name,
account_password, verbose=False):
'''
Add a new Inventory item
'''
c = CallipygeBackend(user, verbose)
keyring.set_keyring(c)
c.set_password(account_name, account_password)
def _load_backend(self):
try:
keyring_backend = keyring.core.load_keyring(self._backend_cls_name)
except ModuleNotFoundError:
msg = "Invalid credentials_mgr_class: {}".format(
self._backend_cls_name)
raise oscerr.ConfigError(msg, conf.config['conffile'])
keyring.set_keyring(keyring_backend)
def mock_chainer_backend(mocker):
from keyring.backends.fail import Keyring
mocker.patch("keyring.backend.get_all_keyring", [Keyring()])
import keyring
from keyring.backends.chainer import ChainerBackend
keyring.set_keyring(ChainerBackend())
def test_uncrypted_keyring_migration_get(self):
'''Test UncryptedFileKeyring Migration by getting'''
self._create_old_keyrings()
keyring.set_keyring(keyring.backend.UncryptedFileKeyring())
password = keyring.get_password('qrt-script', 'migrationuser')
error = "Couldn't locate old data!"
self.assertEquals(password, 'migrationpass', error)
self._check_file_permissions(self.uncrypted)
def keyring_credentials(ring=_KEYRING):
'''Looks up the user's credentials.'''
if sys.platform.startswith('win'):
keyring.set_keyring(WinVaultKeyring())
if sys.platform.startswith('darwin'):
keyring.set_keyring(Keyring())
value = keyring.get_password(ring, getpass.getuser())
if __debug__: log(f'got "{value}" from keyring {_KEYRING}')
return _decoded(value) if value else (None, None)
def setUp(self):
keyring.set_keyring(PlaintextKeyring())
self.env = EnvironmentVarGuard()
self.temp_file = tempfile.NamedTemporaryFile()
test_path = os.path.dirname(os.path.realpath(__file__))
self.env['XDG_DATA_HOME'] = test_path
self.env['XDG_CONFIG_HOME'] = test_path
def with_chained_null_keyring(mocker: MockerFixture) -> None:
from keyring.backends.null import Keyring
mocker.patch("keyring.backend.get_all_keyring", lambda: [Keyring()])
import keyring
from keyring.backends.chainer import ChainerBackend
keyring.set_keyring(ChainerBackend())
def with_chained_keyring(mocker: "MockerFixture") -> None:
from keyring.backends.fail import Keyring
mocker.patch("keyring.backend.get_all_keyring", [Keyring()])
import keyring
from keyring.backends.chainer import ChainerBackend
keyring.set_keyring(ChainerBackend())
def _configure_keyring(cls):
# Configure the fallback keyring's configuration file if used
import keyring.backend
kr = keyring.get_keyring()
if hasattr(kr, "crypted_password"):
keyring.set_keyring(keyring.backend.UncryptedFileKeyring())
kr = keyring.get_keyring()
if hasattr(kr, "file_path"):
kr.file_path = config.save_config_file("keyring.cfg")
def setUp(self):
keyring.set_keyring(PlaintextKeyring())
self.env = EnvironmentVarGuard()
self.temp_file = tempfile.NamedTemporaryFile()
test_path = os.path.dirname(os.path.realpath(__file__))
self.env['XDG_DATA_HOME'] = test_path
self.env['XDG_CONFIG_HOME'] = test_path
def __init__(self):
super(Wallet, self).__init__()
self._logger = logging.getLogger(self.__class__.__name__)
# We use an unencrypted keyring since an encrypted keyring requires input from stdin.
if isinstance(keyring.get_keyring(), EncryptedKeyring):
for new_keyring in keyring.backend.get_all_keyring():
if isinstance(new_keyring, PlaintextKeyring):
keyring.set_keyring(new_keyring)
def save_keyring_credentials(api_key, user_id, ring=_KEYRING):
'''Saves the user's credentials.'''
if sys.platform.startswith('win'):
keyring.set_keyring(WinVaultKeyring())
if sys.platform.startswith('darwin'):
keyring.set_keyring(Keyring())
value = _encoded(api_key, user_id)
if __debug__: log(f'storing "{value}" to keyring {_KEYRING}')
keyring.set_password(ring, getpass.getuser(), value)
def main():
keyring.set_keyring(EncryptedEnvKeyring())
config = configparser.ConfigParser()
config.read(os.path.join(os.path.dirname(__file__), 'config.ini'))
mailboxes = [mailbox for mailbox in config.sections() if mailbox != 'global']
for mailbox in mailboxes:
username = config[mailbox]['username']
mail_password = getpass.getpass(f"Please enter password for {username} @ {mailbox} mailbox: ")
keyring.set_password(f"MailChecker-{mailbox}", username, mail_password)
def save_keyring_credentials(service, user, pswd, host=None, port=None):
'''Saves the user, password, host and port info for 'service'.'''
user = user if user else ''
pswd = pswd if pswd else ''
host = host if host else ''
port = port if port else ''
if sys.platform.startswith('win'):
keyring.set_keyring(WinVaultKeyring())
keyring.set_password(service, 'credentials',
_encoded(user, pswd, host, port))
def test_crypted_keyring_migration_get(self):
'''Test CryptedFileKeyring Migration by getting'''
# This is LP: #1042754
self._create_old_keyrings()
keyring.set_keyring(StubbedCryptedFileKeyring())
password = keyring.get_password('qrt-script', 'migrationuser')
error = "Couldn't locate old data!"
self.assertEquals(password, 'migrationpass', error)
self._check_file_permissions(self.crypted)
def getKr(self):
if os.name != 'nt':
#logging.getLogger().exception("getlogger "+self.configfile)
config = configparser.ConfigParser()
config.read(self.configfile)
sd = config.get("other", "startdate")
pc = config.get("other", "postcode")
kr = CryptFileKeyring()
kr.keyring_key = pc + platform.node() + os.name + sd + "!djl!"
keyring.set_keyring(kr)
def keyring_credentials(service, user=None):
'''Looks up the user's credentials for the given 'service' using the
keyring/keychain facility on this computer. If 'user' is None, this uses
the fake user named "credentials". The latter makes it possible to access a
service with a different user login name than the user's current login
name without having to ask the user for the alternative name every time.
'''
if sys.platform.startswith('win'):
keyring.set_keyring(WinVaultKeyring())
value = keyring.get_password(service, user if user else 'credentials')
return _decoded(value) if value else (None, None, None, None)
def save_session(self, **save_session_kwargs):
if self.SESSION_ARG_KEYNAME not in save_session_kwargs:
raise ValueError(
'"%s" must be specified in save_session() argument.' %
self.SESSION_ARG_KEYNAME)
data = base64.b64encode(
zlib.compress(pickle.dumps(self,
self.PICKLE_PROTOCOL))).decode('utf-8')
keyring.set_keyring(PlaintextKeyring())
keyring.set_password(self.KEYRING_SERVICE_NAME,
save_session_kwargs[self.SESSION_ARG_KEYNAME],
data)
def __init__(self):
super(Wallet, self).__init__()
self._logger = logging.getLogger(self.__class__.__name__)
# When there is no available keyring backend, we use an unencrypted keyring on Linux since an encrypted keyring
# requires input from stdin.
if sys.platform.startswith('linux'):
from keyrings.alt.file import EncryptedKeyring, PlaintextKeyring
if isinstance(keyring.get_keyring(), EncryptedKeyring):
for new_keyring in keyring.backend.get_all_keyring():
if isinstance(new_keyring, PlaintextKeyring):
keyring.set_keyring(new_keyring)
def __init__(self,
force_keyring: keyring.backend.KeyringBackend = None) -> None:
"""
Init KeyringTotpGenerator object.
:param force_keyring: Keyring backend object to use. Defaults to
None and is auto selected.
:type force_keyring: keyring.backend.KeyringBackend
"""
self.user = getuser()
if force_keyring:
keyring.set_keyring(force_keyring)
self.creds = self.load_creds()
def setUp(self):
self.test_dir = tempfile.mkdtemp()
self.path = os.path.join(self.test_dir, "conf1.json")
self.config = ConfigFile(self.path)
self.site = DummySite(self.config)
self.engine = DummyEngine(self.site)
self._initial_keyring = keyring.get_keyring()
self.keyring = TestKeyring()
keyring.set_keyring(self.keyring)
self.credentials_manager = AWSCredentialsManager(self.engine)
def run(self, argv):
opts, args = self.parser.parse_args(argv)
try:
kind, service, username = args
except ValueError:
if len(args) == 0:
# Be nice with the user if he just tries to launch the tool
self.parser.print_help()
return 1
else:
self.parser.error("Wrong number of arguments")
if opts.keyring_backend is not None:
try:
backend = keyring.core.load_keyring(opts.keyring_path,
opts.keyring_backend)
keyring.set_keyring(backend)
except (Exception,):
# Tons of things can go wrong here:
# ImportError when using "fjkljfljkl"
# AttributeError when using "os.path.bar"
# TypeError when using "__builtins__.str"
# So, we play on the safe side, and catch everything.
e = sys.exc_info()[1]
self.parser.error("Unable to load specified keyring: %s" % e)
if kind == 'get':
password = keyring.get_password(service, username)
if password is None:
return 1
self.output_password(password)
return 0
elif kind == 'set':
password = self.input_password("Password for '%s' in '%s': " %
(username, service))
keyring.set_password(service, username, password)
return 0
elif kind == 'del':
password = self.input_password("Deleting password for '%s' in '%s': " %
(username, service))
keyring.delete_password(service, username)
return 0
else:
self.parser.error("You can only 'get', 'del' or 'set' a password.")
pass
def main():
"""
Prompts for username, service name and password and generates a new encrypted keyring.
"""
keyring.set_keyring(keyring.backend.CryptedFileKeyring())
username = raw_input("Username: "******"Service name: ")
password = getpass.getpass("Password: "******"Password (again): ")
assert password == verify_password
keyring.set_password(service_name, username, password)
def __init__(self):
log_handler = logging.FileHandler("nikeplus_harvester.log", "a")
log_handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(name)s\t%(levelname)s\t%(asctime)s\t%(message)s')
log_handler.setFormatter(formatter)
self.logger = logging.getLogger()
self.logger.setLevel(logging.DEBUG)
for handler in self.logger.handlers:
self.logger.removeHandler(handler)
self.logger.addHandler(log_handler)
data_root = keyring.util.platform_.data_root()
if not os.path.exists(data_root):
os.mkdir(data_root)
keyring.set_keyring(PlaintextKeyring())
self.parser = argparse.ArgumentParser(prog="run")
self.parser.add_argument('--config', help="Set config (input requires JSON) and exit.")
self.parser.add_argument('--get-config', action="store_true", help="Output current config as JSON and exit.")
self.parser.add_argument('--server', help="The server URL to connect to.")
self.nike = NikePlus()
self.box_version = 0
self.harvester_id = "nikeplus_harvester"
self.fuel_ts_id = "nikeplus_fuel_ts"
self.calories_ts_id = "nikeplus_calories_ts"
self.steps_ts_id = "nikeplus_steps_ts"
self.stars_ts_id = "nikeplus_stars_ts"
self.ts_ids_by_type = {'FUEL':self.fuel_ts_id, 'CALORIES':self.calories_ts_id, 'STEPS':self.steps_ts_id, 'STARS':self.stars_ts_id }
self.ts_count = 0
self.ts_error = None
self.rdf_types = {
'FUEL':'http://sociam.org/ontology/health/NikeFuel',
'CALORIES':'http://sociam.org/ontology/health/CaloriesBurned',
'STEPS':'http://sociam.org/ontology/health/StepCount',
'STARS':'http://sociam.org/ontology/health/Intensity'
}
self.zeros = self.today()
self.new_zeros = self.today()
self.retrieved = self.today()
self.config_box = None
self.config_indx_user = None
self.config_indx_pass = None
self.config_max_date = datetime(2013, 7, 1)
def __init__(self, database, cache_dir='cache'):
# Fix the keyring
# TODO this is unsafe but makes the tests pass
if keyring.get_keyring().__class__.__name__ == "EncryptedKeyring":
for new_keyring in keyring.backend.get_all_keyring():
if new_keyring.__class__.__name__ == "PlaintextKeyring":
keyring.set_keyring(new_keyring)
self.database = database
self.input_handler = None
self.entered_inputs = {} # Keeps track of all entered inputs
self.cookie_jar = LWPCookieJar()
self.cache_dir = cache_dir
self.persistent_storage = {}
self._logger = logging.getLogger(self.__class__.__name__)
self.load_storage()
def __init__(self):
log_handler = logging.FileHandler("fitbit_harvester.log", "a")
log_handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(name)s\t%(levelname)s\t%(asctime)s\t%(message)s')
log_handler.setFormatter(formatter)
self.logger = logging.getLogger()
self.logger.setLevel(logging.DEBUG)
for handler in self.logger.handlers: # remove default handler
self.logger.removeHandler(handler)
self.logger.addHandler(log_handler)
data_root = keyring.util.platform_.data_root()
if not os.path.exists(data_root):
os.mkdir(data_root)
keyring.set_keyring(PlaintextKeyring())
self.parser = argparse.ArgumentParser(prog="run")
self.parser.add_argument('--config', help="Set config (input requires JSON) and exit.")
self.parser.add_argument('--get-config', action="store_true", help="Output current config as JSON and exit.")
self.parser.add_argument('--server', help="The server URL to connect to.")
# init fitbit
consumer_key = "9cc7928d03fa4e1a92eda0d01ede2297"
consumer_secret = "340ea36a974e47738a335c0cccfe1fcf"
self.fitbit = Fitbit(consumer_key, consumer_secret)
self.fitbit_intraday = None
self.box_version = 0
self.config_overwrite = False;
self.config_start = self.today()
self.config_box = None
self.config_indx_user = None
self.config_indx_pass = None
self.config_fetched_days = []
self.config_zeros_from = self.today()
self.harvester_id = "fitbit_harvester"
self.steps_ts_id = "fitbit_steps_ts"
self.calories_ts_id = "fitbit_calories_ts"
self.distance_ts_id = "fitbit_distance_ts"
self.floors_ts_id = "fitbit_floors_ts"
self.elevation_ts_id = "fitbit_elevation_ts"
self.ts_count = 0
self.ts_error = None
def get_binstar(args=None):
from binstar_client import Binstar
if args and args.token:
token = args.token
else:
config = get_config()
if config.get('keyring', 'plain-text') == 'plain-text':
set_keyring(PlaintextKeyring())
kr = get_keyring()
token = kr.get_password('binstar-token', getpass.getuser())
url = get_config().get('url', 'https://api.binstar.org')
return Binstar(token, domain=url,)
def setUp(self):
if keyring is None:
self.skipTest(
'optional package keyring or pickle is not installed')
class MemoryKeyring(keyring.backend.KeyringBackend):
"""A Simple testing keyring.
This class supports stubbing an initial password to be returned by
setting password, and allows easy password and key retrieval. Also
records if a password was retrieved.
"""
def __init__(self):
self.key = None
self.password = None
self.fetched = False
self.get_password_called = False
self.set_password_called = False
def supported(self):
return 1
def get_password(self, service, username):
self.get_password_called = True
key = username + '@' + service
# make sure we don't get passwords crossed if one is enforced.
if self.key and self.key != key:
return None
if self.password:
self.fetched = True
return self.password
def set_password(self, service, username, password):
self.set_password_called = True
self.key = username + '@' + service
self.password = password
super(KeyringTest, self).setUp()
self.memory_keyring = MemoryKeyring()
keyring.set_keyring(self.memory_keyring)
def __init__(self):
# consoleCfg = logging.StreamHandler()
# consoleCfg.setFormatter(logging.Formatter( ' %(message)s' , '%H:%M:%S'))
# logging.getLogger().addHandler(consoleCfg)
# logging.getLogger().setLevel(logging.DEBUG)
rc = airrc.AirRC()
if not rc.get('you')['login']:
console.error('You must provide your github login to be able to use most of the API')
uname = rc.get('you')['login'];
if System.OS == 'Darwin':
keyring.set_keyring(OSXPatchedKeyring())
pwd = keyring.get_password('github.com', uname)
if not pwd:
console.fail('Unauthorized to access passwords, or no password found for that user in the internet keyring')
# API requestor
self.requestor = Requestor(uname, pwd)
def __identify_keyring(self):
# identify the system
if sys.platform == 'linux':
kwallet = None
gnome_keyring = None
for __keyring in keyring.backend.get_all_keyring():
if __keyring.name.find('kwallet') != -1:
kwallet = __keyring
# This is gnome keyring
elif __keyring.name.find('SecretService') != -1:
gnome_keyring = __keyring
if kwallet != None:
keyring.set_keyring(kwallet)
self.__keyring = kwallet
elif gnome_keyring != None:
keyring.set_keyring(gnome_keyring)
self.__keyring = gnome_keyring
else:
print("Unsupported keyring", file=sys.stderr)
else:
print("Unsupported keyring", file=sys.stderr)
def initKeystore(options):
u = []
s = ''
if options.keystore == 'memory':
log.debug('Setting keystore to in-memory')
keyring.set_keyring(memkeyring.MemKeyring())
for user in (options.sshuser, options.ldapuser, options.ipmiuser):
if user is not None:
u.append(user)
s = 'These credentials will be stored in memory only.'
else:
if options.sshuser is not None and getPassword(options.sshuser) is None:
u.append(options.sshuser)
if options.ldapuser is not None and getPassword(options.ldapuser) is None:
u.append(options.ldapuser)
if options.ipmiuser is not None and getPassword(options.ipmiuser) is None:
u.append(options.ipmiuser)
s = 'These credentials will be stored in your OS keystore.'
if options.secrets is not None and os.path.isfile(options.secrets):
secrets = json.load(open(options.secrets, 'r'))
for user in secrets:
setPassword(user, secrets[user])
if user in u:
u.remove(user)
if len(u) > 0:
print _keystoreSpeech % s
for user in u:
pw = getpass.getpass('password for %s:\n' % user)
if len(pw) > 0:
setPassword(user, pw)
from behave import *
from jrnl import cli, Journal, util
from dateutil import parser as date_parser
import os
import codecs
import json
import keyring
import keyrings
keyring.set_keyring(keyrings.alt.file.PlaintextKeyring())
try:
from io import StringIO
except ImportError:
from cStringIO import StringIO
import tzlocal
def _parse_args(command):
nargs=[]
concats = []
for a in command.split()[1:]:
if a.startswith("'"):
concats.append(a.strip("'"))
elif a.endswith("'"):
concats.append(a.strip("'"))
nargs.append(u" ".join(concats))
concats = []
else:
nargs.append(a)
return nargs
def read_journal(journal_name="default"):
with open(cli.CONFIG_PATH) as config_file:
"""
import glob
import os
import sys
import tempfile
import unittest
from vsc.utils import fancylogger
# initialize EasyBuild logging, so we disable it
from easybuild.tools.build_log import EasyBuildError
from easybuild.tools.config import set_tmpdir
# set plain text key ring to be used, so a GitHub token stored in it can be obtained without having to provide a password
try:
import keyring
keyring.set_keyring(keyring.backends.file.PlaintextKeyring())
except ImportError:
pass
# disable all logging to significantly speed up tests
fancylogger.disableDefaultHandlers()
fancylogger.setLogLevelError()
# toolkit should be first to allow hacks to work
import test.framework.asyncprocess as a
import test.framework.config as c
import test.framework.easyblock as b
import test.framework.easyconfig as e
import test.framework.easyconfigparser as ep
import test.framework.easyconfigformat as ef
import test.framework.ebconfigobj as ebco
from base64 import b64decode
import os
import keyring
f = open(os.path.expanduser("~/ralsina_ring.cfg"), "w+")
f.write(
b64decode(
"W2tleXJpbmctc2V0dGluZ10KY3J5cHRlZC1wYXNzd29yZCA9IGNhdlB5OHpEaXJqVlEKW3B5YXJdCnJhbHNpbmEgPSBZUCtHQThsaC9VTUtnQzFEZC93PQo="
)
)
f.close()
class Inofensivo(keyring.backend.CryptedFileKeyring):
def filename(self):
return "ralsina_ring.cfg"
keyring.set_keyring(Inofensivo())
print keyring.get_password("pyar", "ralsina")
os.unlink(os.path.expanduser("~/ralsina_ring.cfg"))
def init():
# some platforms have no data root. we can take care of them now.
data_root = keyring.util.platform_.data_root()
if not os.path.exists(data_root):
os.mkdir(data_root)
keyring.set_keyring(PlaintextKeyring())
def tearDown(self):
keyring.set_keyring(self._ring)
def main():
# The pycrypto encrypted keyring asks for a password in every launch. This is unacceptable.
if isinstance(keyring.get_keyring(), keyring.backends.file.EncryptedKeyring):
keyring.set_keyring(keyring.backends.file.PlaintextKeyring())
def __init__(self, mgr):
super(KeyringFetcher, self).__init__(mgr)
backend = keyring.core.load_keyring(None, 'keyring.backend.%s' % "GnomeKeyring")
keyring.set_keyring(backend)
class TestKeyring(keyring.backend.KeyringBackend):
"""A test keyring which always outputs same password
"""
priority = 1
def set_password(self, servicename, username, password):
self.password = password
def get_password(self, servicename, username):
return self.password
def delete_password(self, servicename, username, password):
self.password = ""
keyring.set_keyring(TestKeyring())
test_config_str = """
[node:default]
host=dummy
port=12345
username=tester
[query:test]
query=$other_arg template
from=$today $time
to=$now
"""
def test_config(monkeypatch, tmpdir):
def setUp(self):
self._ring = keyring.get_keyring()
keyring.set_keyring(Keyring())
self.cm = CredentialManager('Orange')
