rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
'id': 'job.5.logged_in', | 'id': act3_id, | def test_restore_main_run(self): state_data = \ {'end_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 234159), 'run_num': 5, 'run_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 125149), 'runs': [{'command': 'free', 'end_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 232693), 'id': 'job.5.free_memory', 'run_time... |
state_action = state_data['runs'][0] | def test_restore_main_run(self): state_data = \ {'end_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 234159), 'run_num': 5, 'run_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 125149), 'runs': [{'command': 'free', 'end_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 232693), 'id': 'job.5.free_memory', 'run_time... | |
job_action = job_run.runs[0] assert_equal(job_action.id, state_action['id']) | assert_equal(len(job_run.runs), 2) assert_equal(job_run.runs[0].id, act1_id) assert_equal(job_run.runs[1].id, act3_id) | def test_restore_main_run(self): state_data = \ {'end_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 234159), 'run_num': 5, 'run_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 125149), 'runs': [{'command': 'free', 'end_time': datetime.datetime(2010, 12, 13, 15, 32, 3, 232693), 'id': 'job.5.free_memory', 'run_time... |
or self.scheduler != other.scheduler or self.node_pool != other.node_pool: | or self.scheduler != other.scheduler or self.node_pool != other.node_pool \ or len(self.topo_actions) != len(other.topo_actions): | def __eq__(self, other): if not isinstance(other, Job) or self.name != other.name or self.queueing != other.queueing \ or self.scheduler != other.scheduler or self.node_pool != other.node_pool: return False |
class Service(Job): def __init__(self, *args, **kwargs): super(Service, self).__init__(*args, **kwargs) enable_cmd = None disable_cmd = None | def restore_run(self, data): run = self.build_run() for r, state in zip(run.runs, data['runs']): r.restore_state(state) run.run_num = data['run_num'] run.start_time = data['start_time'] run.end_time = data['end_time'] run.set_run_time(data['run_time']) self.runs.appendleft(run) | |
name="foo", | name="testname", | def build_resource(self): self.mc = turtle.Turtle() self.job = turtle.Turtle( name="foo", runs=[], scheduler=None, node=TEST_NODE) self.mc.jobs = {self.job.name: self.job} |
scheduler=None, | scheduler_str="testsched", | def build_resource(self): self.mc = turtle.Turtle() self.job = turtle.Turtle( name="foo", runs=[], scheduler=None, node=TEST_NODE) self.mc.jobs = {self.job.name: self.job} |
assert job_result['jobs'][0]['name'] == "foo" | assert job_result['jobs'][0]['name'] == "testname" | def test_job_list(self): """Test that we get a proper job list""" resp = self.resource.render_GET(REQUEST) job_result = simplejson.loads(resp) assert 'jobs' in job_result assert job_result['jobs'][0]['name'] == "foo" |
child = self.resource.getChildWithDefault("foo", turtle.Turtle()) | child = self.resource.getChildWithDefault("testname", turtle.Turtle()) | def test_get_job(self): """Test that we can find a specific job""" child = self.resource.getChildWithDefault("foo", turtle.Turtle()) assert isinstance(child, www.JobResource) assert child._job is self.job |
scheduler=None, | scheduler_str="testsched", | def build_resource(self): self.job = turtle.Turtle( name="foo", runs=[ turtle.Turtle( id="1", start_time=None, end_time=None, exit_status=None, ) ], scheduler=None, node=TEST_NODE, ) |
os.waitpid(self.write_pid, os.WNOHANG)[0] self.write_pid = None | if os.waitpid(self.write_pid, os.WNOHANG)[0]: self.write_pid = None | def kill_child(self): if self.write_pid: os.waitpid(self.write_pid, os.WNOHANG)[0] self.write_pid = None |
run = self.build_run([self.enable_act]) | run = self.build_run(actions=[self.enable_act]) | def enable(self): if self.enable_act: run = self.build_run([self.enable_act]) self.enable_runs.appendleft(run) run.start() |
run = self.build_run([self.disable_act]) | run = self.build_run(actions=[self.disable_act]) | def disable(self): if self.disable_act: run = self.build_run([self.disable_act]) self.disable_runs.appendleft(run) run.start() |
def build_run(self, actions=None, run_num=None): actions = actions or self.topo_actions job_run = JobRun(self, run_num=run_num) if self.node_pool: job_run.node = self.node_pool.next() | def build_action_dag(self, job_run, actions): | def build_run(self, actions=None, run_num=None): actions = actions or self.topo_actions |
def build_run(self, node=None): | def build_run(self, node=None, actions=None, run_num=None): | def build_run(self, node=None): job_run = JobRun(self) job_run.node = node or self.node_pool.next() |
actions = actions or self.topo_actions job_run = JobRun(self, run_num=run_num) if self.node_pool: job_run.node = self.node_pool.next() | def build_run(self, node=None): job_run = JobRun(self) job_run.node = node or self.node_pool.next() | |
self.build_action_dag(job_run) | self.build_action_dag(job_run, actions) | def build_run(self, node=None): job_run = JobRun(self) job_run.node = node or self.node_pool.next() |
class ActionRunResource(resource.Resource): | class JobRunResource(resource.Resource): | def job_run_state(job_run): if job_run.is_success: state = "SUCC" elif job_run.is_cancelled: state = "CANC" elif job_run.is_failed: state = "FAIL" elif job_run.is_scheduled: state = "SCHE" elif job_run.is_unknown: state = "UNKWN" elif job_run.is_queued: state = "QUE" else: state = "RUNN" return state |
class JobRunResource(resource.Resource): isLeaf = False | def job_run_state(job_run): if job_run.is_success: state = "SUCC" elif job_run.is_cancelled: state = "CANC" elif job_run.is_failed: state = "FAIL" elif job_run.is_scheduled: state = "SCHE" elif job_run.is_unknown: state = "UNKWN" elif job_run.is_queued: state = "QUE" else: state = "RUNN" return state | |
def getChild(self, run_num, request): if run_num == '': return self if return ActionRunResource(self._run.) return error.NoResource() | def __init__(self, run): self._run = run resource.Resource.__init__(self) | |
if not self.store_delayed: self.store_delayed = True reactor.callLater(STATE_SLEEP, self.delay_store) | def store_state(self): """Stores the state of tron""" # If tron is already storing data, don't start again till it's done if not self.writing_enabled or (self.write_pid and not os.waitpid(self.write_pid, os.WNOHANG)[0]): # If a child is writing, we don't want to ignore this change, so lets try it later #if not self.sto... | |
log.warning("A previous run for %s has not finished - placing in queue", self.job.id) | log.warning("A previous run for %s has not finished - placing in queue", self.id) | def scheduled_start(self): self.attempt_start() |
log.warning("A previous run for %s has not finished - cancelling", self.job.id) | log.warning("A previous run for %s has not finished - cancelling", self.id) | def scheduled_start(self): self.attempt_start() |
log.info("Starting action job %s", self.job.id) | log.info("Starting action job %s", self.id) | def start(self): log.info("Starting action job %s", self.job.id) self.start_time = timeutils.current_time() self.end_time = None |
log.error("Reconfiguration failed: %" % str(e)) | log.exception("Reconfiguration failed") | def live_reconfig(self): try: self.load_config() self.run_jobs() except Exception, e: log.error("Reconfiguration failed: %" % str(e)) |
parser_output_zpt.feed(output_html) | parser_output_zpt.feed(text) | def send(self): """Sends the newsletter """ # preparations request = self.REQUEST enl = self.aq_inner.aq_parent |
text = text.replace("<p>>>PERSOLINE>>", "") | def send(self): """Sends the newsletter """ # preparations request = self.REQUEST enl = self.aq_inner.aq_parent | |
return queryUtility(ISiteRoot) | pstate = self.portal_state() return pstate.portal() | def portal(self): return queryUtility(ISiteRoot) |
return self.portal.portal_url() | pstate = self.portal_state() return pstate.portal_url() | def portal_url(self): return self.portal.portal_url() |
"${portal_url}", self.portal.absolute_url().strip('http://') | "${portal_url}", self.portal_url.strip('http://') | def register_subscriber(self): """ """ subscriber = self.request.get("subscriber") fullname = self.request.get("fullname", "") path_to_easynewsletter = self.request.get("newsletter") # remove leading slash from paths like: /mynewsletter path_to_easynewsletter = path_to_easynewsletter.strip('/') newsletter_container = s... |
confirmation_url = self.portal.absolute_url() + '/confirm-subscriber?hkey=' + str(hashkey) | confirmation_url = self.portal_url + '/confirm-subscriber?hkey=' + str(hashkey) | def register_subscriber(self): """ """ subscriber = self.request.get("subscriber") fullname = self.request.get("fullname", "") path_to_easynewsletter = self.request.get("newsletter") # remove leading slash from paths like: /mynewsletter path_to_easynewsletter = path_to_easynewsletter.strip('/') newsletter_container = s... |
mail = MIMEMultipart("alternative") | outer = MIMEMultipart() | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
mail['To'] = receiver['email'] | outer['To'] = receiver['email'] | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
mail['From'] = from_header mail['Subject'] = Header(subject) mail.epilogue = '' | outer['From'] = from_header outer['Subject'] = Header(subject) outer.epilogue = '' | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
mail.attach(text_part) | outer.attach(text_part) | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
html_part.attach(html_text) | outer.attach(html_text) | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
html_part.attach(image) mail.attach(html_part) try: MailHost.send(mail.as_string()) log.info("Send newsletter to \"%s\"" % receiver['email']) send_counter += 1 except Exception, e: log.info("Sending newsletter to \"%s\" failt, with error \"%s\"!" % (receiver['email'], e)) send_error_counter += 1 | outer.attach(image) MailHost.send(outer.as_string()) | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
def addSubscriber(self, subscriber, fullname, organisation): | def addSubscriber(self, subscriber, fullname, organization): | def addSubscriber(self, subscriber, fullname, organisation): """Adds a new subscriber to the newsletter (if valid). """ # we need the subscriber email here as an id, to check for existing entries email = subscriber plone_utils = getToolByName(self, 'plone_utils') id = plone_utils.normalizeString(email) try: self.invoke... |
id = plone_utils.normalizeString(email) | subscriber_id = plone_utils.normalizeString(email) | def addSubscriber(self, subscriber, fullname, organisation): """Adds a new subscriber to the newsletter (if valid). """ # we need the subscriber email here as an id, to check for existing entries email = subscriber plone_utils = getToolByName(self, 'plone_utils') id = plone_utils.normalizeString(email) try: self.invoke... |
self.invokeFactory('ENLSubscriber', id=id, description="", email=email, fullname=fullname, organisation=organisation) | self.manage_addProduct["EasyNewsletter"].addENLSubscriber(id=subscriber_id) | def addSubscriber(self, subscriber, fullname, organisation): """Adds a new subscriber to the newsletter (if valid). """ # we need the subscriber email here as an id, to check for existing entries email = subscriber plone_utils = getToolByName(self, 'plone_utils') id = plone_utils.normalizeString(email) try: self.invoke... |
text_plain = send_body['text'] | text_plain = send_body['plain'] | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
self.manage_addProduct["EasyNewsletter"].addENLSubscriber(id=subscriber_id) | execute_under_special_role(portal, "Contributor", self.invokeFactory, "ENLSubscriber", id=subscriber_id) | def addSubscriber(self, subscriber, fullname, organization): """Adds a new subscriber to the newsletter (if valid). """ # we need the subscriber email here as an id, to check for existing entries email = subscriber plone_utils = getToolByName(self, 'plone_utils') subscriber_id = plone_utils.normalizeString(email) try: ... |
o.reindexObject() | def addSubscriber(self, subscriber, fullname, organization): """Adds a new subscriber to the newsletter (if valid). """ # we need the subscriber email here as an id, to check for existing entries email = subscriber plone_utils = getToolByName(self, 'plone_utils') subscriber_id = plone_utils.normalizeString(email) try: ... | |
outer = MIMEMultipart() | outer = MIMEMultipart('alternative') | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
return text, text_plain | image_urls = parser_output_zpt.image_urls return text, text_plain, image_urls | def _send_body(self): """ Return rendered body of newsletter (text+html) w/o header and footer. """ |
if enl.getSenderName(): from_header = '"%s" <%s>' % (sender_name, sender_email) else: from_header = sender_email receivers = self._send_recipients(recipients) text, text_plain = self._send_body() | from_header = enl.getSenderName() and '"%s" <%s>' % (sender_name, sender_email) or sender_email | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
for image_url in parser_output_zpt.image_urls: | for image_url in image_urls: | def send(self, recipients=[]): """Sends the newsletter. An optional list of dicts (keys=fullname|mail) can be passed in for sending a newsletter out addresses != subscribers. """ |
flist = ls_r(dest, ".*\.h(pp|xx)?$") | flist = ls_r(dest, ".*\.h(pp|xx)$") | def ls_r(directory, pattern): """Returns a sorted list of all the files present in a diretory, relative to this directory. """ myreg = re.compile(pattern) res = list() for root, dirs, files in os.walk(directory): new_root = os.path.relpath(root, directory) if new_root == "." and not files: continue if new_root == "." a... |
info ("Test 01-b: returning..") | def test_01b(): # parse document (doc, err) = axl.file_parse ("test_01b.xml") if err: error ("Found error: " + str (err.code) + ", message: " + err.msg) return False # get root node node = doc.root # check node name if node.name != "document": error ("Expected to find node name 'document' but found: " + node.name) re... | |
(py_test_03, "Check PyAxlNode and PyAxlDoc relation") | (py_test_03, "Check PyAxlNode and PyAxlDoc relation"), (py_test_04, "Check PyAxlNode reference after PyAxlDoc reference finish") | def run_all_tests (): test_count = 0 for test in tests: # print log info ("TEST-" + str(test_count) + ": Running " + test[1]) # call test if not test[0](): error ("detected test failure at: " + test[1]) return False # next test test_count += 1 ok ("All tests ok!") return True |
(py_test_01, "Check PyNode type attributes"), (py_test_02, "Check PyNode replace, deattach, set_child_after method") | (py_test_01, "Check PyAxlNode type attributes"), (py_test_02, "Check PyAxlNode replace, deattach, set_child_after method"), (py_test_03, "Check PyAxlNode and PyAxlDoc relation") | def run_all_tests (): test_count = 0 for test in tests: # print log info ("TEST-" + str(test_count) + ": Running " + test[1]) # call test if not test[0](): error ("detected test failure at: " + test[1]) return False # next test test_count += 1 ok ("All tests ok!") return True |
(py_test_04, "Check PyAxlNode reference after PyAxlDoc reference finish") | (py_test_04, "Check PyAxlNode reference after PyAxlDoc reference finish"), (py_test_05, "Check PyAxlNode setting childs references crated") | def run_all_tests (): test_count = 0 for test in tests: # print log info ("TEST-" + str(test_count) + ": Running " + test[1]) # call test if not test[0](): error ("detected test failure at: " + test[1]) return False # next test test_count += 1 ok ("All tests ok!") return True |
result = self.setupResponse(result, method) | result = { 'status_code' : result.status_code, 'headers' : result.headers, 'content' : result.content } | def processRequest(self, method): params = self.setupRequest(method) result = 1 if (params['success']): result = urlfetch.fetch(params['url'], payload=params['body'], headers=params['headers'], method=params['method'], deadline=10) result = self.setupResponse(result, method) else: result = self.setupParsingErrorRespon... |
self.response.set_status(result['status_code']) for header in result['headers'].keys(): self.response.headers[header] = result['headers'][header] self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.out.write(result['content']) | if cgi.parse_qs(self.request.query_string).has_key('debugMode'): debugHeaders = {} debugHeaders.update(self.response.headers) if result.has_key('headers'): debugHeaders.update(result['headers']) debugHeaders.update( { 'Access-Control-Allow-Origin' : '*' } ) self.response.set_status(200) self.response.headers['Content-T... | def processRequest(self, method): params = self.setupRequest(method) result = 1 if (params['success']): result = urlfetch.fetch(params['url'], payload=params['body'], headers=params['headers'], method=params['method'], deadline=10) result = self.setupResponse(result, method) else: result = self.setupParsingErrorRespon... |
def setupResponse(self, result, method): return {'status_code' : result.status_code, 'headers' : result.headers, 'content' : result.content } | def setupRequest(self, method): qs = self.request.query_string parsedQs = cgi.parse_qs(qs) params = {} if parsedQs.has_key('url') and parsedQs.has_key('method'): params['success'] = True params['headers'] = {} params['body'] = None for header in parsedQs: if header == "url": params['url'] = urllib.unquote(parsedQs['u... | |
def setupResponse(self, pingResult, method): if method == "POST": return {'status_code' : pingResult.status_code, 'headers' : pingResult.headers, 'content' : pingResult.content } else: result = {} result['status_code'] = 200 result['headers'] = { 'Content-Type' : "text/plain" } result['content'] = str(pingResult.status... | def setupRequest(self, method): qs = self.request.query_string parsedQs = cgi.parse_qs(qs) params = {} if parsedQs.has_key('hub') and parsedQs.has_key('topic'): params['success'] = True params['url'] = urllib.unquote(parsedQs['hub'][0]) params['method'] = "POST" params['body'] = urllib.urlencode( { "hub.mode" : "publ... | |
opts, args = getopt.getopt(sys.argv[1:], 'u:t:x:r:f:pc:t:sa:v:d', ['username','table=','root=','prefix=','passfile=','content=','password', 'silent', 'attachments=', 'version=', 'debug']) | opts, args = getopt.getopt(sys.argv[1:], 'u:t:x:r:f:pc:t:sa:v:d', ['username=','table=','root=','prefix=','passfile=','content=','password', 'silent', 'attachments=', 'version=', 'debug']) | def format_content (content): pattern = re.compile(r""" \n\s*\n # The goal of this regex is to match two newlines in a row, with # only spaces in between. This is where we will add in our paragraph breaks. """, re.VERBOSE | re.MULTILINE); if len(content) < 4 or content[0:2] != '<p': return '<p>' + re.sub(pattern, r'</p... |
print "Command line options\n" + \ | sys.stderr.write("Command line options\n" + \ | def format_content (content): pattern = re.compile(r""" \n\s*\n # The goal of this regex is to match two newlines in a row, with # only spaces in between. This is where we will add in our paragraph breaks. """, re.VERBOSE | re.MULTILINE); if len(content) < 4 or content[0:2] != '<p': return '<p>' + re.sub(pattern, r'</p... |
"\t-d: debug (verbose output to STDERR)\n" | "\t-d: debug (verbose output to STDERR)\n") | def format_content (content): pattern = re.compile(r""" \n\s*\n # The goal of this regex is to match two newlines in a row, with # only spaces in between. This is where we will add in our paragraph breaks. """, re.VERBOSE | re.MULTILINE); if len(content) < 4 or content[0:2] != '<p': return '<p>' + re.sub(pattern, r'</p... |
opts, args = getopt.getopt(sys.argv[1:], 'u:t:x:r:f:pc:t:sa:v:', ['username','table=','root=','prefix=','passfile=','content=','password', 'silent', 'attachments=', 'version=']) | opts, args = getopt.getopt(sys.argv[1:], 'u:t:x:r:f:pc:t:sa:v:d', ['username','table=','root=','prefix=','passfile=','content=','password', 'silent', 'attachments=', 'version=', 'debug']) | def format_content (content): pattern = re.compile(r""" \n\s*\n # The goal of this regex is to match two newlines in a row, with # only spaces in between. This is where we will add in our paragraph breaks. """, re.VERBOSE | re.MULTILINE); if len(content) < 4 or content[0:2] != '<p': return '<p>' + re.sub(pattern, r'</p... |
"\t-s: silent (no output)\n" | "\t-s: silent (no output)\n" + \ "\t-d: debug (verbose output to STDERR)\n" | def format_content (content): pattern = re.compile(r""" \n\s*\n # The goal of this regex is to match two newlines in a row, with # only spaces in between. This is where we will add in our paragraph breaks. """, re.VERBOSE | re.MULTILINE); if len(content) < 4 or content[0:2] != '<p': return '<p>' + re.sub(pattern, r'</p... |
if (debug): sys.stderr.write("got %s: %s\n" % newNode.contentType,newNode.name) | def format_content (content): pattern = re.compile(r""" \n\s*\n # The goal of this regex is to match two newlines in a row, with # only spaces in between. This is where we will add in our paragraph breaks. """, re.VERBOSE | re.MULTILINE); if len(content) < 4 or content[0:2] != '<p': return '<p>' + re.sub(pattern, r'</p... | |
rootNode.children.append(newNode.name) nodes[newNode.name] = newNode | rootNode.children.append(newNode.unique) nodes[newNode.unique] = newNode | def format_content (content): pattern = re.compile(r""" \n\s*\n # The goal of this regex is to match two newlines in a row, with # only spaces in between. This is where we will add in our paragraph breaks. """, re.VERBOSE | re.MULTILINE); if len(content) < 4 or content[0:2] != '<p': return '<p>' + re.sub(pattern, r'</p... |
self.attachments.append([self.make_internal_link(url), unique]) | self.attachments.append([url.replace(self.attachments_path,''), unique]) | def format_links (self, nodes, url, unique, contentType): if contentType == 'attachment' and self.content.find(url) >= 0: self.attachments.append([self.make_internal_link(url), unique]) for i in self.children: nodes[i].format_links(nodes, url, unique, contentType) self.content = self.content.replace(url, '[[' + unique ... |
if opt in visdkrc_opts: setattr(options, opt, visdkrc_opts[opt]) | if visdkrc_opts: if opt in visdkrc_opts: setattr(options, opt, visdkrc_opts[opt]) | def get_options(self): """Get the options that have been set. |
pass | return None | def read_visdkrc(self): try: config = open(self.visdkrc) except IOError, e: if e.errno == 2: # Doesn't exist, ignore it pass elif e.errno == 13: print('Permission denied opening %s' % self.visdkrc) else: print('Could not open %s: %s' % (self.visdkrc, e.strerror)) |
print('Permission denied opening %s' % self.visdkrc) | print('ERROR: Permission denied opening %s' % self.visdkrc) return None | def read_visdkrc(self): try: config = open(self.visdkrc) except IOError, e: if e.errno == 2: # Doesn't exist, ignore it pass elif e.errno == 13: print('Permission denied opening %s' % self.visdkrc) else: print('Could not open %s: %s' % (self.visdkrc, e.strerror)) |
print('Could not open %s: %s' % (self.visdkrc, e.strerror)) | print('ERROR: Could not open %s: %s' % (self.visdkrc, e.strerror)) return None | def read_visdkrc(self): try: config = open(self.visdkrc) except IOError, e: if e.errno == 2: # Doesn't exist, ignore it pass elif e.errno == 13: print('Permission denied opening %s' % self.visdkrc) else: print('Could not open %s: %s' % (self.visdkrc, e.strerror)) |
self.si = ServiceInstance(vim=self) self.sc = self.si.content | self.si = ServiceInstance() self.sc = self.vsoap.invoke('RetrieveServiceContent', _this=self.si) | def __init__(self, url, username, password): self.vsoap = VimSoap(url) self.si = ServiceInstance(vim=self) self.sc = self.si.content self.pc = PropertyCollector(mor=self.sc.propertyCollector, vim=self) self.vsoap.invoke('Login', _this=self.sc.sessionManager, userName=username, password=password) |
def invoke(self, method, **kwargs): result = self.vsoap.invoke(method, **kwargs) | def invoke(self, method, _this, **kwargs): result = self.vsoap.invoke(method, _this=_this, **kwargs) | def invoke(self, method, **kwargs): result = self.vsoap.invoke(method, **kwargs) return result |
filtered_obj = obj_content.obj | filtered_obj_content = obj_content | def find_entity_view(self, view_type, begin_entity=None, filter=None): """Return a new instance based on the search filter. |
return kls(mor=filtered_obj, vim=self) | view = kls(mor=filtered_obj_content.obj, vim=self) view.set_view_data(filtered_obj_content, filter.keys()) return view | def find_entity_view(self, view_type, begin_entity=None, filter=None): """Return a new instance based on the search filter. |
class ServiceInstance(object): def __init__(self, vim): self.vim = vim self.mor = ManagedObjectReference(type='ServiceInstance', value='ServiceInstance') self.content = self.vim.vsoap.invoke('RetrieveServiceContent', _this=self.mor) | def find_entity_view(self, view_type, begin_entity=None, filter=None): """Return a new instance based on the search filter. | |
self.ent = object_content | self._object_content = object_content | def set_view_data(self, object_content, properties=None): """Update the local object from the passed in obj_content array.""" self.ent = object_content props = {} for dyn_prop in object_content.propSet: # Kludgy way of finding if the dyn_prop contains a collection prop_type = str(dyn_prop.val.__class__)[ str(dyn_prop.v... |
def RetrieveProperties(self, specSet): return self.vim.vsoap.invoke('RetrieveProperties', _this=self.mor, specSet=specSet) | def RetrieveProperties(self, specSet): return self.vim.vsoap.invoke('RetrieveProperties', _this=self.mor, specSet=specSet) | |
def refresh_datastore(self): """Explicitly refreshes free-space and capacity values.""" self.vim.vsoap.invoke('RefreshDatastore', _this=self.mor) self.update_view_data() def refresh_datastore_storage_info(self): self.vim.vsoap.invoke('RefreshDatastoreStorageInfo', _this=self.mor) self.update_view_data() | def __init__(self, mor, vim): self.browser = None self.capability = None self.host = [] self.info = None self.summary = None self.vm = [] | |
def acquire_mks_ticket(self): return self.vim.vsoap.invoke('AcquireMksTicket', _this=self.mor) def answer_vm(self, question_id, answer_choice): """Responds to a question that is blocking this virtual machine.""" self.vim.vsoap.invoke('AnswerVM', _this=self.mor, questionId=question_id, answerChoice=answer_choice) | def acquire_mks_ticket(self): return self.vim.vsoap.invoke('AcquireMksTicket', _this=self.mor) | |
if debug: self.client = suds.client.Client('file:///home/jonathan/projects/Personal/psphere/resources/vimService.wsdl') | def __init__(self, url, debug=False): if debug: self.client = suds.client.Client('file:///home/jonathan/projects/Personal/psphere/resources/vimService.wsdl') self.client = suds.client.Client(url + '/vimService.wsdl') self.client.set_options(location=url) | |
pprint(e) | if debug: pprint(e) | def invoke(self, method, **kwargs): """Invoke a method on the underlying soap service. |
log("Error: Control %s can't be replicated! This is a BUG in the Desklet!" "\nThings probably won't work right for you." % control) | log(_("Error: Control %s can't be replicated! This is a BUG in the Desklet!" "\nThings probably won't work right for you.") % control) | def __init__(self, control, size): |
size = 0 | size = 1 | def __init__(self, control, size): |
log("Warning: Value of property \"length\" must be greater than 0 (setting to 1)") | log(_("Warning: Value of property \"length\" must be greater than 0 (setting to 1)")) | def __setattr__(self, name, value): |
log("Warning: Property \"%s\" must be indexed (length == %d)." % (name, self.__length)) | log(_("Warning: Property \"%s\" must be indexed (length == %d).") % (name, self.__length)) | def __setattr__(self, name, value): |
log("Warning: Property \"%s\" must be indexed (length == %d)." % (name, self.__length)) | log(_("Warning: Property \"%s\" must be indexed (length == %d).") % (name, self.__length)) | def __getattr__(self, name): |
log("Warning: Control not initialized as an array.") | log(_("Warning: Control not initialized as an array in Desklet.")) | def __setitem__(self, idx, value): |
log("Warning: Control not initialized as an array.") | log(_("Warning: Control not initialized as an array in Desklet.")) | def __getitem__(self, idx): |
if idx < self.__length and idx >= 1: | if self.__length > 0: | def __delitem__(self, idx): |
del self.__dict__["_ControlWrapper__properties"][idx] new_ctrl_list = self.__dict__["_ControlWrapper__control"](open) del new_ctrl_list[idx] del self.__dict__["_ControlWrapper__control"] self.__dict__["_ControlWrapper__control"] = Vault( new_ctrl_list ) self.__dict__["_ControlWrapper__length"] = self.__length - 1 | if idx < 0: idx = self.__length + idx if idx < self.__length and idx >= 0: del self.__dict__["_ControlWrapper__properties"][idx] new_ctrl_list = self.__dict__["_ControlWrapper__control"](open) del new_ctrl_list[idx] self.__dict__["_ControlWrapper__control"] = Vault( new_ctrl_list ) self.__dict__["_ControlWrapper__... | def __delitem__(self, idx): |
log("Warning: Trying to delete index %d when length is %d." % (idx, self.__length)) | log(_("Warning: Control not initialized as an array in Desklet; not deleting anything.")) | def __delitem__(self, idx): |
self.__tooltips = gtk.Tooltips() self.__tooltips.enable() | def __init__(self, path): | |
self.__tooltips.set_tip(ebox, help) | ebox.set_tooltip_markup(help) | def __add_line(self, page, page_lines, indent, widgets, help): |
if (not obj): | if (not obj and not (parent._getp("id") == name)): | def f(): try: parent = self._get_parent() my_id = self._getp("id") if (not parent or not parent.get_child_by_id(my_id)): return |
relative = obj.get_layout_object() self.__layout_object.set_relative_to(relative, rx, ry) | if obj: relative = obj.get_layout_object() self.__layout_object.set_relative_to(relative, rx, ry) | def f(): try: parent = self._get_parent() my_id = self._getp("id") if (not parent or not parent.get_child_by_id(my_id)): return |
textrenderer0.set_property("wrap-mode", gtk.WRAP_WORD) | textrenderer0.set_property("wrap-mode", pango.WRAP_WORD) | def __create_listview(self, texts): |
textrenderer1.set_property("wrap-mode", gtk.WRAP_WORD) | textrenderer1.set_property("wrap-mode", pango.WRAP_WORD) | def __create_listview(self, texts): |
assert(self.__id, "The ID is invalid in the constructor.") | assert self.__id, "The ID is invalid in the constructor." | def get_id(self): assert(self.__id, "The ID is invalid in the constructor.") |
trayicon = TrayIcon() trayicon.set_menu([(None, _("_Manage desklets"), | self.__trayicon = TrayIcon() self.__trayicon.set_menu([(None, _("_Manage desklets"), | def __init__(self): |
if (self.__latest_version["major"] > self.__version["major"]) or \ (self.__latest_version["minor"] > self.__version["minor"]) or \ (self.__latest_version["development"] > self.__version["development"]): | if (self.__latest_version["major"], self.__latest_version["minor"], self.__latest_version["development"]) > \ (self.__version["major"], self.__version["minor"], self.__version["development"]): | def endElement(self, name): |
elif self.__latest_version["type"] != self.__version["type"]: | elif (self.__latest_version["major"], self.__latest_version["minor"], self.__latest_version["development"]) == \ (self.__version["major"], self.__version["minor"], self.__version["development"]): | def endElement(self, name): |
"<i>http://bugzilla.gnome.org</i>\n" | "<i>https://bugs.launchpad.net/gdesklets</i>\n" | def _check_version(): path = os.path.join(USERHOME, "registry", "version") try: version = open(path).read() except Exception: version = "old :)" try: open(path, "w").write(VERSION) except Exception: pass return (VERSION == version) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.