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
