def remove_service(input, service_id):
service = get_service(service_id)
try:
service.Remove()
except:
return "Invalid or missing service %s" % service_id
return None
def remove_service(input, service_id):
service = get_service(service_id)
try:
service.Remove()
except:
return "Invalid or missing service %s" % service_id
return None
def connect_psk(input, service_id, agent):
(from_agent, to_agent, agent_stderr) = (agent.stdout, agent.stdin,
agent.stderr)
sleep(1)
print >> to_agent, "Passphrase=%s\n" % input.passphrase
to_agent.flush()
sleep(1)
service = get_service(service_id)
try:
service.Connect()
except dbus.DBusException, error:
#print "%s: %s" % (error._dbus_error_name, error.message)
if error._dbus_error_name != "net.connman.Error.InProgress":
agent.terminate()
agent.wait()
return "Invalid or missing service %s (%s: %s)" % \
(service_id, error._dbus_error_name, error.message)
def connect_psk(input, service_id, agent):
(from_agent, to_agent, agent_stderr) = (agent.stdout, agent.stdin,
agent.stderr)
sleep(1)
print >> to_agent, "Passphrase=%s\n" % input.passphrase
to_agent.flush()
sleep(1)
service = get_service(service_id)
try:
service.Connect()
except dbus.DBusException, error:
#print "%s: %s" % (error._dbus_error_name, error.message)
if error._dbus_error_name != "net.connman.Error.InProgress":
agent.terminate()
agent.wait()
return "Invalid or missing service %s (%s: %s)" % \
(service_id, error._dbus_error_name, error.message)
Args:
output_dir: str containing the path to the directory you want to save to.
query_id: str containing the Id of the query that generated the report.
report_url: str containing the url to the generated report.
"""
# Create formatter for output file path.
if not os.path.isabs(output_dir):
output_dir = os.path.expanduser(output_dir)
output_fmt = output_dir + '/%s.csv'
with (open(output_fmt % query_id, 'wb')) as handle:
handle.write(urllib.request.urlopen(report_url).read())
if __name__ == '__main__':
args = parser.parse_args()
# Retrieve the query id of the report we're downloading, or set to 0.
QUERY_ID = args.query_id
if not QUERY_ID:
try:
QUERY_ID = int(
input('Enter the query id or press enter to '
'list queries: '))
except ValueError:
QUERY_ID = 0
main(
util.get_service(client_id=args.client_id,
client_secret=args.client_secret),
args.output_directory, QUERY_ID, args.report_window)
# Then write the contents of the response to a CSV file.
handler.write(request.execute()['lineItems'].encode('utf-8'))
print('Download complete.')
if __name__ == '__main__':
request_body = {}
valid_filter_types = [
'ADVERTISER_ID', 'INSERTION_ORDER_ID', 'LINE_ITEM_ID'
]
# If your download requests time out, you may need to filter to reduce the
# number of items returned. Below we parse optional arguments to add these
# filters to the body of the request.
args = parser.parse_args()
path = args.file_path
if not os.path.isabs(path):
FILE_PATH = os.path.expanduser(path)
if args.filter_ids:
request_body['filterIds'] = args.filter_ids.split(',')
# if args.filter_type in valid_filter_types:
# request_body['filterType'] = args.filter_type
# else:
# raise ValueError('Invalid filterType. Acceptable values: %s' %
# valid_filter_types)
main(
util.get_service(client_id=args.client_id,
client_secret=args.client_secret), path, request_body)
def update_service(input, service_id):
properties = get_properties(service_id)
if not properties.keys():
return "No properties for service %s" % service_id
service = get_service(service_id)
try:
if input.autoconnect == "Yes":
autoconnect = True
else:
autoconnect = False
(value_changed, error) = change(service, properties, "AutoConnect",
autoconnect)
if not value_changed:
return service_not_found(service_id, error, "AutoConnect")
except:
pass
try:
(value_changed, error) = change(service, properties,
"Domains.Configuration",
input.domains,
dbus.Array([input.domains],
signature=dbus.Signature('s')))
if not value_changed:
return service_not_found(service_id, error, "Domains")
except:
pass
try:
(value_changed, error) = change(service, properties,
"Nameservers.Configuration",
input.nameservers,
dbus.Array([input.nameservers],
signature=dbus.Signature('s')))
if not value_changed:
return service_not_found(service_id, error, "Nameservers")
except:
pass
try:
(value_changed, error) = change(service, properties,
"Timeservers.Configuration",
input.timeservers,
dbus.Array([input.timeservers],
signature=dbus.Signature('s')))
if not value_changed:
return service_not_found(service_id, error, "Timeservers")
except:
pass
try:
if input.proxymethod == "auto":
if changed_dict(properties, "Proxy.Configuration", "URL",
input.proxyurl):
proxy = { "Method": make_variant("auto") }
proxy["URL"] = make_variant(input.proxyurl)
try:
service.SetProperty("Proxy.Configuration", proxy)
except dbus.DBusException, error:
return service_not_found(service_id, error,
"Proxy URL setting failed")
elif input.proxymethod == "manual":
set_property = False
proxy = { "Method": make_variant("manual") }
if changed_dict(properties, "Proxy.Configuration", "Servers",
input.proxyservers):
proxy["Servers"] = split_string(input.proxyservers)
set_property = True
if changed_dict(properties, "Proxy.Configuration", "Excludes",
input.proxyexcludes):
proxy["Excludes"] = split_string(input.proxyexcludes)
set_property = True
if set_property:
try:
service.SetProperty("Proxy.Configuration",
dbus.Dictionary(proxy, signature='sv'))
except dbus.DBusException, error:
return service_not_found(service_id, error,
"Manual Proxy setting failed")
def main(doubleclick_bid_manager, body):
# Construct the request.
request = doubleclick_bid_manager.lineitems().uploadlineitems(body=body)
response = request.execute()
if 'uploadStatus' in response and 'errors' in response['uploadStatus']:
for error in response['uploadStatus']['errors']:
print error
else:
print 'Upload Successful.'
if __name__ == '__main__':
args = parser.parse_args()
file_path = args.file_path
if not os.path.isabs(file_path):
file_path = os.path.expanduser(file_path)
with open(file_path, 'rb') as handle:
line_items = handle.read()
BODY = {
'dryRun': args.dry_run,
'lineItems': line_items
}
main(util.get_service(
client_id=args.client_id, client_secret=args.client_secret), BODY)
def test_remote_auth_hub(image, swarm, network, make_service):
"""Test that logging in as a new user creates a new docker service."""
test_logger.info("Start of service testing")
make_service(remote_hub_service)
client = docker.from_env()
# jupyterhub service should be running at this point
services_before_spawn = client.services.list()
test_logger.info("Pre test services: {}".format(services_before_spawn))
username = "******"
# Auth header
test_logger.info("Authenticating with user: {}".format(username))
headers = {"Remote-User": username}
assert wait_for_site(JHUB_URL, valid_status_code=401) is True
with requests.Session() as s:
# Login
login_response = s.post(JHUB_URL + "/hub/login", headers=headers)
test_logger.info("Login response message: {}".format(
login_response.text))
assert login_response.status_code == 200
# Spawn a notebook
spawn_form_resp = s.get(JHUB_URL + "/hub/spawn")
test_logger.info("Spawn page message: {}".format(spawn_form_resp.text))
assert spawn_form_resp.status_code == 200
assert "Select a notebook image" in spawn_form_resp.text
payload = {"dockerimage": "nielsbohr/base-notebook:latest"}
spawn_resp = s.post(JHUB_URL + "/hub/spawn", data=payload)
test_logger.info("Spawn POST response message: {}".format(
spawn_resp.text))
assert spawn_resp.status_code == 200
# Get spawned service
target_service_name = "{}-".format("jupyter")
spawned_service = get_service(client, target_service_name)
assert spawned_service is not None
# Get the service api url
service_url = get_service_url(spawned_service)
# If failed the service might not be running
if not service_url:
test_logger.info("Properly failed to start the service correctly")
assert service_url is not None
# Combine with the base jhub URL
jhub_service_api = urljoin(JHUB_URL, service_url)
# Write to user home
new_file = "write_test.ipynb"
data = json.dumps({"name": new_file})
test_logger.info("Looking for xsrf in: {}".format(s.cookies))
# Refresh csrf token
assert wait_for_session(s, jhub_service_api, require_xsrf=True)
assert "_xsrf" in s.cookies
xsrf_token = s.cookies["_xsrf"]
service_api_url = get_service_api_url(spawned_service,
postfix_url="contents/")
jhub_service_content = urljoin(JHUB_URL, service_api_url)
# Write to home
xsrf_headers = {"X-XSRFToken": xsrf_token}
resp = s.put(
"".join([jhub_service_content, new_file]),
data=data,
headers=xsrf_headers,
)
assert resp.status_code == 201
# Remove via the web interface
refresh_csrf(s, jhub_service_api)
assert "_xsrf" in s.cookies
delete_headers = {
"Referer": urljoin(JHUB_URL, "/hub/home"),
"Origin": JHUB_URL,
}
jhub_user = get_service_user(spawned_service)
delete_url = urljoin(JHUB_URL,
"/hub/api/users/{}/server".format(jhub_user))
# Wait for the server to finish deleting
deleted = delete(s, delete_url, headers=delete_headers)
assert deleted
deleted_service = get_service(client, target_service_name)
assert deleted_service is None
def test_image_selection(image, swarm, network, make_service):
"""Test that the spawner allows for dynamic image selection"""
test_logger.info("Start of the image selection test")
make_service(hub_service)
client = docker.from_env()
# jupyterhub service should be running at this point
services_before_spawn = client.services.list()
test_logger.info("Pre test services: {}".format(services_before_spawn))
username = "******"
password = "******"
test_logger.info("Authenticating with user: {}".format(username))
assert wait_for_site(JHUB_URL) is True
with requests.Session() as s:
# login
test_logger.info("Authenticating with user: {}".format(username))
login_response = s.post(
urljoin(JHUB_URL, "/hub/login"),
data={
"username": username,
"password": password
},
)
test_logger.info("Login response message: {}".format(
login_response.text))
assert login_response.status_code == 200
# Spawn a notebook
spawn_form_resp = s.get(JHUB_URL + "/hub/spawn")
test_logger.info("Spawn page message: {}".format(spawn_form_resp.text))
assert spawn_form_resp.status_code == 200
assert "Select a notebook image" in spawn_form_resp.text
user_image = "nielsbohr/base-notebook:latest"
user_image_name = "Basic Python Notebook"
payload = {"name": user_image_name, "image": user_image}
json_payload = json.dumps(payload)
spawn_resp = s.post(
JHUB_URL + "/hub/spawn/{}".format(username),
files={"select_image": (
None,
json_payload,
)},
)
test_logger.info("Spawn POST response message: {}".format(
spawn_resp.text))
assert spawn_resp.status_code == 200
target_service_name = "{}-{}-{}".format("jupyter", username, "1")
spawned_service = get_service(client, target_service_name)
assert spawned_service is not None
# Verify that a task is succesfully running
running_task = wait_for_service_task(
client, spawned_service, filters={"desired-state": "running"})
assert running_task
# Verify that the image is correct
service_image = get_task_image(running_task)
assert service_image == user_image
service_labels = get_service_labels(spawned_service)
assert service_labels is not None
assert service_labels["image_name"] == user_image_name
# Delete the spawned service
delete_headers = {
"Referer": urljoin(JHUB_URL, "/hub/home"),
"Origin": JHUB_URL
}
jhub_user = get_service_user(spawned_service)
delete_url = urljoin(JHUB_URL,
"/hub/api/users/{}/server".format(jhub_user))
deleted = delete(s, delete_url, headers=delete_headers)
assert deleted
deleted_service = get_service(client, target_service_name)
assert deleted_service is None
# Spawn a second service with a different name but the same image ##
# Spawn a notebook
second_spawn_form_resp = s.get(JHUB_URL + "/hub/spawn")
test_logger.info("Spawn page message: {}".format(
second_spawn_form_resp.text))
assert second_spawn_form_resp.status_code == 200
assert "Select a notebook image" in second_spawn_form_resp.text
second_image_name = "Basic Python Notebook 2"
selection_payload = {"name": second_image_name, "image": user_image}
json_second_payload = json.dumps(selection_payload)
spawn_resp = s.post(
JHUB_URL + "/hub/spawn/{}".format(username),
files={"select_image": (
None,
json_second_payload,
)},
)
test_logger.info("Spawn POST response message: {}".format(
spawn_resp.text))
assert spawn_resp.status_code == 200
second_target_service_name = "{}-{}-{}".format("jupyter", username,
"1")
second_spawned_service = get_service(client,
second_target_service_name)
assert second_spawned_service is not None
# Verify that a task is succesfully running
second_running_task = wait_for_service_task(
client,
second_spawned_service,
filters={"desired-state": "running"})
assert second_running_task
# Verify that the image is correct
second_service_image = get_task_image(second_running_task)
assert second_service_image == user_image
second_service_labels = get_service_labels(second_spawned_service)
assert second_service_labels is not None
assert second_service_labels["image_name"] == second_image_name
# Delete the second spawned service
deleted = delete(s, delete_url, headers=delete_headers)
assert deleted
deleted_service = get_service(client, second_target_service_name)
assert deleted_service is None
def disconnect_service(input, service_id):
service = get_service(service_id)
try:
service.Disconnect()
except dbus.DBusException, error:
return error
def service(input, service_id):
service = get_service(service_id)
try:
service.Connect()
except dbus.DBusException, error:
print "%s: %s" % (error._dbus_error_name, error.message)
def disconnect_service(input, service_id):
service = get_service(service_id)
try:
service.Disconnect()
except dbus.DBusException, error:
return error
def service(input, service_id):
service = get_service(service_id)
try:
service.Connect()
except dbus.DBusException, error:
print "%s: %s" % (error._dbus_error_name, error.message)
def post(post_id):
res = util.get_service('/collab/post/', post_id)
return util.toJSON(res)
def test_creates_service(image, swarm, network, make_service):
"""Test that logging in as a new user creates a new docker service."""
test_logger.info("Start of service testing")
make_service(hub_service)
client = docker.from_env()
# jupyterhub service should be running at this point
services_before_spawn = client.services.list()
test_logger.info("Pre test services: {}".format(services_before_spawn))
username = "******"
password = "******"
test_logger.info("Authenticating with user: {}".format(username))
assert wait_for_site(JHUB_URL) is True
with requests.Session() as s:
# login
test_logger.info("Authenticating with user: {}".format(username))
login_response = s.post(
JHUB_URL + "/hub/login?next=",
data={
"username": username,
"password": password
},
)
test_logger.info("Login response message: {}".format(
login_response.text))
assert login_response.status_code == 200
# Spawn a notebook
spawn_form_resp = s.get(JHUB_URL + "/hub/spawn")
test_logger.info("Spawn page message: {}".format(spawn_form_resp.text))
assert spawn_form_resp.status_code == 200
assert "Select a notebook image" in spawn_form_resp.text
payload = {"dockerimage": "nielsbohr/base-notebook:latest"}
spawn_resp = s.post(JHUB_URL + "/hub/spawn", data=payload)
test_logger.info("Spawn POST response message: {}".format(
spawn_resp.text))
assert spawn_resp.status_code == 200
services = client.services.list()
test_logger.info("Post spawn services: {}".format(services))
target_service_name = "{}-{}-{}".format("jupyter", username, "1")
spawned_service = get_service(client, target_service_name)
assert spawned_service is not None
# Verify that a task is succesfully running
running_task = wait_for_service_task(
client, spawned_service, filters={"desired-state": "running"})
assert running_task
# wait for user home
home_resp = s.get(JHUB_URL + "/user/{}/tree?".format(username))
assert home_resp.status_code == 200
# Remove via the web interface
delete_headers = {
"Referer": urljoin(JHUB_URL, "/hub/home"),
"Origin": JHUB_URL
}
jhub_user = get_service_user(spawned_service)
delete_url = urljoin(JHUB_URL,
"/hub/api/users/{}/server".format(jhub_user))
pending = True
num_wait, max_wait = 0, 15
while pending or num_wait > max_wait:
num_wait += 1
resp = s.delete(delete_url, headers=delete_headers)
test_logger.info(
"Response from removing the user server: {}".format(resp.text))
if resp.status_code == 204:
pending = False
time.sleep(1)
assert resp.status_code == 204
# double check it is gone
deleted_service = get_service(client, target_service_name)
assert deleted_service is None
test_logger.info("End of test service")
def security_get_session():
res = util.get_service('/security/session/')
return util.toJSON(res)
def update_service(input, service_id):
properties = get_properties(service_id)
if not properties.keys():
return "No properties for service %s" % service_id
service = get_service(service_id)
try:
if input.autoconnect == "Yes":
autoconnect = True
else:
autoconnect = False
(value_changed, error) = change(service, properties, "AutoConnect",
autoconnect)
if not value_changed:
return service_not_found(service_id, error, "AutoConnect")
except:
pass
try:
(value_changed, error) = change(
service, properties, "Domains.Configuration", input.domains,
dbus.Array([input.domains], signature=dbus.Signature('s')))
if not value_changed:
return service_not_found(service_id, error, "Domains")
except:
pass
try:
(value_changed, error) = change(
service, properties, "Nameservers.Configuration",
input.nameservers,
dbus.Array([input.nameservers], signature=dbus.Signature('s')))
if not value_changed:
return service_not_found(service_id, error, "Nameservers")
except:
pass
try:
(value_changed, error) = change(
service, properties, "Timeservers.Configuration",
input.timeservers,
dbus.Array([input.timeservers], signature=dbus.Signature('s')))
if not value_changed:
return service_not_found(service_id, error, "Timeservers")
except:
pass
try:
if input.proxymethod == "auto":
if changed_dict(properties, "Proxy.Configuration", "URL",
input.proxyurl):
proxy = {"Method": make_variant("auto")}
proxy["URL"] = make_variant(input.proxyurl)
try:
service.SetProperty("Proxy.Configuration", proxy)
except dbus.DBusException, error:
return service_not_found(service_id, error,
"Proxy URL setting failed")
elif input.proxymethod == "manual":
set_property = False
proxy = {"Method": make_variant("manual")}
if changed_dict(properties, "Proxy.Configuration", "Servers",
input.proxyservers):
proxy["Servers"] = split_string(input.proxyservers)
set_property = True
if changed_dict(properties, "Proxy.Configuration", "Excludes",
input.proxyexcludes):
proxy["Excludes"] = split_string(input.proxyexcludes)
set_property = True
if set_property:
try:
service.SetProperty("Proxy.Configuration",
dbus.Dictionary(proxy, signature='sv'))
except dbus.DBusException, error:
return service_not_found(service_id, error,
"Manual Proxy setting failed")
