def initialize_soledad(tempdir, uuid):
if os.path.isdir(tempdir):
shutil.rmtree(tempdir)
passphrase = u"verysecretpassphrase"
secret_path = os.path.join(tempdir, "secret.gpg")
local_db_path = os.path.join(tempdir, "soledad.u1db")
server_url = "http://provider"
cert_file = ""
class MockSharedDB(object):
get_doc = Mock(return_value=None)
put_doc = Mock()
lock = Mock(return_value=('atoken', 300))
unlock = Mock(return_value=True)
close = Mock()
def __call__(self):
return self
Soledad._shared_db = MockSharedDB()
_soledad = Soledad(
uuid,
passphrase,
secret_path,
local_db_path,
server_url,
cert_file,
defer_encryption=False,
syncable=False)
yield SoledadMailAdaptor().initialize_store(_soledad)
defer.returnValue(_soledad)
def _soledad_instance(self, uuid, passphrase, secrets_path, local_db_path,
server_url, cert_file):
"""
Return a Soledad instance for tests.
"""
# mock key fetching and storing so Soledad doesn't fail when trying to
# reach the server.
Soledad._fetch_keys_from_shared_db = Mock(return_value=None)
Soledad._assert_keys_in_shared_db = Mock(return_value=None)
# instantiate soledad
def _put_doc_side_effect(doc):
self._doc_put = doc
class MockSharedDB(object):
get_doc = Mock(return_value=None)
put_doc = Mock(side_effect=_put_doc_side_effect)
lock = Mock(return_value=('atoken', 300))
unlock = Mock(return_value=True)
def __call__(self):
return self
Soledad._shared_db = MockSharedDB()
return Soledad(
uuid,
passphrase,
secrets_path=secrets_path,
local_db_path=local_db_path,
server_url=server_url,
cert_file=cert_file,
)
def setUp(self):
self.gpg_binary_path = get_gpg_bin_path()
# TODO: we pass a fake shared database to soledad because we don't want
# it o try to reach network to lookup a stored secret in the shared
# database. This logic still has to be improved in soledad itself to
# account for tests, and when that is done we can remove this from
# here.
class FakeSharedDb(object):
def get_doc(self, doc_id):
return None
def put_doc(self, doc):
return None
self._soledad = Soledad(
u"*****@*****.**",
u"123456",
secrets_path=self.tempdir + "/secret.gpg",
local_db_path=self.tempdir + "/soledad.u1db",
server_url='',
cert_file=None,
auth_token=None,
shared_db=FakeSharedDb(),
)
def _soledad_instance(self,
user=ADDRESS,
passphrase=u'123',
prefix='',
secrets_path='secrets.json',
local_db_path='soledad.u1db',
server_url='https://127.0.0.1/',
cert_file=None,
shared_db_class=None,
auth_token='auth-token'):
def _put_doc_side_effect(doc):
self._doc_put = doc
if shared_db_class is not None:
MockSharedDB = shared_db_class
else:
MockSharedDB = self.get_default_shared_mock(_put_doc_side_effect)
soledad = Soledad(
user,
passphrase,
secrets_path=os.path.join(self.tempdir, prefix, secrets_path),
local_db_path=os.path.join(self.tempdir, prefix, local_db_path),
server_url=server_url, # Soledad will fail if not given an url.
cert_file=cert_file,
defer_encryption=self.defer_sync_encryption,
shared_db=MockSharedDB(),
auth_token=auth_token)
self.addCleanup(soledad.close)
return soledad
def _soledad_instance(self,
user=ADDRESS,
passphrase=u'123',
prefix='',
secrets_path=Soledad.STORAGE_SECRETS_FILE_NAME,
local_db_path='soledad.u1db',
server_url='',
cert_file=None,
secret_id=None,
shared_db_class=None):
def _put_doc_side_effect(doc):
self._doc_put = doc
if shared_db_class is not None:
MockSharedDB = shared_db_class
else:
MockSharedDB = self.get_default_shared_mock(_put_doc_side_effect)
Soledad._shared_db = MockSharedDB()
return Soledad(
user,
passphrase,
secrets_path=os.path.join(self.tempdir, prefix, secrets_path),
local_db_path=os.path.join(self.tempdir, prefix, local_db_path),
server_url=server_url, # Soledad will fail if not given an url.
cert_file=cert_file,
secret_id=secret_id,
defer_encryption=self.defer_sync_encryption)
def setUp(self):
self.gpg_binary_path = get_gpg_bin_path()
self._soledad = Soledad(u"*****@*****.**",
u"123456",
secrets_path=self.tempdir + "/secret.gpg",
local_db_path=self.tempdir + "/soledad.u1db",
server_url='',
cert_file=None,
auth_token=None,
shared_db=defaultMockSharedDB())
self.km = self._key_manager()
class Response(object):
code = 200
phrase = ''
def deliverBody(self, x):
return ''
self.km._nicknym._async_client_pinned.request = Mock(
return_value=defer.succeed(Response()))
d1 = self.km.put_raw_key(PRIVATE_KEY, ADDRESS)
d2 = self.km.put_raw_key(PRIVATE_KEY_2, ADDRESS_2)
return gatherResults([d1, d2])
def initialize_soledad(tempdir):
if os.path.isdir(tempdir):
shutil.rmtree(tempdir)
uuid = "foobar-uuid"
passphrase = u"verysecretpassphrase"
secret_path = os.path.join(tempdir, "secret.gpg")
local_db_path = os.path.join(tempdir, "soledad.u1db")
server_url = "http://provider"
cert_file = ""
class MockSharedDB(object):
get_doc = Mock(return_value=None)
put_doc = Mock()
lock = Mock(return_value=('atoken', 300))
unlock = Mock(return_value=True)
close = Mock()
def __call__(self):
return self
Soledad._shared_db = MockSharedDB()
_soledad = Soledad(uuid, passphrase, secret_path, local_db_path,
server_url, cert_file)
return _soledad
def create(force_fresh_db=False,
uuid=default_uuid,
passphrase=DEFAULT_PASSPHRASE,
token=DEFAULT_TOKEN):
secrets_file = '%s.secret' % uuid
secrets_path = os.path.join(tmpdir.strpath, secrets_file)
# in some tests we might want to use the same user and remote database
# but with a clean/empty local database (i.e. download benchmarks), so
# here we provide a way to do that.
idx = 1
if force_fresh_db:
# find the next index for this user
idx = len(glob.glob('%s/*-*.db' % tmpdir.strpath)) + 1
db_file = '%s-%d.db' % (uuid, idx)
local_db_path = os.path.join(tmpdir.strpath, db_file)
soledad_client = Soledad(uuid,
unicode(passphrase),
secrets_path=secrets_path,
local_db_path=local_db_path,
server_url=server_url,
cert_file=cert_file,
auth_token=token,
with_blobs=True)
request.addfinalizer(soledad_client.close)
return soledad_client
def _soledad_instance(self, user='******', passphrase=u'123',
prefix='',
secrets_path='secrets.json',
local_db_path='soledad.u1db', server_url='',
cert_file=None, auth_token=None):
"""
Instantiate Soledad.
"""
# this callback ensures we save a document which is sent to the shared
# db.
def _put_doc_side_effect(doc):
self._doc_put = doc
soledad = Soledad(
user,
passphrase,
secrets_path=os.path.join(self.tempdir, prefix, secrets_path),
local_db_path=os.path.join(
self.tempdir, prefix, local_db_path),
server_url=server_url,
cert_file=cert_file,
auth_token=auth_token,
shared_db=self.get_default_shared_mock(_put_doc_side_effect))
self.addCleanup(soledad.close)
return soledad
def init_soledad(_):
token = srpauth.get_token()
print "token", token
global soledad
soledad = Soledad(uuid,
_pass,
secrets_path,
local_db_path,
server_url,
cert_file,
auth_token=token,
defer_encryption=False)
def getall(_):
d = soledad.get_all_docs()
return d
d1 = soledad.create_doc({"test": 42})
d1.addCallback(getall)
d1.addCallbacks(printStuff, printErr)
d2 = soledad.sync()
d2.addCallbacks(printStuff, printErr)
d2.addBoth(lambda r: reactor.stop())
def _initialize_soledad(email, gnupg_home, tempdir):
"""
Initializes soledad by hand
:param email: ID for the user
:param gnupg_home: path to home used by gnupg
:param tempdir: path to temporal dir
:rtype: Soledad instance
"""
uuid = "foobar-uuid"
passphrase = u"verysecretpassphrase"
secret_path = os.path.join(tempdir, "secret.gpg")
local_db_path = os.path.join(tempdir, "soledad.u1db")
server_url = "https://provider"
cert_file = ""
soledad = Soledad(
uuid,
passphrase,
secret_path,
local_db_path,
server_url,
cert_file,
syncable=False)
return soledad
def _get_soledad_client(self):
self._tempdir = tempfile.mkdtemp()
return Soledad(
uuid=self._uuid,
passphrase=u'123',
secrets_path=os.path.join(self._tempdir, 'secrets.json'),
local_db_path=os.path.join(self._tempdir, 'soledad.db'),
server_url=self._server_url,
cert_file=None,
auth_token=self._auth_token,
secret_id=None)
def setUp(self):
self.gpg_binary_path = get_gpg_bin_path()
self._soledad = Soledad(u"*****@*****.**",
u"123456",
secrets_path=self.tempdir + "/secret.gpg",
local_db_path=self.tempdir + "/soledad.u1db",
server_url='',
cert_file=None,
auth_token=None,
syncable=False)
def _try_soledad_init(self, uuid, secrets_path, local_db_path, server_url,
cert_file, auth_token):
"""
Try to initialize soledad.
:param uuid: user identifier
:type uuid: str
:param secrets_path: path to secrets file
:type secrets_path: str
:param local_db_path: path to local db file
:type local_db_path: str
:param server_url: soledad server uri
:type server_url: str
:param cert_file: path to the certificate of the ca used
to validate the SSL certificate used by the remote
soledad server.
:type cert_file: str
:param auth token: auth token
:type auth_token: str
"""
# TODO: If selected server fails, retry with another host
# (issue #3309)
encoding = sys.getfilesystemencoding()
# XXX We should get a flag in soledad itself
if flags.OFFLINE is True:
Soledad._shared_db = MockSharedDB()
try:
self._soledad = Soledad(
uuid,
self._password,
secrets_path=secrets_path.encode(encoding),
local_db_path=local_db_path.encode(encoding),
server_url=server_url,
cert_file=cert_file.encode(encoding),
auth_token=auth_token,
defer_encryption=True)
# XXX All these errors should be handled by soledad itself,
# and return a subclass of SoledadInitializationFailed
# recoverable, will guarantee retries
except (socket.timeout, socket.error, BootstrapSequenceError):
logger.warning("Error while initializing Soledad")
raise
# unrecoverable
except (u1db_errors.Unauthorized, u1db_errors.HTTPError):
logger.error("Error while initializing Soledad (u1db error).")
raise
except Exception as exc:
logger.exception("Unhandled error while initializating "
"Soledad: %r" % (exc, ))
raise
def create():
secrets_path = os.path.join(tmpdir.strpath, '%s.secret' % uuid4().hex)
local_db_path = os.path.join(tmpdir.strpath, '%s.db' % uuid4().hex)
soledad_client = Soledad(default_uuid,
unicode(passphrase),
secrets_path=secrets_path,
local_db_path=local_db_path,
server_url=server_url,
cert_file=None,
auth_token=token,
defer_encryption=True)
request.addfinalizer(soledad_client.close)
return soledad_client
def _init_soledad(self, encryption_passphrase):
try:
server_url = self._discover_soledad_server()
self._create_database_dir()
secrets = self._secrets_path()
local_db = self._local_db_path()
return Soledad(self.leap_srp_session.uuid,
unicode(encryption_passphrase), secrets, local_db,
server_url, which_bundle(self.provider),
self.leap_srp_session.token)
except (WrongMac, UnknownMacMethod, MacMethods), e:
raise SoledadWrongPassphraseException(e)
def create(cls, user_token, user_uuid, encryption_passphrase, secrets,
local_db, server_url, api_cert):
try:
return Soledad(user_uuid,
passphrase=unicode(encryption_passphrase),
secrets_path=secrets,
local_db_path=local_db,
server_url=server_url,
cert_file=api_cert,
shared_db=None,
auth_token=user_token,
defer_encryption=False)
except (WrongMacError, UnknownMacMethodError), e:
raise SoledadWrongPassphraseException(e)
def _get_soledad_instance(uuid, passphrase, basedir, server_url, cert_file,
token):
# setup soledad info
logger.info('UUID is %s' % uuid)
logger.info('Server URL is %s' % server_url)
secrets_path = os.path.join(basedir, '%s.secret' % uuid)
local_db_path = os.path.join(basedir, '%s.db' % uuid)
# instantiate soledad
return Soledad(uuid,
unicode(passphrase),
secrets_path=secrets_path,
local_db_path=local_db_path,
server_url=server_url,
cert_file=cert_file,
auth_token=token)
def initialize_soledad(uuid, email, passwd,
secrets, localdb,
gnupg_home, tempdir):
"""
Initializes soledad by hand
:param email: ID for the user
:param gnupg_home: path to home used by gnupg
:param tempdir: path to temporal dir
:rtype: Soledad instance
"""
# XXX TODO unify with an authoritative source of mocks
# for soledad (or partial initializations).
# This is copied from the imap tests.
server_url = "http://provider"
cert_file = ""
class Mock(object):
def __init__(self, return_value=None):
self._return = return_value
def __call__(self, *args, **kwargs):
return self._return
class MockSharedDB(object):
get_doc = Mock()
put_doc = Mock()
lock = Mock(return_value=('atoken', 300))
unlock = Mock(return_value=True)
def __call__(self):
return self
Soledad._shared_db = MockSharedDB()
soledad = Soledad(
uuid,
passwd,
secrets,
localdb,
server_url,
cert_file,
defer_encryption=True)
return soledad
def _init_soledad(self, encryption_passphrase):
try:
server_url = self._discover_soledad_server()
self._create_database_dir()
secrets = self._secrets_path()
local_db = self._local_db_path()
return Soledad(self.user_uuid,
unicode(encryption_passphrase),
secrets,
local_db,
server_url,
which_api_CA_bundle(self.provider),
self.user_token,
defer_encryption=False)
except (WrongMac, UnknownMacMethod), e:
raise SoledadWrongPassphraseException(e)
def _init_soledad(self, encryption_passphrase):
try:
server_url = self._discover_soledad_server()
self._create_database_dir()
secrets = self._secrets_path()
local_db = self._local_db_path()
return Soledad(self.user_uuid,
passphrase=unicode(encryption_passphrase),
secrets_path=secrets,
local_db_path=local_db, server_url=server_url,
cert_file=LeapCertificate(self.provider).provider_api_cert,
shared_db=None,
auth_token=self.user_token,
defer_encryption=False)
except (WrongMacError, UnknownMacMethodError), e:
raise SoledadWrongPassphraseException(e)
def _soledad_instance(self,
user='******',
passphrase=u'123',
prefix='',
secrets_path=Soledad.STORAGE_SECRETS_FILE_NAME,
local_db_path='soledad.u1db',
server_url='',
cert_file=None,
auth_token=None,
secret_id=None):
"""
Instantiate Soledad.
"""
# this callback ensures we save a document which is sent to the shared
# db.
def _put_doc_side_effect(doc):
self._doc_put = doc
# we need a mocked shared db or else Soledad will try to access the
# network to find if there are uploaded secrets.
class MockSharedDB(object):
get_doc = mock.Mock(return_value=None)
put_doc = mock.Mock(side_effect=_put_doc_side_effect)
lock = mock.Mock(return_value=('atoken', 300))
unlock = mock.Mock()
def __call__(self):
return self
Soledad._shared_db = MockSharedDB()
return Soledad(user,
passphrase,
secrets_path=os.path.join(self.tempdir, prefix,
secrets_path),
local_db_path=os.path.join(self.tempdir, prefix,
local_db_path),
server_url=server_url,
cert_file=cert_file,
auth_token=auth_token,
secret_id=secret_id)
def setUp(self):
self.setUpEnv()
# setup our own stuff
address = '*****@*****.**' # user's address in the form user@provider
uuid = '*****@*****.**'
passphrase = u'123'
secrets_path = os.path.join(self.tempdir, 'secret.gpg')
local_db_path = os.path.join(self.tempdir, 'soledad.u1db')
server_url = 'http://provider/'
cert_file = ''
self._soledad = Soledad(uuid,
passphrase,
secrets_path=secrets_path,
local_db_path=local_db_path,
server_url=server_url,
cert_file=cert_file,
syncable=False)
return self._setup_keymanager(address)
def _soledad_instance(self,
user=None,
passphrase=u'123',
prefix='',
secrets_path='secrets.json',
local_db_path='soledad.u1db',
server_url='',
cert_file=None,
auth_token=None):
"""
Instantiate Soledad.
"""
# this callback ensures we save a document which is sent to the shared
# db.
def _put_doc_side_effect(doc):
self._doc_put = doc
if not server_url:
# attempt to find the soledad server url
server_address = None
server = getattr(self, 'server', None)
if server:
server_address = getattr(self.server, 'server_address', None)
else:
host = self.port.getHost()
server_address = (host.host, host.port)
if server_address:
server_url = 'http://%s:%d' % (server_address)
return Soledad(
user,
passphrase,
secrets_path=os.path.join(self.tempdir, prefix, secrets_path),
local_db_path=os.path.join(self.tempdir, prefix, local_db_path),
server_url=server_url,
cert_file=cert_file,
auth_token=auth_token,
shared_db=self.get_default_shared_mock(_put_doc_side_effect))
def create(force_fresh_db=False):
secrets_file = '%s.secret' % default_uuid
secrets_path = os.path.join(tmpdir.strpath, secrets_file)
# in some tests we might want to use the same user and remote database
# but with a clean/empty local database (i.e. download benchmarks), so
# here we provide a way to do that.
db_file = '%s.db' % default_uuid
if force_fresh_db:
prefix = uuid4().hex
db_file = prefix + '-' + db_file
local_db_path = os.path.join(tmpdir.strpath, db_file)
soledad_client = Soledad(default_uuid,
unicode(passphrase),
secrets_path=secrets_path,
local_db_path=local_db_path,
server_url=server_url,
cert_file=None,
auth_token=token)
request.addfinalizer(soledad_client.close)
return soledad_client
def initialize_soledad(email, gnupg_home, tempdir):
"""
Initializes soledad by hand
:param email: ID for the user
:param gnupg_home: path to home used by gnupg
:param tempdir: path to temporal dir
:rtype: Soledad instance
"""
uuid = "foobar-uuid"
passphrase = u"verysecretpassphrase"
secret_path = os.path.join(tempdir, "secret.gpg")
local_db_path = os.path.join(tempdir, "soledad.u1db")
server_url = "http://provider"
cert_file = ""
class MockSharedDB(object):
get_doc = Mock(return_value=None)
put_doc = Mock()
lock = Mock(return_value=('atoken', 300))
unlock = Mock(return_value=True)
def __call__(self):
return self
Soledad._shared_db = MockSharedDB()
_soledad = Soledad(
uuid,
passphrase,
secret_path,
local_db_path,
server_url,
cert_file)
return _soledad
def _initialize_soledad(email, gnupg_home, tempdir):
"""
Initializes soledad by hand
:param email: ID for the user
:param gnupg_home: path to home used by gnupg
:param tempdir: path to temporal dir
:rtype: Soledad instance
"""
uuid = "foobar-uuid"
passphrase = u"verysecretpassphrase"
secret_path = os.path.join(tempdir, "secret.gpg")
local_db_path = os.path.join(tempdir, "soledad.u1db")
server_url = "https://provider"
cert_file = ""
# TODO: we pass a fake shared database to soledad because we don't want
# it o try to reach network to lookup a stored secret in the shared
# database. This logic still has to be improved in soledad itself to
# account for tests, and when that is done we can remove this from
# here.
class FakeSharedDb(object):
def get_doc(self, doc_id):
return None
def put_doc(self, doc):
return None
soledad = Soledad(uuid,
passphrase,
secret_path,
local_db_path,
server_url,
cert_file,
shared_db=FakeSharedDb())
return soledad
