def test_cmp_datetime_DateTime(self): now = datetime.datetime.now() dt = xmlrpclib.DateTime(now.timetuple()) self.assertTrue(dt == now) self.assertTrue(now == dt) then = now + datetime.timedelta(seconds=4) self.assertTrue(then >= dt) self.assertTrue(dt < then)
def xmlrpc_getPageInfoVersion(self, pagename, rev): """ Return page information for specific revision @param pagename: the name of the page (utf-8) @param rev: revision to get info about (int) @rtype: dict @return: page information * name (string): the canonical page name, UTF-8. * lastModified (date): Last modification date, UTC. * author (string): author name, UTF-8. * version (int): current version """ pn = self._instr(pagename) # User may read this page? if not self.request.user.may.read(pn): return self.notAllowedFault() if rev is not None: page = Page(self.request, pn, rev=rev) else: page = Page(self.request, pn) rev = page.current_rev() # Non existing page? if not page.exists(): return self.noSuchPageFault() # Get page info edit_info = page.edit_info() if not edit_info: return self.noLogEntryFault() mtime = wikiutil.version2timestamp(long( edit_info['timestamp'])) # must be long for py 2.2.x gmtuple = tuple(time.gmtime(mtime)) version = rev # our new rev numbers: 1,2,3,4,.... ####################################################################### # BACKWARDS COMPATIBILITY CODE - remove when 1.2.x is regarded stone age # as we run a feed for BadContent on MoinMaster, we want to stay # compatible here for a while with 1.2.x moins asking us for BadContent # 1.3 uses the lastModified field for checking for updates, so it # should be no problem putting the old UNIX timestamp style of version # number in the version field if self.request.cfg.sitename == 'MoinMaster' and pagename == 'BadContent': version = int(mtime) ####################################################################### return { 'name': self._outstr(page.page_name), 'lastModified': xmlrpclib.DateTime(gmtuple), 'author': self._outstr(edit_info['editor']), 'version': version, }
def test_dto_not_comparable_instances(self): dt = xmlrpclib.DateTime() # DateTime throws exception when doing: # dt == {} # for instance dto = mapper.dto_generator({"foo": dt}) dt2 = mapper.load_from_dto(dto) self.assertEquals(["foo"], dt2.keys()) self.assertEquals(dt.value, dt2["foo"].value)
def test_bug_1164912 (self): d = xmlrpclib.DateTime() ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,), methodresponse=True)) self.assertIsInstance(new_d.value, str) # Check that the output of dumps() is still an 8-bit string s = xmlrpclib.dumps((new_d,), methodresponse=True) self.assertIsInstance(s, str)
def write_post_to_wordpress(summary,title,keywords): date_now=str(datetime.datetime.today())[:-10] date_created = xmlrpclib.DateTime(datetime.datetime.strptime(str(date_now), "%Y-%m-%d %H:%M")) categories = [country_now] data = {'title': title, 'description': summary, 'dateCreated': str(date_created), 'categories': categories, 'mt_keywords': keywords} if os.path.exists("posts")==False: os.makedirs("posts") json.dump(data, open(".\\posts\\content.json",'a+')) #post_id = server.metaWeblog.newPost(wp_blogid, wp_username, wp_password, data, status_published) print "Posts created",title
def test_schedule_package_install(self): installable = client.system.listLatestInstallablePackages( self.session_key, SERVER_ID) install_these = [] for pkg in installable[0:3]: install_these.append(pkg['package_id']) earliest = datetime.now() + timedelta(3) # 3 days from now dt = xmlrpclib.DateTime(earliest.timetuple()) client.system.schedulePackageInstall(self.session_key, SERVER_ID, install_these, dt)
def test_datetimeRoundtrip(self): """ If an L{xmlrpclib.DateTime} is passed as an argument to an XML-RPC call and then returned by the server unmodified, the result should be equal to the original object. """ when = xmlrpclib.DateTime() d = self.proxy().callRemote("echo", when) d.addCallback(self.assertEqual, when) return d
def test_datetime_before_1900(self): # same as before but with a date before 1900 dt = datetime.datetime(1, 02, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) self.assertEqual(newdt, dt) self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) self.assertEqual(newdt, xmlrpclib.DateTime('00010210T11:41:23'))
def __init__(self): self.posts = [{ "dateCreated": xmlrpclib.DateTime(time.time()), "userid": c.userID, "postid": '3', "content": "Third post!" }, { "dateCreated": xmlrpclib.DateTime(time.time()), "userid": c.userID, "postid": '2', "content": "Second post!" }, { "dateCreated": xmlrpclib.DateTime(time.time()), "userid": c.userID, "postid": '1', "content": "First post!" }] self.template = copy.deepcopy(c.template) self.nextPostID = len(self.posts) + 1
def _save_post(self, namespace, method_name, args, post, publish, post_type): # FIXME: does permaLink do anything here?? Doesn't seem so, but wp_slug might blogContent = {} # print post; # for now, the pages use this if namespace == 'wp': blogContent = { 'post_type' : post_type, 'post_title' : post.title, 'post_content' : post.description, # 'permaLink' : post.permaLink, 'ping_status' : 'closed', 'post_excerpt' : post.excerpt, 'post_parent' : post.parent_id or 0, # 'terms' : {}, # 'terms_names' : {'category':self._marshal_categories_names(post.categories)}, # 'mt_keywords': self._marshal_tags_names(post.tags), # 'categories' : self._marshal_categories_names(post.categories), } if publish: blogContent['post_status'] = 'publish' # print blogContent else: blogContent = { 'title' : post.title, 'description' : post.description, 'permaLink' : post.permaLink, 'mt_allow_pings' : post.allowPings, 'mt_text_more' : post.textMore, 'mt_excerpt' : post.excerpt, 'mt_keywords': self._marshal_tags_names(post.tags), 'categories' : self._marshal_categories_names(post.categories), } # print blogContent if post.date: blogContent['date_created_gmt'] = xmlrpclib.DateTime(post.date) print "Back-converting dateCreated:", post.date, blogContent['date_created_gmt'] # Get remote method: e.g. self._server.metaWeblog.editPost ns = getattr(self._server, namespace) meth = getattr(ns, method_name) if namespace=='wp' and method_name=='editPost': # ghetto hack! result = meth(*([args[0]]+[self.user, self.password, int(args[1]), blogContent])) else: # call remote method: arg0 is blogId for newPost, postId for editPost result = meth(*(args+[self.user, self.password, blogContent, int(publish)])) return result
def prepareupdate(key, servers): """Update servers""" servers_ids = [] already_up2date = [] for s in servers: id = servers[s][0] pids, pnames = checkforupdates(key, id) if (pids) and (pnames): servers[s].append(pids) servers[s].append(pnames) servers_ids.append(id) else: already_up2date.append(s) print "Server " + str(s) + " is up to date." for up2date_server in already_up2date: servers.pop(up2date_server) if len(servers_ids) > 0: today = datetime.today() earliest_occurrence = xmlrpclib.DateTime(today) #Workaround for com.redhat.rhn.common.translation.TranslationException: Could not find translator for class redstone.xmlrpc.XmlRpcArray to class java.lang.Integer try: script_aid = client.system.scheduleScriptRun( key, servers_ids, "root", "root", 300, nogpg_install, earliest_occurrence) if script_aid: print("Executing a pre-update script...") sleep(60) else: print("Failed to run a pre-update script.") print("Quiting...") sys.exit(-1) except Exception: for sid in servers_ids: if (client.system.scheduleScriptRun(key, sid, "root", "root", 300, nogpg_install, earliest_occurrence)): print("Executing a pre-update script...") else: print "Failed to run a pre-update script for server with id " + str( sid) print("Quiting...") sys.exit(-1) for s in servers.keys(): print("Updating " + s + "...") aid = doupdate(key, servers[s]) servers[s].append(aid) postcheck(key, servers) else: print "All systems are up to date." sys.exit(1)
def xmlrpc_getRecentChanges(self, date): """ Get RecentChanges since date @param date: date since when rc will be listed @rtype: list @return: a list of changed pages since date, which should be in UTC. The result is a list, where each element is a struct: * name (string) : Name of the page. The name is in UTF-8. * lastModified (date) : Date of last modification, in UTC. * author (string) : Name of the author (if available). UTF-8. * version (int) : Current version. """ return_items = [] edit_log = editlog.EditLog(self.request) for log in edit_log.reverse(): # get last-modified UTC (DateTime) from log gmtuple = tuple( time.gmtime(wikiutil.version2timestamp(log.ed_time_usecs))) lastModified_date = xmlrpclib.DateTime(gmtuple) # skip if older than "date" if lastModified_date < date: break # skip if knowledge not permitted if not self.request.user.may.read(log.pagename): continue # get page name (str) from log pagename_str = self._outstr(log.pagename) # get user name (str) from log author_str = log.hostname if log.userid: userdata = user.User(self.request, log.userid) if userdata.name: author_str = userdata.name author_str = self._outstr(author_str) return_item = { 'name': pagename_str, 'lastModified': lastModified_date, 'author': author_str, 'version': int(log.rev) } return_items.append(return_item) return return_items
def blogger_getRecentPosts(request, appkey, blogid, username, password, numberOfPosts=5): """ Get recent posts from a blog tree """ authenticate(request, username, password) config = request.getConfiguration() data = request.getData() from Pyblosxom.entries.fileentry import FileEntry from Pyblosxom import pyblosxom exts = tools.run_callback("entryparser", {'txt': pyblosxom.blosxom_entry_parser}, mappingfunc=lambda x, y: y, defaultfunc=lambda x: x) data['extensions'] = exts result = [] dataList = [] filelist = tools.Walk(request, os.path.join(config['datadir'], blogid[1:]), pattern=re.compile(r'.*\.(' + '|'.join(exts.keys()) + ')-?$'), recurse=1) for ourfile in filelist: entry = FileEntry(request, ourfile, config['datadir']) dataList.append((entry._mtime, entry)) # this sorts entries by mtime in reverse order. entries that have # no mtime get sorted to the top. dataList.sort() dataList.reverse() dataList = [x[1] for x in dataList] count = 1 for entry in dataList: result.append({ 'dateCreated': xmlrpclib.DateTime(entry['mtime']), 'userid': '01', 'postid': entry['filename'].replace(config['datadir'], ''), 'content': open(entry['filename']).read() }) if count >= int(numberOfPosts): break count += 1 return result
def test_schedule_script_run(self): script = \ """ #!/bin/sh cat /proc/cpuinfo """ earliest = datetime.now() + timedelta(3) # 3 days dt = xmlrpclib.DateTime(earliest.timetuple()) script_id = client.system.scheduleScriptRun(self.session_key, SERVER_ID, 'root', 'root', 600, script, dt)
def format_file_results(row, server=None): encoding = '' checksum = row['checksum'] or '' is_binary = row['is_binary'] == 'Y' raw_contents = rhnSQL.read_lob(row['file_contents']) if is_binary: contents = raw_contents else: contents = rhnSQL._fix_encoding(raw_contents or '') if server and not is_binary and contents: interpolator = ServerTemplatedDocument(server, start_delim=row['delim_start'], end_delim=row['delim_end']) contents = interpolator.interpolate(contents) if row['checksum_type']: checksummer = hashlib.new(row['checksum_type']) checksummer.update(contents.encode()) checksum = checksummer.hexdigest() if contents: client_caps = rhnCapability.get_client_capabilities() if client_caps and 'configfiles.base64_enc' in client_caps: encoding = 'base64' if is_binary: contents = contents else: contents = contents.encode() contents = base64.encodestring(contents).decode() if row.get('modified', False): m_date = xmlrpclib.DateTime(str(row['modified'])) else: m_date = '' return { 'path': row['path'], 'config_channel': row['config_channel'], 'file_contents': contents, 'symlink': row['symlink'] or '', 'checksum_type': row['checksum_type'] or '', 'checksum': checksum, 'verify_contents': True, 'delim_start': row['delim_start'] or '', 'delim_end': row['delim_end'] or '', 'revision': row['revision'] or '', 'username': row['username'] or '', 'groupname': row['groupname'] or '', 'filemode': row['filemode'] or '', 'encoding': encoding or '', 'filetype': row['label'], 'selinux_ctx': row['selinux_ctx'] or '', 'modified': m_date, 'is_binary': row['is_binary'] or '', }
def encodeDate(self, datestr = None): """ returns an xmlrpclib.DateTime object for all those methods that require one. Defaults to current date/time if this is not provided. """ if datestr is not None: try: time.strptime(datestr, '%Y%m%dT%H:%M:%S') return xmlrpclib.DateTime(datestr) except ValueError, E: return self.fail(E, 'encode date. Error: %s' % E.args[0])
def processCommandLine(): if not options.satellite: options.satellite = os.uname()[1] if not options.delete and not options.list and not options.long_list: sys.stderr.write( "Must include a command options (--list, --long-list, --delete)\n") sys.exit(1) if not options.all and not options.system_id and not options.snapshot_id: sys.stderr.write( "Must include one of the required parameters (--all, --system-id or --snapshot-id\n" ) sys.exit(1) if options.snapshot_id and (options.start_date or options.end_date): sys.stderr.write( "--start-date and --end-date options do not apply when specifying --snapshot-id\n" ) sys.exit(1) if options.end_date and not options.start_date: sys.stderr.write("--end-date must be used with --start-date.\n") sys.exit(1) if options.list and options.long_list: sys.stderr.write( "-l (--list) and -L (--long-list) are mutually exclusive.\n") sys.exit(1) # convert the start / end dates to a format that usable by the xmlrpc api if options.start_date: options.start_date = datetime( *(strptime(options.start_date, "%Y%m%d%H%M%S")[0:6])) options.start_date = xmlrpclib.DateTime(options.start_date.timetuple()) if options.end_date: options.end_date = datetime( *(strptime(options.end_date, "%Y%m%d%H%M%S")[0:6])) options.end_date = xmlrpclib.DateTime(options.end_date.timetuple())
def _wrap_obj(self, obj): """Wraps some values in something older XMLRPC versions can handle.""" if isinstance(obj, (tuple, list)): return map(self._wrap_obj, obj) if isinstance(obj, dict): return dict((k, self._wrap_obj(v)) for k, v in obj.iteritems()) if isinstance(obj, datetime): return xmlrpclib.DateTime(obj.timetuple()) # make sure we can send translated strings over the wire. if isinstance(obj, _TranslationProxy): return unicode(obj) return obj
def test_dump_bare_date(self): # This checks that an unwrapped datetime.date object can be handled # by the marshalling code. This can't be done via test_dump_load() # since the unmarshaller produces a datetime object d = datetime.datetime(2005, 02, 10, 11, 41, 23).date() s = xmlrpclib.dumps((d, )) (newd, ), m = xmlrpclib.loads(s, use_datetime=1) self.assertEquals(newd.date(), d) self.assertEquals(newd.time(), datetime.time(0, 0, 0)) self.assertEquals(m, None) (newdt, ), m = xmlrpclib.loads(s, use_datetime=0) self.assertEquals(newdt, xmlrpclib.DateTime('20050210T00:00:00'))
def test_dump_bare_datetime(self): # This checks that an unwrapped datetime.date object can be handled # by the marshalling code. This can't be done via test_dump_load() # since with use_datetime set to 1 the unmarshaller would create # datetime objects for the 'datetime[123]' keys as well dt = datetime.datetime(2005, 02, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) self.assertEqual(newdt, dt) self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) self.assertEqual(newdt, xmlrpclib.DateTime('20050210T11:41:23'))
def send(self): """Send traffic deltas to trafficstore.""" if not self.savedcounters: return try: self.directory.store_traffic( xmlrpclib.DateTime(time.time()), list(self._convert_savedcounters_to_xmlrpc())) self.savedcounters.clear() except (socket.error, xmlrpclib.Error), e: if hasattr(e, 'url'): # Strip out passwords e.url = re.sub(r'^.*@', '', e.url) raise e
def test_dump_bare_time(self): # This checks that an unwrapped datetime.time object can be handled # by the marshalling code. This can't be done via test_dump_load() # since the unmarshaller produces a datetime object t = datetime.datetime(2005, 02, 10, 11, 41, 23).time() s = xmlrpclib.dumps((t, )) (newt, ), m = xmlrpclib.loads(s, use_datetime=1) today = datetime.datetime.now().date().strftime("%Y%m%d") self.assertEquals(newt.time(), t) self.assertEquals(newt.date(), datetime.datetime.now().date()) self.assertEquals(m, None) (newdt, ), m = xmlrpclib.loads(s, use_datetime=0) self.assertEquals(newdt, xmlrpclib.DateTime('%sT11:41:23' % today))
def testParamState(master, myState): callerId = 'master' #validate from root for (k, v) in myState.iteritems(): if HAS_PARAM: assert apiSuccess(master.hasParam(callerId, k)) print "verifying parameter %s"%k v2 = apiSuccess(master.getParam(callerId, k)) if isinstance(v2, xmlrpclib.DateTime): assert xmlrpclib.DateTime(v) == v2, "[%s]: %s != %s, %s"%(k, v, v2, v2.__class__) else: assert v == v2, "[%s]: %s != %s, %s"%(k, v, v2, v2.__class__) paramNames = myState.keys() remoteParamNames = apiSuccess(master.getParamNames(callerId)) assert not set(paramNames) ^ set(remoteParamNames), "parameter server keys do not match local"
def repost(self, blogid, postid, content, publish): rpcServer = xmlrpclib.ServerProxy(self.endpoint) # Sanitize time for xmlrpc transport if needed. if isinstance(content['dateCreated'], xmlrpclib.DateTime) == False: content['dateCreated'] = xmlrpclib.DateTime(content['dateCreated']) try: repost = rpcServer.metaWeblog.editPost(postid, self.username, self.password, content, publish) except Exception, e: raise Exception, str(e)
def getWorkHourChangeTimes(self, req, id): """Returns a list of changetimes""" #時間関連のフィールドが変更された時間の一覧を返します. db = self.env.get_db_cnx() cursor = db.cursor() if id == 0: sql="SELECT DISTINCT time FROM ticket_change WHERE (field='totalhours' OR field='estimatedhours' OR field='baseline_cost') ORDER BY time" else: sql="SELECT DISTINCT time FROM ticket_change WHERE (field='totalhours' OR field='estimatedhours' OR field='baseline_cost') AND ticket='%s' ORDER BY time" % id cursor.execute(sql) result = [] for row in cursor: #result.append(row[0]) result.append(xmlrpclib.DateTime(datetime.datetime.fromtimestamp(row[0]))) return result
def test_sync_to_system(self): packages_to_sync = [232, 260] diff = client.system.comparePackages(self.session_key, SERVER_ID_2, SERVER_ID) for pnid in packages_to_sync: found = False for d in diff: if d['package_name_id'] == pnid: found = True break self.assertTrue(found) earliest = datetime.now() + timedelta(3) # 3 days from now dt = xmlrpclib.DateTime(earliest.timetuple()) client.system.scheduleSyncPackagesWithSystem(self.session_key, SERVER_ID_2, SERVER_ID, packages_to_sync, dt)
def repost(self, blogid, postID, content, publish): rpcServer = xmlrpclib.ServerProxy(self.endpoint) if content['dateCreated']: if isinstance(content['dateCreated'], xmlrpclib.DateTime) == False: content['dateCreated'] = xmlrpclib.DateTime( content['dateCreated']) try: result = rpcServer.blogger.editPost(self.appkey, postID, self.username, self.password, content['content'], publish) except Exception, e: raise Exception, str(e)
def createPostWithCats(self, blogid, content, publish, cats): rpcServer = xmlrpclib.ServerProxy(self.endpoint) # Sanitize time for xmlrpc transport if needed. if content['dateCreated']: if isinstance(content['dateCreated'], xmlrpclib.DateTime) == False: content['dateCreated'] = xmlrpclib.DateTime(content['dateCreated']) try: post = rpcServer.metaWeblog.newPost(blogid, self.username, self.password, content, content['publish']) rpcServer.mt.setPostCategories(post, self.username, self.password, cats) except Exception, e: raise Exception, str(e)
def newPost(self, post, publish): """Insert new post """ blogContent = { 'title': post.title, 'description': post.description, 'mt_keywords': post.tags } # Use provided date, if provided... if post.date: blogContent['dateCreated'] = xmlrpclib.DateTime(post.date) # add categories i = 0 categories = [] for cat in post.categories: if i == 0: categories.append({ 'categoryName': cat, 'isPrimary': True, 'categoryId': self.getCategoryIdFromName(str(cat)) }) else: categories.append({ 'categoryName': cat, 'isPrimary': False, 'categoryId': self.getCategoryIdFromName(str(cat)) }) i += 1 # insert new post idNewPost = int( self._server.metaWeblog.newPost(self.blogId, self.user, self.password, blogContent, True)) print categories # set categories for new post self.setPostCategories(idNewPost, categories) print idNewPost return idNewPost
def do_newPost(self, doc): appkey, blogID, username, password, content = map( text, doc.all("string")) if blogID <> c.blogID: self._err(self.noPerms) if (username <> c.username) or (password <> c.password): self._err(self.authFailed % username) postID = str(self.nextPostID) self.nextPostID += 1 self.posts.insert( 0, { "dateCreated": xmlrpclib.DateTime(time.time()), "userid": c.userID, "postid": postID, "content": content }) return postID