def connectToServer(self, resetTicket=False):
try:
server = TacticServerStub()
except TacticApiException:
tacticDataProcess.createSthpwUserFile(os.getlogin())
server = TacticServerStub()
print("Connecting to server...")
if resetTicket:
if not self.setTicket(server):
print("Connecting interrupted.")
return
try:
server.ping()
except Exception as err:
print(err)
if not self.setTicket(server):
print("Connecting interrupted.")
return
print("Connection successful.")
self.connected = True
self.server = server
ticketData = tacticDataProcess.getTicketData()
self.userName = ticketData.get('login')
self.IpAdress = ticketData.get('IpAdress')
self.ticket = ticketData.get('ticket')
self.userData = self.__getUserData(self.userName)
self.userProjects = self.__getAllUserProjects(self.userName)
self.isAdmin = tacticPostUtils.checkAdminPremition(
server, self.userName)
return True
def connectToServer(resetTicket=False):
global server
try:
server = TacticServerStub()
except TacticApiException:
tacticDataProcess.createSthpwUserFile(os.getlogin())
server = TacticServerStub()
print("Connecting to server...")
if resetTicket:
setTicket(server)
print("server", server)
try:
server.ping()
except Exception as err:
print(err)
if setTicket(server) is None:
return
print("Connection successful.")
# connected = True
# server = server
# ticketData = tacticDataProcess.getTicketData()
# userName = ticketData.get('login')
# IpAdress = ticketData.get('IpAdress')
# ticket = ticketData.get('ticket')
# mainProject = ticketData.get('project')
# userData = __getUserData(userName)
# isAdmin = tacticPostUtils.checkAdminPremition(server, userName)
return True
def bootstrap_get_tactic_server_stub( tactic_server_str, project_code, login, password ):
conn = httplib.HTTPConnection(tactic_server_str)
conn.request("GET", "/context/VERSION.txt")
response = conn.getresponse()
# print response.status, response.reason
data = response.read()
tactic_version = data.strip()
conn.close()
print
print "> Found TACTIC version '%s' running on server %s ..." % (tactic_version, tactic_server_str)
print
client_lib_install_path = "C:/sthpw/client_api/tactic-%s/client" % tactic_version
print " ... attempting to import 'TacticServerStub' from 'tactic_client_lib' located in:"
print
print " %s" % client_lib_install_path
print
try:
sys.path.append( client_lib_install_path )
from tactic_client_lib import TacticServerStub
if not login or not password:
print
print "> Warning: login/password not provided, assuming the use of .tacticrc ticket ..."
print
tactic_server = TacticServerStub(server=tactic_server_str, project=project_code)
else:
tactic_server = TacticServerStub(
server=tactic_server_str,
project=project_code,
user=login,
password=password
)
except:
print " ERROR: unable to access TACTIC client API for server version '%s'" % (tactic_version)
if not login or not password:
print " (likely there is no .tacticrc ticket that exists)"
print
print "Exception found:"
print '-'*60
traceback.print_exc(file=sys.stdout)
print '-'*60
print
tactic_server = None
return tactic_server
def execute(my):
#protocol = 'xmlrpc'
protocol = 'local'
if protocol == 'local':
server = TacticServerStub.get()
else:
server = TacticServerStub(protocol=protocol, setup=False)
TacticServerStub.set(server)
project = my.data.get("project")
ticket = my.data.get("ticket")
assert project
assert ticket
server.set_server("localhost")
server.set_project(project)
server.set_ticket(ticket)
my.class_name = my.data.get('class_name')
assert my.class_name
my.kwargs = my.data.get('kwargs')
if not my.kwargs:
my.kwags = {}
#trigger = eval("%s(**my.kwargs)" % my.class_name)
trigger = Common.create_from_class_path(my.class_name,
kwargs=my.kwargs)
input_data = my.get_input_data()
trigger.set_input(input_data)
trigger.execute()
def execute(my):
#protocol = 'xmlrpc'
protocol = 'local'
if protocol == 'local':
server = TacticServerStub.get()
else:
server = TacticServerStub(protocol=protocol, setup=False)
TacticServerStub.set(server)
project = my.data.get("project")
ticket = my.data.get("ticket")
assert project
assert ticket
server.set_server("localhost")
server.set_project(project)
server.set_ticket(ticket)
my.class_name = my.data.get('class_name')
assert my.class_name
# get the script to run
script_code = my.data.get("script_code")
if script_code:
search_type = "config/custom_script"
search_key = server.build_search_key(search_type, script_code)
script_obj = server.get_by_search_key(search_key)
script = script_obj.get('script')
my.run_script(script)
else:
print "Nothing to run"
def test_all(self):
print "Running Sample3d Test"
from pyasm.security import Batch
from pyasm.biz import Project
Batch()
Project.set_project("sample3d")
#self.server = TacticServerStub(protocol="local")
self.server = TacticServerStub(protocol="xmlrpc")
project_code = "sample3d"
self.server.set_project(project_code)
self.server.start("Sample3d Test")
try:
self._test_create_search_type()
self._test_create_submission()
self._test_get_submission()
self._test_shot_sequence_hierarchy()
self._test_query_snapshots()
#self._test_performance()
except Exception:
self.server.abort()
raise
self.server.abort()
def _execute(self):
# get the server name
server_name = self.get_option("server_name")
if not server_name:
raise ClientCallbackException(
"No [server_name] option delivered to callback")
server_name = server_name[0]
# get the project
project_code = self.get_option("project_code")
if not project_code:
raise ClientCallbackException(
"No [project_code] option delivered to callback")
project_code = project_code[0]
# the entire pipeline is run in a TacticServer Transaction
from tactic_client_lib import TacticServerStub
self.server = TacticServerStub()
self.server.set_server(server_name)
self.server.set_ticket(self.ticket)
self.server.set_project(project_code)
self.server.start("Pipeline checkin")
try:
self.execute()
except Exception, e:
self.server.abort()
raise
def main():
# get an instance of the stub
server = TacticServerStub()
# start the transaction
server.start("Set query")
try:
# define the search type we are searching for
search_type = "prod/asset"
# define a filter
filters = []
filters.append( ("asset_library", "chr") )
# do the query
assets = server.query(search_type, filters)
# show number found
print("found [%s] assets" % len(assets) )
# go through the asset and print the code
for asset in assets:
code = asset.get("code")
print(code)
except:
# in the case of an exception, abort all of the interactions
server.abort()
raise
else:
# otherwise, finish the transaction
server.finish()
def _test_get_submission(self):
server = TacticServerStub()
server.set_project("sample3d")
# choose some arbitrary bin
bin_id = 4
filters = []
filters.append(['bin_id', bin_id])
connectors = server.query("prod/submission_in_bin", filters)
# get all of the submissions from the bin
submission_ids = [x.get('submission_id') for x in connectors]
filters = [['id', submission_ids]]
submissions = server.query("prod/submission", filters)
# get all of the snapshots from the submissions
for submission in submissions:
search_key = submission.get('__search_key__')
print "-" * 20
snapshot = server.get_snapshot(search_key, include_paths=True)
paths = snapshot.get('__paths__')
for path in paths:
print path
def search(cls, filters=[]):
SubjectInfo.logger.debug("Search with cls: %s" % cls)
server = TacticServerStub()
objects = server.query(cls.stype, filters=filters)
# Here we do something different
si = SubjectInfo(objects)
return si
def __init__(self, data, server=None):
if not data:
raise "Must set data for the exam"
self.server = server or TacticServerStub()
self.data = data
self.__dict__.update(data)
self._tags = None
def post(self):
json_data = request.get_json()
ticket = json_data.get('token')
element_evaluation_data = json_data.get('element_evaluation')
server = TacticServerStub(server=url, project=project, ticket=ticket)
server.insert('twog/element_evaluation', element_evaluation_data)
return jsonify({'status': 200})
def main(args):
usage = "USAGE: checkin.py <search_type> <code> [context] <path>\n"
usage += "example: python checkin.py beat Sc01.Bt01 .\\test\\image.png"
context = "publish"
# TODO: lots of assumptions here
if len(args) == 2:
# assume code and file path are equivalent
code = args[1]
file_path = args[1]
elif len(args) == 3:
code = args[1]
file_path = args[2]
elif len(args) == 4:
code = args[1]
context = args[2]
file_path = args[3]
else:
print usage
return
search_type = args[0]
server = TacticServerStub()
# do the actual work
server.start("Checked in file [%s] to [%s] - [%s]" %
(file_path, search_type, code))
try:
# query all of the search_types to simplify argument
if search_type.find("/") == -1:
columns = ["search_type"]
results = server.query("sthpw/search_object", columns=columns)
for result in results:
test = result.get("search_type")
if test.endswith("/%s" % search_type):
search_type = test
break
else:
raise Exception("Search type [%s] not found" % search_type)
search_key = server.build_search_key(search_type, code)
# upload the file
server.upload_file(file_path)
# checkin the uploaded file
result = server.simple_checkin(search_key, context, file_path)
except Exception as e:
server.abort()
print "ERROR: ", e.__str__()
else:
server.finish()
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('token', required=True)
args = parser.parse_args()
ticket = args.get('token')
server = TacticServerStub(server=url, project=project, ticket=ticket)
element_evaluations = server.eval("@SOBJECT(twog/element_evaluation)")
return jsonify({'element_evaluations': element_evaluations})
def get_server(my):
# do a query for the search
from tactic_client_lib import TacticServerStub
if my.protocol == 'xmlrpc':
stub = TacticServerStub(setup=False, protocol=my.protocol)
stub.set_server(my.host)
stub.set_project(my.project_code)
stub.set_ticket(my.ticket)
else:
stub = TacticServerStub.get()
return stub
def search(cls, expression=None, filters=[], server=None):
TObject.logger.debug(
"Search with cls: {}, expression: {} filters: {}".format(
cls, expression, filters))
server = server or TacticServerStub()
columns = server.get_column_names(cls.stype)
if expression != None:
TObject.logger.debug("Evaluating expression {}".format(expression))
objects = server.eval(expression)
elif filters != None:
TObject.logger.debug("Filtering with {}".format(filters))
objects = server.query(cls.stype, filters=filters, columns=columns)
return [cls(data=x, server=server) for x in objects]
def get(self, name):
parser = reqparse.RequestParser()
parser.add_argument('token', required=True)
args = parser.parse_args()
ticket = args.get('token')
server = TacticServerStub(server=url, project=project, ticket=ticket)
element_evaluations = server.eval(
"@SOBJECT(twog/element_evaluation['name', '{0}'])".format(name))
if element_evaluations:
return jsonify({'exists': True})
else:
return jsonify({'exists': False})
def main():
# get an instance of the stub
server = TacticServerStub()
# start the transaction
server.start("Ping Test")
try:
# ping the server
print server.ping()
except:
# in the case of an exception, abort all of the interactions
server.abort()
raise
else:
# otherwise, finish the transaction
server.finish()
def _test_insert_trigger(self):
# create a db trigger
sobject = Search.eval(
"@SOBJECT(sthpw/trigger['event','insert|unittest/person'])",
single=True)
if sobject:
raise Exception(
'Please delete the insert|unittest/person trigger in sthpw first'
)
trigger_sobj = SearchType.create("sthpw/trigger")
trigger_sobj.set_value("event", "insert|unittest/person")
trigger_sobj.set_value("class_name",
"pyasm.command.command_test.TestInsertHandler")
trigger_sobj.set_value("description", "Unittest Test Api Handler")
trigger_sobj.commit()
search = Search("sthpw/trigger")
count = search.get_count()
# use the client api to insert that trigger
server = TacticServerStub(protocol='xmlrpc')
server.start("insert trigger test")
try:
# create a new person
search_type = "unittest/person"
code = "fred"
search_key = server.build_search_key(search_type, code)
Container.put("TestApiHandler/search_key", search_key)
# insert
data = {'code': code}
# insert test: if the trigger fails then an exception should be
# raised ...?
server.insert(search_type, data)
finally:
server.abort()
trigger_sobj.delete()
search = Search('sthpw/trigger')
search.add_filter('event', 'insert|unittest/person')
trig = search.get_sobject()
self.assertEquals(trig, None)
def test_all(self):
self.server = TacticServerStub()
project_code = "unittest"
self.server.set_project(project_code)
self.server.start("Expression Test")
try:
self._setup()
self._test_expression()
except:
self.server.abort()
raise
else:
self.server.abort()
def test_all(my):
my.server = TacticServerStub()
project_code = "unittest"
my.server.set_project(project_code)
my.server.start("Expression Test")
try:
my._setup()
my._test_expression()
except:
my.server.abort()
raise
else:
my.server.abort()
def main(args):
# USAGE: query_shot.py <shot_code>
shot_code = args[0]
server = TacticServerStub()
search_key = server.build_search_type(SEARCH_TYPE)
# do the actual work
server.start("Queried shot [%s]" % shot_code)
try:
filters = [('code', shot_code)]
print server.query(search_key, filters)
except:
server.abort()
raise
else:
server.finish()
def main(args, login=None):
# USAGE: checkin_plates.py
code = args[0]
file_range = args[1]
pattern = args[2]
# hard-coded for now
context = 'publish'
server = TacticServerStub(login)
# do the actual work
server.start("Checked in file group [%s]" % pattern)
try:
# checkin the uploaded file
filters = []
filters.append(('code', code))
results = server.query(SEARCH_TYPE, filters)
# take the first one
if results:
id = results[0].get('id')
else:
print "Plate with code [%s] not found. Please insert an entry in the Plates tab first." %code
return
search_key = server.build_search_key(SEARCH_TYPE, id, column='id')
# move the file
dir = server.get_handoff_dir()
print "Copied files to handoff dir\n"
new_pattern = pattern
file_type = 'main'
# run group checkin
server.group_checkin(search_key, context, file_path=new_pattern, file_type=file_type, \
file_range=file_range, mode='copy', info={'type':'2d_plates'})
except:
server.abort()
raise
else:
server.finish()
def main(args):
search_type = args[0]
code = args[1]
if len(args) == 2:
context = "publish"
to_dir = "."
elif len(args) == 3:
context = "publish"
to_dir = args[2]
else:
context = args[2]
to_dir = args[3]
server = TacticServerStub()
# do the actual work
server.start("Checked out file/s to [%s]" % to_dir)
try:
# query all of the search_types to simplify argument
if search_type.find("/") == -1:
columns = ["search_type"]
results = server.query("sthpw/search_object", columns=columns)
for result in results:
test = result.get("search_type")
if test.endswith("/%s" % search_type):
search_type = test
break
else:
raise Exception("Search type [%s] not found" % search_type)
search_key = server.build_search_key(search_type, code)
# checkin the uploaded file
version = -1
result = server.checkout(search_key, context, version=version, to_dir=to_dir)
print result
except:
server.abort()
raise
else:
server.finish()
def get_remote_server(self):
if not self.server_sobj:
return
host = self.server_sobj.get_value("host")
ticket = self.server_sobj.get_value("ticket")
# connect to the admin project? This likely does not matter
project_code = 'admin'
# get the transaction log of a remote server
from tactic_client_lib import TacticServerStub
remote_server = TacticServerStub(
protocol='xmlrpc',
server=host,
project=project_code,
ticket=ticket,
)
return remote_server
def _test_interpreter(self):
# create a package to be delivered to each handler
package = {'company': 'Acme', 'city': 'Toronto', 'context': 'whatever'}
# use client api
from tactic_client_lib import TacticServerStub
server = TacticServerStub()
interpreter = PipelineInterpreter(self.pipeline_xml)
interpreter.set_server(server)
interpreter.set_package(package)
interpreter.execute()
# introspect the interpreter to see if everything ran well
handlers = interpreter.get_handlers()
process_names = [x.get_process_name() for x in handlers]
expected = ['model', 'texture', 'rig', 'extra1', 'extra2']
self.assertEquals(expected, process_names)
# make sure all the handlers completed
self.assertEquals(5, len(handlers))
for handler in handlers:
self.assertEquals("complete", handler.get_status())
# check that the package is delivered to the input
self.assertEquals("Acme", handler.get_input_value('company'))
self.assertEquals("Toronto", handler.get_input_value('city'))
process_name = handler.get_process_name()
if process_name == 'model':
self.assertEquals("Acme", handler.company)
self.assertEquals("pig", handler.get_option_value('test'))
self.assertEquals("cow", handler.get_option_value('test2'))
# ensure input settings propogate
if process_name == 'extra1':
self.assertEquals("test.txt", handler.get_output_value('file'))
self.assertEquals("Acme", handler.get_package_value('company'))
def main(args, login=None):
# USAGE: checkin_shot.py <shot_code> <context> <path>
shot_code = args[0]
context = args[1]
file_path = args[2]
server = TacticServerStub(login)
search_key = server.build_search_key(SEARCH_TYPE, shot_code)
# do the actual work
server.start("Checked in file [%s]" % file_path)
try:
# upload the file
#server.upload_file(file_path)
# checkin the uploaded file
result = server.simple_checkin(search_key, context, file_path, mode='upload')
except:
server.abort()
raise
else:
server.finish()
def _test_create_submission(self):
server = TacticServerStub()
server.set_project("sample3d")
# choose some arbitrary bin
bin_id = 4
filters = []
# asset
parent_type = "prod/asset"
parent_code = "chr001"
parent_key = server.build_search_key(parent_type, parent_code)
parent = server.get_by_search_key(parent_key)
parent_id = parent.get('id')
# create a submission
data = {
'description': 'A test submission',
'artist': 'joe',
'context': 'model'
}
submission = server.insert("prod/submission",
data,
parent_key=parent_key)
submission_key = submission.get('__search_key__')
submission_id = submission.get('id')
file_path = './miso_ramen.jpg'
context = "publish"
snapshot = server.simple_checkin(submission_key,
context,
file_path,
mode="upload")
# no connect to the bin with a connector
data = {"bin_id": bin_id, 'submission_id': submission_id}
server.insert("prod/submission_in_bin", data)
def login(self):
global server
from tactic_client_lib import TacticServerStub
ticket_path = "c:/sthpw/etc"
if os.path.exists(ticket_path) is False:
os.makerdirs(ticket_path)
name = self.ui.login.text()
password = self.ui.password.text()
ticket_files = os.listdir("c:/sthpw/etc/")
ticket_file = "c:/sthpw/etc/" + name + ".tacticrc"
if len(ticket_files) == 0:
file_object = open(ticket_file, "w")
ticket_content = "login="******"\n" + "server=192.168.201.10" + "\n" + "project=simpleslot"
file_object.write(ticket_content)
file_object.close()
server = TacticServerStub(setup=0)
server.login = name
server.set_server("192.168.201.10")
server.set_project("simpleslot")
try:
ticket = server.get_ticket(name, password)
server.set_ticket(ticket)
file_object = open(ticket_file, "w")
ticket_content = "login="******"\n" + "server=192.168.201.10" + "\n" + "ticket=" + ticket + "\n" + "project=simpleslot"
file_object.write(ticket_content)
file_object.close()
print "ok"
except:
print "error"
loginWidget.close()
def __init__(self, data=None, server=None):
Subject.logger.setLevel(logging.DEBUG)
self.server = server or TacticServerStub()
if not data.has_key('subjectname') and data.has_key('patientname'):
data['subjectname'] = data['patientname']
if not data.has_key('subjectid') and data.has_key('patientid'):
data['subjectid'] = data['patientid']
if not data.has_key('subjectname') and not data.has_key(
'subjectid') and not data:
raise 'Must have subjectname and subjectid'
# Tactic will be looking for a 'safename'
if not data.has_key('safename'):
# Connect and create!
Subject.logger.debug("Finding the subject %s", data['subjectname'])
data['safename'] = util.makeFilename(data['subjectname'])
Subject.logger.debug(data)
if not data.has_key('code'):
d = util.createOrUpdate(self.server, Subject.stype, data,
[("subjectname", data['subjectname']),
("subjectid", data['subjectid'])])
else:
d = data
TObject.__init__(self, d, server)
