def create_session():
lplib_cachedir = os.path.expanduser("~/.cache/launchpadlib/")
hydrazine_cachedir = os.path.expanduser("~/.cache/hydrazine/")
rrd_dir = os.path.expanduser("~/.cache/hydrazine/rrd")
for d in [lplib_cachedir, hydrazine_cachedir, rrd_dir]:
if not os.path.isdir(d):
os.makedirs(d, mode=0700)
hydrazine_credentials_filename = os.path.join(hydrazine_cachedir,
'credentials')
if os.path.exists(hydrazine_credentials_filename):
credentials = Credentials()
credentials.load(file(
os.path.expanduser("~/.cache/hydrazine/credentials"),
"r"))
trace('loaded existing credentials')
return Launchpad(credentials, service_root,
lplib_cachedir)
# TODO: handle the case of having credentials that have expired etc
else:
launchpad = Launchpad.get_token_and_login(
'Hydrazine',
service_root,
lplib_cachedir)
trace('saving credentials...')
launchpad.credentials.save(file(
hydrazine_credentials_filename,
"w"))
return launchpad
def create_session():
lplib_cachedir = os.path.expanduser("~/.cache/launchpadlib/")
hydrazine_cachedir = os.path.expanduser("~/.cache/hydrazine/")
rrd_dir = os.path.expanduser("~/.cache/hydrazine/rrd")
for d in [lplib_cachedir, hydrazine_cachedir, rrd_dir]:
if not os.path.isdir(d):
os.makedirs(d, mode=0700)
hydrazine_credentials_filename = os.path.join(hydrazine_cachedir,
'credentials')
if os.path.exists(hydrazine_credentials_filename):
credentials = Credentials()
credentials.load(file(
os.path.expanduser("~/.cache/hydrazine/credentials"),
"r"))
trace('loaded existing credentials')
return Launchpad(credentials, service_root,
lplib_cachedir)
# TODO: handle the case of having credentials that have expired etc
else:
launchpad = Launchpad.get_token_and_login(
'Hydrazine',
service_root,
lplib_cachedir)
trace('saving credentials...')
launchpad.credentials.save(file(
hydrazine_credentials_filename,
"w"))
return launchpad
def test_existing_credentials_arguments_passed_on(self):
# When re-using existing credentials, the arguments login_with
# is called with are passed on the the __init__() method.
os.makedirs(
os.path.join(self.temp_dir, 'api.example.com', 'credentials'))
credentials_file_path = os.path.join(
self.temp_dir, 'api.example.com', 'credentials', 'app name')
credentials = Credentials(
'app name', consumer_secret='consumer_secret:42',
access_token=AccessToken('access_key:84', 'access_secret:168'))
credentials.save_to_path(credentials_file_path)
timeout = object()
proxy_info = object()
version = "foo"
launchpad = NoNetworkLaunchpad.login_with(
'app name', launchpadlib_dir=self.temp_dir,
service_root=SERVICE_ROOT, timeout=timeout, proxy_info=proxy_info,
version=version)
expected_arguments = dict(
service_root=SERVICE_ROOT,
timeout=timeout,
proxy_info=proxy_info,
version=version,
cache=os.path.join(self.temp_dir, 'api.example.com', 'cache'))
for key, expected in expected_arguments.items():
actual = launchpad.passed_in_args[key]
self.assertEqual(actual, expected)
def test_existing_credentials_arguments_passed_on(self):
# When re-using existing credentials, the arguments login_with
# is called with are passed on the the __init__() method.
os.makedirs(
os.path.join(self.temp_dir, 'api.example.com', 'credentials'))
credentials_file_path = os.path.join(
self.temp_dir, 'api.example.com', 'credentials', 'app name')
credentials = Credentials(
'app name', consumer_secret='consumer_secret:42',
access_token=AccessToken('access_key:84', 'access_secret:168'))
credentials.save_to_path(credentials_file_path)
timeout = object()
proxy_info = object()
version = "foo"
launchpad = NoNetworkLaunchpad.login_with(
'app name', launchpadlib_dir=self.temp_dir,
service_root=SERVICE_ROOT, timeout=timeout, proxy_info=proxy_info,
version=version)
expected_arguments = dict(
service_root=SERVICE_ROOT,
timeout=timeout,
proxy_info=proxy_info,
version=version,
cache=os.path.join(self.temp_dir, 'api.example.com', 'cache'))
for key, expected in expected_arguments.items():
actual = launchpad.passed_in_args[key]
self.assertEqual(actual, expected)
def _authorize_token_and_login(
cls, consumer_name, service_root, cache, timeout, proxy_info,
authorization_engine, allow_access_levels, credential_store,
credential_save_failed, version):
"""Authorize a request token. Log in with the resulting access token.
This is the private, non-deprecated implementation of the
deprecated method get_token_and_login(). Once
get_token_and_login() is removed, this code can be streamlined
and moved into its other call site, login_with().
"""
if isinstance(consumer_name, Consumer):
consumer = consumer_name
else:
# Create a system-wide consumer. lazr.restfulclient won't
# do this automatically, but launchpadlib's default is to
# do a desktop-wide integration.
consumer = SystemWideConsumer(consumer_name)
# Create the credentials with no Consumer, then set its .consumer
# property directly.
credentials = Credentials(None)
credentials.consumer = consumer
if authorization_engine is None:
authorization_engine = cls.authorization_engine_factory(
service_root, consumer_name, None, allow_access_levels)
if credential_store is None:
credential_store = cls.credential_store_factory(
credential_save_failed)
else:
# A credential store was passed in, so we won't be using
# any provided value for credential_save_failed. But at
# least make sure we weren't given a conflicting value,
# since that makes the calling code look confusing.
cls._assert_login_argument_consistency(
"credential_save_failed", credential_save_failed,
credential_store.credential_save_failed,
"credential_store")
# Try to get the credentials out of the credential store.
cached_credentials = credential_store.load(
authorization_engine.unique_consumer_id)
if cached_credentials is None:
# They're not there. Acquire new credentials using the
# authorization engine.
credentials = authorization_engine(credentials, credential_store)
else:
# We acquired credentials. But, the application name
# wasn't stored along with the credentials, because in a
# desktop integration scenario, a single set of
# credentials may be shared by many applications. We need
# to set the application name for this specific instance
# of the credentials.
credentials = cached_credentials
credentials.consumer.application_name = (
authorization_engine.application_name)
return cls(credentials, authorization_engine, credential_store,
service_root, cache, timeout, proxy_info, version)
def _authorize_token_and_login(
cls, consumer_name, service_root, cache, timeout, proxy_info,
authorization_engine, allow_access_levels, credential_store,
credential_save_failed, version):
"""Authorize a request token. Log in with the resulting access token.
This is the private, non-deprecated implementation of the
deprecated method get_token_and_login(). Once
get_token_and_login() is removed, this code can be streamlined
and moved into its other call site, login_with().
"""
if isinstance(consumer_name, Consumer):
consumer = consumer_name
else:
# Create a system-wide consumer. lazr.restfulclient won't
# do this automatically, but launchpadlib's default is to
# do a desktop-wide integration.
consumer = SystemWideConsumer(consumer_name)
# Create the credentials with no Consumer, then set its .consumer
# property directly.
credentials = Credentials(None)
credentials.consumer = consumer
if authorization_engine is None:
authorization_engine = cls.authorization_engine_factory(
service_root, consumer_name, None, allow_access_levels)
if credential_store is None:
credential_store = cls.credential_store_factory(
credential_save_failed)
else:
# A credential store was passed in, so we won't be using
# any provided value for credential_save_failed. But at
# least make sure we weren't given a conflicting value,
# since that makes the calling code look confusing.
cls._assert_login_argument_consistency(
"credential_save_failed", credential_save_failed,
credential_store.credential_save_failed,
"credential_store")
# Try to get the credentials out of the credential store.
cached_credentials = credential_store.load(
authorization_engine.unique_consumer_id)
if cached_credentials is None:
# They're not there. Acquire new credentials using the
# authorization engine.
credentials = authorization_engine(credentials, credential_store)
else:
# We acquired credentials. But, the application name
# wasn't stored along with the credentials, because in a
# desktop integration scenario, a single set of
# credentials may be shared by many applications. We need
# to set the application name for this specific instance
# of the credentials.
credentials = cached_credentials
credentials.consumer.application_name = (
authorization_engine.application_name)
return cls(credentials, authorization_engine, credential_store,
service_root, cache, timeout, proxy_info, version)
class ScriptableRequestTokenAuthorization(RequestTokenAuthorizationEngine):
"""A request token process that doesn't need any user input.
The RequestTokenAuthorizationEngine is supposed to be hooked up to a
user interface, but that makes it difficult to test. This subclass
is designed to be easy to test.
"""
def __init__(self, consumer_name, username, password, choose_access_level,
allow_access_levels=[], max_failed_attempts=2,
web_root="http://launchpad.dev:8085/"):
# Get a request token.
self.credentials = Credentials(consumer_name)
self.credentials.get_request_token(web_root=web_root)
# Initialize the superclass with the new request token.
super(ScriptableRequestTokenAuthorization, self).__init__(
web_root, consumer_name, self.credentials._request_token.key,
allow_access_levels, max_failed_attempts)
self.username = username
self.password = password
self.choose_access_level = choose_access_level
def __call__(self, exchange_for_access_token=True):
super(ScriptableRequestTokenAuthorization, self).__call__()
# Now verify that it worked by exchanging the authorized
# request token for an access token.
if (exchange_for_access_token and
self.choose_access_level != self.UNAUTHORIZED_ACCESS_LEVEL):
self.credentials.exchange_request_token_for_access_token(
web_root=self.web_root)
return self.credentials.access_token
return None
def open_page_in_user_browser(self, url):
"""Print a status message."""
print ("[If this were a real application, the end-user's web "
"browser would be opened to %s]" % url)
def input_username(self, cached_username, suggested_message):
"""Collect the Launchpad username from the end-user."""
print suggested_message
if cached_username is not None:
print "Cached email address: " + cached_username
return self.username
def input_password(self, suggested_message):
"""Collect the Launchpad password from the end-user."""
print suggested_message
return self.password
def input_access_level(self, available_levels, suggested_message,
only_one_option):
"""Collect the desired level of access from the end-user."""
print suggested_message
print [level['value'] for level in available_levels]
def get_lp(self):
if not os.path.isdir(self.cachedir):
os.makedirs(self.cachedir)
if not os.path.isfile(self.credential_file):
launchpad = Launchpad.get_token_and_login(self.application, STAGING_SERVICE_ROOT, self.cachedir)
launchpad.credentials.save(file(self.credential_file, "w"))
else:
credentials = Credentials()
credentials.load(open(self.credential_file))
launchpad = Launchpad(credentials, STAGING_SERVICE_ROOT, self.cachedir)
return launchpad
def get_launchpad():
"""Get a Launchpad instance.
@raise RuntimeError: Raised if credentials are not available.
"""
credentials_path = os.path.join(get_config_path(), "credentials.txt")
if not os.path.exists(credentials_path):
raise RuntimeError(
"Run the launchpad-login command to create OAuth credentials.")
credentials = Credentials()
credentials.load(open(credentials_path, "r"))
return Launchpad(credentials, SERVICE_ROOT, get_cache_path())
def get_lp(self):
launchpad = False
cachedir = os.path.expanduser('~/.launchpadlib/cache')
if not os.path.exists(cachedir):
os.makedirs(cachedir,0700)
credfile = os.path.expanduser('~/.launchpadlib/credentials')
try:
credentials = Credentials()
credentials.load(open(credfile))
launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT, cachedir)
except:
launchpad = Launchpad.get_token_and_login(sys.argv[0], EDGE_SERVICE_ROOT, cachedir)
return launchpad
def get_lp(self):
if not os.path.isdir(self.cachedir):
os.makedirs(self.cachedir)
if not os.path.isfile(self.credential_file):
launchpad = Launchpad.get_token_and_login(self.application,
STAGING_SERVICE_ROOT,
self.cachedir)
launchpad.credentials.save(file(self.credential_file, "w"))
else:
credentials = Credentials()
credentials.load(open(self.credential_file))
launchpad = Launchpad(credentials, STAGING_SERVICE_ROOT,
self.cachedir)
return launchpad
def launchpadlib_for(consumer_name,
person=None,
permission=OAuthPermission.WRITE_PRIVATE,
context=None,
version="devel",
service_root="http://api.launchpad.dev/"):
"""Create a Launchpad object for the given person.
:param consumer_name: An OAuth consumer name.
:param person: A person (or the name of a person) for whom to create
or find credentials.
:param permission: An OAuthPermission (or its token) designating
the level of permission the credentials should have.
:param context: The OAuth context for the credentials.
:param version: The version of the web service to access.
:param service_root: The root URL of the web service to access.
:return: A launchpadlib Launchpad object.
"""
if person is None:
token = AnonymousAccessToken()
credentials = Credentials(consumer_name, access_token=token)
else:
credentials = launchpadlib_credentials_for(consumer_name, person,
permission, context)
transaction.commit()
cache = tempfile.mkdtemp(prefix='launchpadlib-cache-')
zope.testing.cleanup.addCleanUp(_clean_up_cache, (cache, ))
return Launchpad(credentials,
None,
None,
service_root=service_root,
version=version,
cache=cache)
def launchpadlib_credentials_for(consumer_name,
person,
permission=OAuthPermission.WRITE_PRIVATE,
context=None):
"""Create launchpadlib credentials for the given person.
:param consumer_name: An OAuth consumer name.
:param person: A person (or the name of a person) for whom to create
or find credentials.
:param permission: An OAuthPermission (or its token) designating
the level of permission the credentials should have.
:param context: The OAuth context for the credentials.
:return: A launchpadlib Credentials object.
"""
# Start an interaction so that oauth_access_token_for will
# succeed. oauth_access_token_for may be called in any layer, but
# launchpadlib_credentials_for is only called in the
# PageTestLayer, when a Launchpad instance is running for
# launchpadlib to use.
login(ANONYMOUS)
access_token = oauth_access_token_for(consumer_name, person, permission,
context)
logout()
launchpadlib_token = AccessToken(access_token.key, access_token.secret)
return Credentials(consumer_name=consumer_name,
access_token=launchpadlib_token)
def get_launchpad():
if not HAVE_LPLIB:
return None
try:
return Launchpad.login_anonymously("bzr-builddeb",
service_root=LPNET_SERVICE_ROOT)
except AttributeError: # older version of launchpadlib
creds_path = os.path.join(config_dir(), "builddeb.lp_creds.txt")
if not os.path.exists(creds_path):
return None
creds = Credentials("bzr-builddeb")
f = open(creds_path)
try:
creds.load(f)
finally:
f.close()
return Launchpad(creds, service_root=LPNET_SERVICE_ROOT)
def login(cls,
consumer_name,
token_string,
access_secret,
service_root=uris.STAGING_SERVICE_ROOT,
cache=None,
timeout=None,
proxy_info=None,
authorization_engine=None,
allow_access_levels=None,
max_failed_attempts=None,
credential_store=None,
credential_save_failed=None,
version=DEFAULT_VERSION):
"""Convenience method for setting up access credentials.
When all three pieces of credential information (the consumer
name, the access token and the access secret) are available, this
method can be used to quickly log into the service root.
This method is deprecated as of launchpadlib version
1.9.0. You should use Launchpad.login_anonymously() for
anonymous access, and Launchpad.login_with() for all other
purposes.
:param consumer_name: the application name.
:type consumer_name: string
:param token_string: the access token, as appropriate for the
`AccessToken` constructor
:type token_string: string
:param access_secret: the access token's secret, as appropriate for
the `AccessToken` constructor
:type access_secret: string
:param service_root: The URL to the root of the web service.
:type service_root: string
:param authorization_engine: See `Launchpad.__init__`. If you don't
provide an authorization engine, a default engine will be
constructed using your values for `service_root` and
`credential_save_failed`.
:param allow_access_levels: This argument is ignored, and only
present to preserve backwards compatibility.
:param max_failed_attempts: This argument is ignored, and only
present to preserve backwards compatibility.
:return: The web service root
:rtype: `Launchpad`
"""
cls._warn_of_deprecated_login_method("login")
access_token = AccessToken(token_string, access_secret)
credentials = Credentials(consumer_name=consumer_name,
access_token=access_token)
if authorization_engine is None:
authorization_engine = cls.authorization_engine_factory(
service_root, consumer_name, allow_access_levels)
if credential_store is None:
credential_store = cls.credential_store_factory(
credential_save_failed)
return cls(credentials, authorization_engine, credential_store,
service_root, cache, timeout, proxy_info, version)
def get_token_and_login(cls, consumer_name,
service_root=uris.STAGING_SERVICE_ROOT,
cache=None, timeout=None, proxy_info=None,
authorizer_class=AuthorizeRequestTokenWithBrowser,
allow_access_levels=[], max_failed_attempts=3,
version=DEFAULT_VERSION):
"""Get credentials from Launchpad and log into the service root.
This is a convenience method which will open up the user's preferred
web browser and thus should not be used by most applications.
Applications should, instead, use Credentials.get_request_token() to
obtain the authorization URL and
Credentials.exchange_request_token_for_access_token() to obtain the
actual OAuth access token.
This method will negotiate an OAuth access token with the service
provider, but to complete it we will need the user to log into
Launchpad and authorize us, so we'll open the authorization page in
a web browser and ask the user to come back here and tell us when they
finished the authorization process.
:param consumer_name: The consumer name, as appropriate for the
`Consumer` constructor
:type consumer_name: string
:param service_root: The URL to the root of the web service.
:type service_root: string
:return: The web service root
:rtype: `Launchpad`
"""
credentials = Credentials(consumer_name)
service_root = uris.lookup_service_root(service_root)
web_root_uri = URI(service_root)
web_root_uri.path = ""
web_root_uri.host = web_root_uri.host.replace("api.", "", 1)
web_root = str(web_root_uri.ensureSlash())
authorization_json = credentials.get_request_token(
web_root=web_root, token_format=Credentials.DICT_TOKEN_FORMAT)
authorizer = authorizer_class(
web_root, authorization_json['oauth_token_consumer'],
authorization_json['oauth_token'], allow_access_levels,
max_failed_attempts)
authorizer()
credentials.exchange_request_token_for_access_token(web_root)
return cls(credentials, service_root, cache, timeout, proxy_info,
version)
def connect():
cachedir = os.path.expanduser('~/.launchpadlib/cache')
if not os.path.exists(cachedir):
os.makedirs(cachedir, 0700)
credfile = os.path.expanduser('~/.launchpadlib/credentials')
try:
credentials = Credentials()
credentials.load(open(credfile))
launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT, cachedir)
except:
launchpad = Launchpad.get_token_and_login(sys.argv[0],
EDGE_SERVICE_ROOT, cachedir)
credfd = tempfile.NamedTemporaryFile(dir=os.path.dirname(credfile))
launchpad.credentials.save(credfd)
os.link(credfd.name, credfile)
credfd.close()
return launchpad
def get_lp(self):
launchpad = False
if not os.path.isdir(self.cachedir):
try:
os.makedirs(self.cachedir)
except:
raise
if not os.path.isfile(self.lp_credential_file):
try:
launchpad = Launchpad.get_token_and_login('openerp', EDGE_SERVICE_ROOT, self.cachedir)
launchpad.credentials.save(file(self.lp_credential_file, "w"))
except:
print 'Service Unavailable !'
else:
credentials = Credentials()
credentials.load(open(self.lp_credential_file))
launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT, self.cachedir)
return launchpad
def login(self):
if self.launchpad is not None:
return
cachedir = os.path.expanduser('~/.cache/launchpadlib')
creddir = os.path.expanduser('~/.config/launchpadlib')
credfile = creddir + '/credentials.txt'
root = EDGE_SERVICE_ROOT
if not os.path.exists(cachedir):
os.makedirs(cachedir, 0700)
try:
credentials = Credentials()
credentials.load(open(credfile))
self.launchpad = Launchpad(credentials, root, cachedir)
except:
self.launchpad = Launchpad.get_token_and_login('igotu2gpx-launchpad-tools',
root, cachedir)
if not os.path.exists(creddir):
os.makedirs(creddir, 0700)
self.launchpad.credentials.save(open(credfile, "w", 0600))
self.project = self.launchpad.projects['igotu2gpx']
def test_filename(self):
ignore, filename = tempfile.mkstemp()
launchpad = NoNetworkLaunchpad.login_with(
application_name='not important', credentials_file=filename)
# The credentials are stored unencrypted in the file you
# specify.
credentials = Credentials.load_from_path(filename)
self.assertEquals(credentials.consumer.key,
launchpad.credentials.consumer.key)
os.remove(filename)
def test_filename(self):
ignore, filename = tempfile.mkstemp()
launchpad = NoNetworkLaunchpad.login_with(
application_name='not important', credentials_file=filename)
# The credentials are stored unencrypted in the file you
# specify.
credentials = Credentials.load_from_path(filename)
self.assertEquals(credentials.consumer.key,
launchpad.credentials.consumer.key)
os.remove(filename)
def lp_login():
cachedir = os.path.expanduser('~/.cache/launchpadlib/')
if not os.path.isdir(cachedir):
os.makedirs(cachedir)
creddir = os.path.expanduser("~/.cache/lp_credentials")
if not os.path.isdir(creddir):
os.makedirs(creddir)
os.chmod(creddir, 0700)
try:
credfile = open(os.path.join(creddir, 'close_launchpad_bugs.txt'), 'r')
credentials = Credentials()
credentials.load(credfile)
credfile.close()
launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT, cachedir)
except IOError:
launchpad = Launchpad.get_token_and_login('close_launchpad_bugs', EDGE_SERVICE_ROOT, cachedir)
credfile = open(os.path.join(creddir, 'close_launchpad_bugs.txt'), 'w')
launchpad.credentials.save(credfile)
credfile.close()
return launchpad
def get_lp(self):
launchpad = False
if not os.path.isdir(self.cachedir):
try:
os.makedirs(self.cachedir)
except:
raise
if not os.path.isfile(self.lp_credential_file):
try:
launchpad = Launchpad.get_token_and_login(
'openerp', EDGE_SERVICE_ROOT, self.cachedir)
launchpad.credentials.save(file(self.lp_credential_file, "w"))
except:
print 'Service Unavailable !'
else:
credentials = Credentials()
credentials.load(open(self.lp_credential_file))
launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT,
self.cachedir)
return launchpad
def login_anonymously(
cls, consumer_name, service_root=uris.STAGING_SERVICE_ROOT,
launchpadlib_dir=None, timeout=None, proxy_info=proxy_info_from_environment,
version=DEFAULT_VERSION):
"""Get access to Launchpad without providing any credentials."""
(service_root, launchpadlib_dir, cache_path,
service_root_dir) = cls._get_paths(service_root, launchpadlib_dir)
token = AnonymousAccessToken()
credentials = Credentials(consumer_name, access_token=token)
return cls(credentials, None, None, service_root=service_root,
cache=cache_path, timeout=timeout, proxy_info=proxy_info,
version=version)
def launchpad(self):
'''Return Launchpad instance.'''
if self.__launchpad:
return self.__launchpad
if self.options.get('staging') or os.getenv('APPORT_STAGING'):
launchpad_instance = STAGING_SERVICE_ROOT
else:
launchpad_instance = EDGE_SERVICE_ROOT
auth_dir = os.path.dirname(self.auth)
if auth_dir and not os.path.isdir(auth_dir):
os.makedirs(auth_dir)
try:
if os.path.exists(self.auth):
# use existing credentials
credentials = Credentials()
credentials.load(open(self.auth))
self.__launchpad = Launchpad(credentials, launchpad_instance,
self.__lpcache)
else:
# get credentials and save them
try:
self.__launchpad = Launchpad.get_token_and_login(
'apport-collect', launchpad_instance, self.__lpcache)
except HTTPError, e:
print >> sys.stderr, 'Error connecting to Launchpad: %s\nYou have to allow "Change anything" privileges.' % str(
e)
sys.exit(1)
f = open(self.auth, 'w')
os.chmod(self.auth, 0600)
self.__launchpad.credentials.save(f)
f.close()
except (socket.error, ServerNotFoundError), e:
print >> sys.stderr, 'Error connecting to Launchpad: %s' % str(e)
sys.exit(99) # transient error
def process_launchpad_authorization():
global user_agents
credentials = Credentials()
SimpleLaunchpad.set_credentials_consumer(credentials,
"launchpad-reporting-www")
if 'should_authorize' in session and session['should_authorize']:
if 'request_token_parts' in session:
return get_access_token(credentials)
elif 'access_token_parts' in session:
return use_access_token(credentials)
else:
return get_and_authorize_request_token(credentials)
else:
return (False, None, False)
def test_existing_credentials_are_reused(self):
# If a credential file for the application already exists, that
# one is used.
os.makedirs(
os.path.join(self.temp_dir, 'api.example.com', 'credentials'))
credentials_file_path = os.path.join(
self.temp_dir, 'api.example.com', 'credentials', 'app name')
credentials = Credentials(
'app name', consumer_secret='consumer_secret:42',
access_token=AccessToken('access_key:84', 'access_secret:168'))
credentials.save_to_path(credentials_file_path)
launchpad = NoNetworkLaunchpad.login_with(
'app name', launchpadlib_dir=self.temp_dir,
service_root='http://api.example.com/beta')
self.assertFalse(launchpad.get_token_and_login_called)
self.assertEqual(launchpad.credentials.consumer.key, 'app name')
self.assertEqual(
launchpad.credentials.consumer.secret, 'consumer_secret:42')
self.assertEqual(
launchpad.credentials.access_token.key, 'access_key:84')
self.assertEqual(
launchpad.credentials.access_token.secret, 'access_secret:168')
def launchpad(self):
'''Return Launchpad instance.'''
if self.__launchpad:
return self.__launchpad
if self.options.get('staging') or os.getenv('APPORT_STAGING'):
launchpad_instance = STAGING_SERVICE_ROOT
else:
launchpad_instance = EDGE_SERVICE_ROOT
auth_dir = os.path.dirname(self.auth)
if auth_dir and not os.path.isdir(auth_dir):
os.makedirs(auth_dir)
try:
if os.path.exists(self.auth):
# use existing credentials
credentials = Credentials()
credentials.load(open(self.auth))
self.__launchpad = Launchpad(credentials, launchpad_instance,
self.__lpcache)
else:
# get credentials and save them
try:
self.__launchpad = Launchpad.get_token_and_login('apport-collect',
launchpad_instance, self.__lpcache)
except HTTPError, e:
print >> sys.stderr, 'Error connecting to Launchpad: %s\nYou have to allow "Change anything" privileges.' % str(e)
sys.exit(1)
f = open(self.auth, 'w')
os.chmod(self.auth, 0600)
self.__launchpad.credentials.save(f)
f.close()
except (socket.error, ServerNotFoundError), e:
print >> sys.stderr, 'Error connecting to Launchpad: %s' % str(e)
sys.exit(99) # transient error
def lp_login():
cachedir = os.path.expanduser('~/.cache/launchpadlib/')
if not os.path.isdir(cachedir):
os.makedirs(cachedir)
creddir = os.path.expanduser("~/.cache/lp_credentials")
if not os.path.isdir(creddir):
os.makedirs(creddir)
os.chmod(creddir, 0o700)
credpath = os.path.join(creddir, 'close_launchpad_bugs.txt')
try:
credfile = open(credpath, 'r')
credentials = Credentials()
credentials.load(credfile)
credfile.close()
launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT, cachedir)
except IOError:
launchpad = Launchpad.get_token_and_login('close_launchpad_bugs',
EDGE_SERVICE_ROOT, cachedir)
credfile = open(credpath, 'w')
launchpad.credentials.save(credfile)
credfile.close()
return launchpad
class RequestTokenApp(object):
"""An application that creates request tokens."""
def __init__(self, web_root, consumer_name, context):
"""Initialize."""
self.web_root = lookup_web_root(web_root)
self.credentials = Credentials(consumer_name)
self.context = context
def run(self):
"""Get a request token and return JSON information about it."""
token = self.credentials.get_request_token(
self.context,
self.web_root,
token_format=Credentials.DICT_TOKEN_FORMAT)
return simplejson.dumps(token)
class RequestTokenApp(object):
"""An application that creates request tokens."""
def __init__(self, web_root, consumer_name, context):
"""Initialize."""
self.web_root = lookup_web_root(web_root)
self.credentials = Credentials(consumer_name)
self.context = context
def run(self):
"""Get a request token and return JSON information about it."""
token = self.credentials.get_request_token(
self.context, self.web_root,
token_format=Credentials.DICT_TOKEN_FORMAT)
return simplejson.dumps(token)
def __init__(self, consumer_name, username, password, choose_access_level,
allow_access_levels=[], max_failed_attempts=2,
web_root="http://launchpad.dev:8085/"):
# Get a request token.
self.credentials = Credentials(consumer_name)
self.credentials.get_request_token(web_root=web_root)
# Initialize the superclass with the new request token.
super(ScriptableRequestTokenAuthorization, self).__init__(
web_root, consumer_name, self.credentials._request_token.key,
allow_access_levels, max_failed_attempts)
self.username = username
self.password = password
self.choose_access_level = choose_access_level
def test_new_credentials_are_saved(self):
# After get_token_and_login() have been called, the created
# credentials are saved.
launchpad = NoNetworkLaunchpad.login_with(
'app name', launchpadlib_dir=self.temp_dir,
service_root='http://api.example.com/beta')
credentials_path = os.path.join(
self.temp_dir, 'api.example.com', 'credentials', 'app name')
self.assertTrue(os.path.exists(credentials_path))
# Make sure that the credentials can be loaded, thus were
# written correctly.
loaded_credentials = Credentials.load_from_path(credentials_path)
self.assertEqual(loaded_credentials.consumer.key, 'app name')
self.assertEqual(
loaded_credentials.consumer.secret, 'consumer_secret:42')
self.assertEqual(
loaded_credentials.access_token.key, 'access_key:84')
self.assertEqual(
loaded_credentials.access_token.secret, 'access_secret:168')
print "Uploading", f
finalDesc = FILE_DESCRIPTIONS[fType]
if lang: finalDesc = finalDesc % (lang)
try:
releaseFile = release.add_file(filename = os.path.basename(f), description = finalDesc, file_content = open(f, 'r').read(), content_type = FILE_CONTENTTYPES[fType], file_type = FILE_TYPES[fType], signature_filename = fSign, signature_content = open(fSign, 'r').read())
# Don't know why, but an exception will always be thrown even though the file is uploaded
except lazr.restfulclient.errors.HTTPError:
pass
for arg in sys.argv:
if arg == "--auth":
manualAuthentication()
if not launchpad:
if os.path.exists(credentialsfile):
credentials = Credentials()
credentials.load(open(credentialsfile))
launchpad = Launchpad(credentials, serviceRoot, cachedir)
else:
manualAuthentication()
project = launchpad.projects[projectName]
for release in project.releases:
if release.version == lpRelease:
gpgPass = getpass.getpass("Found the release. I will now create signature files - please enter your GPG private key passphrase: ")
# Upload the source tarball
if options.uploadsource: uploadFile('pack/source/tagainijisho-' + releaseVersion + '.tar.gz', 'source', '', gpgPass)
# Upload the mac binaries
if options.uploadmac:
for lang in LANGUAGES:
uploadFile('pack/MacOS/Tagaini Jisho-' + releaseVersion + '-' + LANGUAGES_SUFFIXES[lang] + '.dmg', 'mac', lang, gpgPass)
def login_with(cls, consumer_name,
service_root=uris.STAGING_SERVICE_ROOT,
launchpadlib_dir=None, timeout=None, proxy_info=None,
authorizer_class=AuthorizeRequestTokenWithBrowser,
allow_access_levels=[], max_failed_attempts=3,
credentials_file=None, version=DEFAULT_VERSION):
"""Log in to Launchpad with possibly cached credentials.
This is a convenience method for either setting up new login
credentials, or re-using existing ones. When a login token is generated
using this method, the resulting credentials will be saved in
`credentials_file`, or if not given, into the `launchpadlib_dir`
directory. If the same `credentials_file`/`launchpadlib_dir` is passed
in a second time, the credentials in for the consumer will be used
automatically.
Each consumer has their own credentials per service root in
`launchpadlib_dir`. `launchpadlib_dir` is also used for caching
fetched objects. The cache is per service root, and shared by
all consumers.
See `Launchpad.get_token_and_login()` for more information about
how new tokens are generated.
:param consumer_name: The consumer name, as appropriate for the
`Consumer` constructor
:type consumer_name: string
:param service_root: The URL to the root of the web service.
:type service_root: string. Can either be the full URL to a service
or one of the short service names.
:param launchpadlib_dir: The directory where the cache and
credentials are stored.
:type launchpadlib_dir: string
:param credentials_file: If given, the credentials are stored in that
file instead in `launchpadlib_dir`.
:type credentials_file: string
:return: The web service root
:rtype: `Launchpad`
"""
(service_root, launchpadlib_dir, cache_path,
service_root_dir) = cls._get_paths(service_root, launchpadlib_dir)
credentials_path = os.path.join(service_root_dir, 'credentials')
if not os.path.exists(credentials_path):
os.makedirs(credentials_path)
if credentials_file is None:
consumer_credentials_path = os.path.join(credentials_path,
consumer_name)
else:
consumer_credentials_path = credentials_file
if os.path.exists(consumer_credentials_path):
credentials = Credentials.load_from_path(
consumer_credentials_path)
launchpad = cls(
credentials, service_root=service_root, cache=cache_path,
timeout=timeout, proxy_info=proxy_info, version=version)
else:
launchpad = cls.get_token_and_login(
consumer_name, service_root=service_root, cache=cache_path,
timeout=timeout, proxy_info=proxy_info,
authorizer_class=authorizer_class,
allow_access_levels=allow_access_levels,
max_failed_attempts=max_failed_attempts, version=version)
launchpad.credentials.save_to_path(consumer_credentials_path)
os.chmod(consumer_credentials_path, stat.S_IREAD | stat.S_IWRITE)
return launchpad
sys.exit(1)
changelog = 'debian/changelog'
if not os.path.exists(changelog):
changelog = "./changelog"
if not os.path.exists(changelog):
print "File " + changelog + " not found"
sys.exit(2)
home = os.environ['HOME']
cachedir = home + '/.launchpadlib/cache/'
launchpad_key = home + "/.launchpadlib/key.txt"
credentials = Credentials()
credentials.load(open(launchpad_key))
#launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT, cachedir)
launchpad = Launchpad.login_with('GetDeb.net Bug Manager', 'production')
me = launchpad.me
project_name = "GetDeb Software Portal"
if sys.argv[1] == 'start' or sys.argv[1].startswith('s'):
current_changelog = get_changelog(1, changelog)
previous_changelog = get_changelog(2, changelog)
bug_ids = current_changelog['bugs_to_be_closed']
check_not_empty(bug_ids)
import json, time
from launchpadlib.credentials import Credentials
from lazr.restfulclient.errors import HTTPError
credentials = Credentials("launchpad-reporting-www")
request_token_info = credentials.get_request_token(web_root="production")
print request_token_info
print '**** *** sleeping (while you validate token in the browser) *** ***'
time.sleep(15)
print '**** *** continuing *** ***'
credentials.exchange_request_token_for_access_token(web_root="production")
print json.dumps(credentials)
try:
bug = LP.bugs[bug_id]
except Exception, e:
self.msg(dst, 'Could not find lp bug %i, %s' % (bug_id, str(e)))
return
owner = str(bug.owner).split('~', 1)[1]
self.msg(
dst,
str('LP bug #%i, %s (%s) by %s' %
(bug_id, bug.title, bug.self_link, owner)))
# this is the module initialization process if we are imported.
if __name__ == 'lpbugs':
creds = Credentials()
creds.load(open('%s/lpcreds.txt' % CONFDIR))
LP = Launchpad(creds, EDGE_SERVICE_ROOT, CACHEDIR)
core.MODULES.append(__name__)
log('%s Loaded Successfully' % __name__)
# This is the setup initialization process
if __name__ == '__main__':
if not os.path.exists(CACHEDIR):
print "Creating conf and cache dir"
try:
os.makedirs(CACHEDIR)
except Exception, e:
print 'Error creating directories, %s' % str(e)
sys.exit(1)
def make_credential(self, consumer_key):
"""Helper method to make a fake credential."""
return Credentials("app name",
consumer_secret='consumer_secret:42',
access_token=AccessToken(consumer_key,
'access_secret:168'))
# Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
import subprocess
import sys
from launchpadlib.credentials import Credentials
web_root = "https://launchpad.net/"
creds = Credentials("process-merge-requests")
url = creds.get_request_token(web_root=web_root)
subprocess.call(['xdg-open', url])
print("Once you have authenticated then press enter")
sys.stdin.readline()
creds.exchange_request_token_for_access_token(web_root=web_root)
f = open("credentials", "wb")
try:
creds.save(f)
finally:
f.close()
# Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
import subprocess
import sys
from launchpadlib.credentials import Credentials
web_root = "https://launchpad.net/"
creds = Credentials("tarmac")
url = creds.get_request_token(web_root=web_root)
subprocess.call(['xdg-open', url])
print("Once you have authenticated then press enter")
sys.stdin.readline()
creds.exchange_request_token_for_access_token(web_root=web_root)
f = open("credentials", "wb")
try:
creds.save(f)
finally:
f.close()
sys.exit(1)
changelog = 'debian/changelog'
if not os.path.exists(changelog):
changelog = "./changelog"
if not os.path.exists(changelog):
print "File "+changelog+" not found"
sys.exit(2)
home = os.environ['HOME']
cachedir = home + '/.launchpadlib/cache/'
launchpad_key = home + "/.launchpadlib/key.txt"
credentials = Credentials()
credentials.load(open(launchpad_key))
#launchpad = Launchpad(credentials, EDGE_SERVICE_ROOT, cachedir)
launchpad = Launchpad.login_with('GetDeb.net Bug Manager', 'production')
me = launchpad.me
project_name = "GetDeb Software Portal"
if sys.argv[1] == 'start' or sys.argv[1].startswith('s'):
current_changelog = get_changelog(1, changelog)
previous_changelog = get_changelog(2, changelog)
bug_ids = current_changelog['bugs_to_be_closed']
check_not_empty(bug_ids)
def __init__(self, web_root, consumer_name, context):
"""Initialize."""
self.web_root = lookup_web_root(web_root)
self.credentials = Credentials(consumer_name)
self.context = context
bug_id,
str(e)
))
return
owner = str(bug.owner).split('~', 1)[1]
self.msg(dst, str('LP bug #%i, %s (%s) by %s' % (
bug_id,
bug.title,
bug.self_link,
owner
)))
# this is the module initialization process if we are imported.
if __name__ == 'lpbugs':
creds = Credentials()
creds.load(open('%s/lpcreds.txt' % CONFDIR))
LP = Launchpad(creds, EDGE_SERVICE_ROOT, CACHEDIR)
core.MODULES.append(__name__)
log('%s Loaded Successfully' % __name__)
# This is the setup initialization process
if __name__ == '__main__':
if not os.path.exists(CACHEDIR):
print "Creating conf and cache dir"
try:
os.makedirs(CACHEDIR)
except Exception, e:
print 'Error creating directories, %s' % str(e)
sys.exit(1)
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
import subprocess
import sys
from launchpadlib.credentials import Credentials
web_root="https://launchpad.net/"
creds = Credentials("tarmac")
url = creds.get_request_token(web_root=web_root)
subprocess.call(['xdg-open', url])
print("Once you have authenticated then press enter")
sys.stdin.readline()
creds.exchange_request_token_for_access_token(web_root=web_root)
f = open("credentials", "wb")
try:
creds.save(f)
finally:
f.close()
def authenticateFromSaved(self): credentials = Credentials() credentials.load(file(self.credentialsFilename, 'r')) self.launchpad = Launchpad(credentials, self.service, self.cacheDir)
def __init__(self, token_string, access_secret):
self.token_string = token_string
self.access_secret = access_secret
self.token = AccessToken(token_string, access_secret)
self.credentials = Credentials(consumer_name="launchpad-library",
access_token=self.token)
def __init__(self, web_root, consumer_name, context):
"""Initialize."""
self.web_root = lookup_web_root(web_root)
self.credentials = Credentials(consumer_name)
self.context = context
import json, time
from launchpadlib.credentials import Credentials
from lazr.restfulclient.errors import HTTPError
credentials = Credentials("launchpad-reporting-www")
request_token_info = credentials.get_request_token(web_root="production")
print request_token_info
print "**** *** sleeping (while you validate token in the browser) *** ***"
time.sleep(15)
print "**** *** continuing *** ***"
credentials.exchange_request_token_for_access_token(web_root="production")
print json.dumps(credentials)