def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
if args.parent_project_path is not None:
project_path = Server.get_project_by_name_and_parent_path(
logger, server, None, args.parent_project_path)
else:
project_path = None
try:
project = PublishSamplesCommand.get_project_by_name_and_parent_path(
logger, server, args.project_name, project_path)
except Exception as e:
Errors.exit_with_error(
logger,
_("tabcmd.report.error.publish_samples.expected_project"),
exception=e)
try:
server.projects.update(project, samples=True)
except Exception as e:
Errors.exit_with_error(logger,
_("tabcmd.result.failure.publish_samples"),
exception=e)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
if args.parent_project_path:
logger.debug("parent path: {}".format(args.parent_project_path))
try:
logger.debug(
_("deleteproject.status").format(args.parent_project_path,
args.project_name))
project = Server.get_project_by_name_and_parent_path(
logger, server, args.project_name, args.parent_project_path)
except TSC.ServerResponseError as e:
Errors.exit_with_error(
logger, _("publish.errors.unexpected_server_response"), e)
project_id = project.id
try:
logger.info(_("deleteproject.status").format(args.project_name))
server.projects.delete(project_id)
logger.info(_("common.output.succeeded"))
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger,
"tabcmd.result.failure.delete.project", e)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
parent_id = None
readable_name = args.project_name
if args.parent_project_path:
try:
logger.info(
_("tabcmd.find.parent_project").format(
args.parent_project_path))
parent = Server.get_project_by_name_and_parent_path(
logger, server, None, args.parent_project_path)
except TSC.ServerResponseError as exc:
Errors.exit_with_error(
logger, _("publish.errors.server_resource_not_found"), exc)
readable_name = "{0}/{1}".format(args.parent_project_path,
args.project_name)
parent_id = parent.id
logger.debug("parent project = `{0}`, id = {1}".format(
args.parent_project_path, parent_id))
logger.info(_("createproject.status").format(readable_name))
new_project = TSC.ProjectItem(args.project_name, args.description,
None, parent_id)
try:
project_item = server.projects.create(new_project)
logger.info(_("common.output.succeeded"))
return project_item
except TSC.ServerResponseError as e:
if Errors.is_resource_conflict(e):
if args.continue_if_exists:
logger.info(
_("tabcmd.result.already_exists").format(
args.project_name))
return
else:
Errors.exit_with_error(
logger,
_("tabcmd.result.already_exists").format(
args.project_name))
Errors.exit_with_error(
logger, _("publish.errors.unexpected_server_response"), e)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
if args.project_name:
try:
project_id = Server.get_project_by_name_and_parent_path(
logger, server, args.project_name, args.parent_project_path
)
except Exception as exc:
Errors.exit_with_error(logger, _("publish.errors.server_resource_not_found"), exc)
else:
project_id = ""
args.project_name = "default"
args.parent_project_path = ""
publish_mode = PublishCommand.get_publish_mode(args)
source = PublishCommand.get_filename_extension_if_tableau_type(logger, args.filename)
logger.info(_("publish.status").format(args.filename))
if source in ["twbx", "twb"]:
new_workbook = TSC.WorkbookItem(project_id, name=args.name, show_tabs=args.tabbed)
try:
new_workbook = server.workbooks.publish(new_workbook, args.filename, publish_mode)
except IOError as ioe:
Errors.exit_with_error(logger, ioe)
logger.info(_("publish.success") + "\n{}".format(new_workbook.webpage_url))
elif source in ["tds", "tdsx", "hyper"]:
new_datasource = TSC.DatasourceItem(project_id, name=args.name)
try:
new_datasource = server.datasources.publish(new_datasource, args.filename, publish_mode)
except IOError as ioe:
Errors.exit_with_error(logger, exc)
logger.info(_("publish.success") + "\n{}".format(new_datasource.webpage_url))
def test_get_project(self, mock_server):
mock_server.projects.get = getter
Server.get_project_by_name_and_parent_path(mock.MagicMock(),
mock_server, "random_name",
"")
getter.assert_called()
def test_get_project(self):
logger = log(__class__.__name__, "info")
server = E2EServerTests.test_log_in()
Server.get_project_by_name_and_parent_path(logger, server, "Default",
None)
def run_command(args):
logger = log(__class__.__name__, args.logging_level)
logger.debug(_("tabcmd.launching"))
session = Session()
server = session.create_session(args)
refresh_action = "refresh"
if args.addcalculations or args.removecalculations:
logger.warning(
"Data Acceleration tasks are deprecated and this parameter has no effect."
"It will be removed in a future update.")
# are these two mandatory? mutually exclusive?
# docs: the REST method always runs a full refresh even if the refresh type is set to incremental.
if args.incremental: # docs: run the incremental refresh
logger.warn(
"Incremental refresh is not yet available through the new tabcmd"
)
# if args.synchronous: # docs: run a full refresh and poll until it completes
# else: run a full refresh but don't poll for completion
container = None
if args.project_name:
try:
container = Server.get_project_by_name_and_parent_path(
logger, server, args.project_name,
args.parent_project_path)
except Exception as ex:
logger.warning(
"Could not find project {}/{}. Continuing without.".format(
args.parent_project_path, args.project_name))
job = None
try:
# TODO: use the container in the search
if args.datasource:
logger.debug(_("export.status").format(args.datasource))
datasource_id = Server.get_data_source_id(
logger, server, args.datasource, container)
logger.info(
_("refreshextracts.status_refreshed").format(
_("content_type.datasource"), args.datasource))
job: TSC.JobItem = server.datasources.refresh(datasource_id)
elif args.workbook:
logger.debug(_("export.status").format(args.workbook))
workbook_id = Server.get_workbook_id(logger, server,
args.workbook, container)
logger.info(
_("refreshextracts.status_refreshed").format(
_("content_type.workbook"), args.workbook))
job: TSC.JobItem = server.workbooks.refresh(workbook_id)
elif args.url:
logger.error("URL not yet implemented")
except TSC.ServerResponseError as e:
Errors.exit_with_error(logger, _("refreshextracts.errors.error"),
e)
logger.info(_("common.output.job_queued_success"))
if args.synchronous:
# maintains a live connection to the server while the refresh operation is underway, polling every second
# until the background job is done. <job id="JOB_ID" mode="MODE" type="RefreshExtract" />
logger.info("Waiting for refresh job to begin ....")
try:
polling2.poll(
lambda: logger.info(".") and job.started_at is not None,
step=1,
timeout=args.timeout)
except polling2.TimeoutException as te:
Errors.exit_with_error(logger,
_("messages.timeout_error.summary"))
logger.info("Job started at {}".format(job.started_at))
try:
polling2.poll(
lambda: logger.info("{}".format(job.progress)) and job.
finish_code != -1,
step=1,
timeout=args.timeout,
)
logger.info("Job completed at {}".format(job.completed_at))
except polling2.TimeoutException as te:
Errors.exit_with_error(logger,
_("messages.timeout_error.summary"))
else:
logger.info(_("common.output.job_queued_success"))
logger.debug("Extract refresh started with JobID: {0}".format(
job.id))