class Repository:
def __init__(self, section):
self.chat_db_config = self.read_db_config(section) # Open Database connection
self.logger = LogManager("chatApp")
# For general execution, just pass the query
def execute_query(self, query, params):
conn = MySQLdb.connect(self.chat_db_config['host'], self.chat_db_config['user'],
self.chat_db_config['password'], self.chat_db_config['database'])
cursor = conn.cursor()
try:
# Execute the SQL command
cursor.execute(query, params)
# Commit your changes in the database
conn.commit()
except Error as error:
conn.rollback()
self.logger.exception_log(error)
conn.close()
# A function with a yield return builds a generator object
def execute_select_generator(self, query):
conn = MySQLdb.connect(self.chat_db_config['host'], self.chat_db_config['user'],
self.chat_db_config['password'], self.chat_db_config['database'])
cursor = conn.cursor()
try:
cursor.execute(query)
results = cursor.fetchall()
for row in results:
yield row
except Exception.message, error:
self.logger.error_log("Error: unable to fetch data")
conn.close()
def __init__(self, config):
self.config = config
self.api = DB_API(self.config)
self.logger = LogManager(self.config)
self.cash_output = None
self.cash_command = None
self.cash_slot = None
def test(fm: FileManager):
with open(fm['config'], 'rb') as f:
cfg = pickle.load(f)
test_data = LoadDatasetManager(fm['test'],
dict_classes=cfg['classes']).get_dataset()
bm_test = BatchManager(test_data, cfg, StatusDatasets.Test)
res = Tester(cfg, bm_test, fm['model']).run()
LogManager.write_log(cfg, res, './logs/log.txt')
class ChatClearHistoryPlugin(IChatTask):
def __init__(self):
self.logger = LogManager("chatApp")
self.chat_message_repository = ChatMessageRepository()
def execute_task(self, under_num_days):
self.logger.debug_log('The clear history task should start soon')
self.chat_message_repository.delete_previous_message_execute(under_num_days)
def __init__(self, start_time=0, end_time=int(time.time())):
self.log_manager = LogManager(start_time, end_time)
self.ip_cache = ip_location_cache.ip_location_cache()
# for now, get from logs. maybe use aggregator to make these calls later?
self.servers = self.log_manager.get_unique_destinations()
self.uuid_metadata = {
} # dictionary mapping uuid -> metadata (includes state-ful data)
def live_event_change(log: LogManager, timestamp: datetime,
ch_onair: ProgrammeMetadata, ch_next: ProgrammeMetadata,
viewing_start: datetime):
stop = make_live_stop_event(timestamp, viewing_start, ch_onair,
(timestamp - viewing_start).seconds)
log.push_event(stop)
play = make_live_play_event(timestamp, ch_next)
log.push_event(play)
return ch_next
def __init__(self, out_dir, target_cpu, logs_dir): self._out_dir = out_dir self._target_cpu = target_cpu self._command_runner = None self._symbolizer_proc = None self._log_listener_proc = None self._dry_run = False self._started = False self._log_manager = LogManager(logs_dir) self._ffx_runner = ffx_session.FfxRunner(self._log_manager)
def __init__(self, graph, workspace, optim_info, mock=None):
self.node_versions = dict()
self.graph = graph
self.log_manager = LogManager()
self.workspace = workspace
self.mock = mock
self.local = not not mock
self.optim_info = optim_info
self.searcher = None
for node in graph:
self.node_versions[node.node_name] = []
def __init__(self, out_dir, target_cpu, logs_dir):
self._out_dir = out_dir
self._target_cpu = target_cpu
self._command_runner = None
self._symbolizer_proc = None
self._log_listener_proc = None
self._dry_run = False
self._started = False
self._ffx_path = os.path.join(common.SDK_ROOT, 'tools',
common.GetHostArchFromPlatform(), 'ffx')
self._log_manager = LogManager(logs_dir)
def __init__(self, path):
# path that script will run
self.path = path
# flag to enable debug messages
# if this flag "True", any file is renamed
self.debug_mode = True
# flag to enable log messages
self.log_mode = True
# object logs instances
self.logger_duplicate = LogManager.instance().getLoggerDuplicateFile
# list of files supported:
self.images_list = ["jpg", "png"]
self.video_list = ["mp4", "avi"]
# total folders renamed by script
self.total_folders = 0
# total files renamed by script
self.total_files_renamed = 0
# total duplicated files save in log folder
self.total_duplicated_files = 0
# total of files analyzed based on "self.images_list" and "self.video_list"
self.total_files = 0
# files that already renamed and not to do with its
self.total_files_ok = 0
def compare_dates(self, trashed_file_dict):
"""
Function to compare file deletionTime with currentTime
"""
date_format = '%Y-%m-%d %H:%M:%S'
deletion_date = trashed_file_dict["deletionDate"]
filename = trashed_file_dict["filename"]
filename = os.path.basename(filename)
# file deletion date
deletion_date = deletion_date.replace("T", " ")
deletion_datetime = datetime.strptime(deletion_date, date_format)
# current time
current_time_string = datetime.now().strftime(date_format)
current_datetime = datetime.strptime(current_time_string, date_format)
difference_in_days = (current_datetime - deletion_datetime).days
real_filename = f"{self.home}/.local/share/Trash/files/{filename}"
size = os.path.getsize(real_filename)
if difference_in_days >= 30:
# remove_files(filename)
logger = LogManager.instance().getLogger
logger.info(filename)
return size
return None
def notification(self, deleted_files):
"""
Function to send notification in the end of script execution
"""
notification_title = os.path.basename(__file__)
files = deleted_files["Files"]
size = deleted_files["Size"]
notification_description = f"{files} Arquivos removidos: {size} Liberados"
notification_icon = f"{os.path.dirname(os.path.abspath(__file__))}/python-logo-64px.png"
command = f"/usr/bin/notify-send \"{notification_title}\" \"{notification_description}\" --icon={notification_icon}"
if files != None:
os.system(command)
LogManager.instance().log_clean()
def __init__(self, config, training_manager, sess, batch_tensor_val):
""" If we want to visualize the outputs """
#terminal_draw_tool.start_curses()
#terminal_draw_tool.curses_started = True
self._batch_size = config.batch_size
self._training_manager = training_manager
self._sess = sess # the session from tensorflow that is going to be used
self._config = config
self._training_start_time = time.time()
self._logger = LogManager(config, training_manager, sess,
self._config.use_curses)
self.tensorboard_scalars()
self.tensorboard_images()
self._merged = tf.summary.merge_all()
self._validater = ValidationManager(config, training_manager, sess,
batch_tensor_val, self._merged)
self.first_time = True
self.store_steer = True
def setup(cls, msg_num=1, rate=1):
task_usdeur_logger_config = LoggerConfig("TASK_USDEUR", 2)
task_usdeur_connector_config = ConnectorConfig("KAFKA_CONNECTOR", "USDEUR")
task_gbpusd_logger_config = LoggerConfig("TASK_GBPUSD", 2)
task_gbpusd_connector_config = ConnectorConfig("KAFKA_CONNECTOR", "GBPUSD")
cls.__log_manager = LogManager([(task_usdeur_logger_config, task_usdeur_connector_config),
(task_gbpusd_logger_config, task_gbpusd_connector_config)],
msg_num, rate)
return cls
def flush(self):
"""Write the buffer to file."""
if not self.written_catalog:
LogManager(self.folder).register(self.filename, 'csv', self.name)
self.written_catalog = True
if not os.path.exists(self.filename):
mode = 'w'
else:
mode = 'a'
with open(self.filename, mode) as f:
f.write(''.join(self.buffer))
self.buffer = []
def setup(cls, msg_num=1, rate=1):
task_usage_logger_config = LoggerConfig("TASK_USAGE", 2)
task_usage_connector_config = ConnectorConfig("KAFKA_CONNECTOR",
"TASK-USAGE")
task_event_logger_config = LoggerConfig("TASK_EVENT", 2)
task_event_connector_config = ConnectorConfig("KAFKA_CONNECTOR",
"TASK-EVENT")
cls.__log_manager = LogManager(
[(task_usage_logger_config, task_usage_connector_config),
(task_event_logger_config, task_event_connector_config)], msg_num,
rate)
return cls
def main():
# load in our configuration settings
config = Config()
if config.config_file is None:
print 'BuildAgent config file not found; skipping step.'
return
generator = DeltaGenerator(config, LogManager(config))
result = generator.run()
if result and len(generator.error_message):
print generator.error_message
return 0
def build_summary(self, summary_files):
"""
Function to build summary
"""
total_size = 0
DECIMAL = 2
deleted_files = {"Files":None, "Size": None}
# get total files
total_files = len(summary_files)
for index in range(total_files):
# get total size in bytes
total_size += summary_files[index]
# KB
total_size = round(total_size/1024, DECIMAL)
unit = "KB"
# MB
if total_size > 1024:
total_size = round(total_size/1024, DECIMAL)
unit = "MB"
# GB
if total_size > 1024:
total_size = round(total_size/1024, DECIMAL)
unit = "GB"
if total_files != 0:
logger_summary = LogManager.instance().getLoggerSummary
logger_summary.info(f"Files: {total_files}")
logger_summary.info(f"Size: {total_size} {unit}")
deleted_files["Files"] = total_files
deleted_files["Size"] = f"{total_size} {unit}"
return deleted_files
def register(self):
self._registered = True
LogManager(os.path.dirname(self._fname)).register(
self._fname, self._typ, self._name)
def register(self):
if not self.registered:
LogManager(self.folder).register(self.filename, 'image', self.name)
self._registered = True
pass
def trickmode_viewing(m: LogManager):
timestamp = datetime.utcnow()
m.clear_state(timestamp)
context = device_context(timestamp)
context.rcu_version = "** SCENARIO: TRICKMODE VIEWING **"
m.push_event(context)
player = PageViewEvent(timestamp, 'player')
m.push_event(player)
viewing_start = timestamp
f8d_events = request_channel_events('F8D')
event = find_event_on_air(timestamp, f8d_events)
view_1 = make_live_play_event(timestamp, event)
m.push_event(view_1)
offset = (timestamp - event.start_time).seconds
remaining_duration = event.duration.seconds - offset
offset += int(remaining_duration / 2)
timestamp += timedelta(seconds=int(remaining_duration / 2))
stop = make_live_stop_event(timestamp, viewing_start, event, offset)
m.push_event(stop)
media = Media(content_type=ContentTypeType(
ContentTypeType.TUNER_SUB_TRICKMODE),
view_status=ViewStatusType(ViewStatusType.CAPTIONS),
booking_source=None,
event_source=None,
create_timestamp=timestamp,
duration=timestamp - viewing_start)
playback_pause = make_playback_event(timestamp, viewing_start, event,
media, offset, 0)
m.push_event(playback_pause)
pause_duration = timedelta(minutes=15)
timestamp += pause_duration
media.duration += pause_duration
playback_play = make_playback_event(timestamp, viewing_start, event, media,
offset, 1000)
m.push_event(playback_play)
timestamp += pause_duration
media.duration += pause_duration
pvr_stop = make_pvr_stop_event(
timestamp, viewing_start, event, media, event.duration.seconds,
(event.duration - (viewing_start - event.start_time)).seconds)
m.push_event(pvr_stop)
"""
import datetime
import json
import os
import sys
import requests
from lxml import html
from selenium import webdriver
from downloader import downloader
from log_manager import LogManager
from db.data_ops import DAO
logger = LogManager.getLogger('scraper')
# dao = DAO()
# Assuming `prev.json` is not in use by another process.
resources = os.path.join(
os.path.abspath(os.path.join(__file__, os.path.pardir)),
'resources'
)
prev_file = os.path.join(resources, 'prev.json')
with open(prev_file, 'r', encoding='utf-8') as f:
prev = json.load(f)
# prev = dao.get_to_be_downloaded()
logger.info("Loaded the want-to-download anime list")
home = os.path.expanduser("~")
logger.debug(script_stats)
db.scriptstats.save(script_stats)
return script_stats
def update_stats(script_stats):
script_stats['running_count'] = 0
script_stats['processed_requests'] = processed_requests
script_stats['last_completed_at'] = datetime.now().strftime(
'%A, %d. %B %Y %H:%M:%S')
db.scriptstats.save(script_stats)
if __name__ == '__main__':
endpoints = ['bloomington', 'baltimore', 'boston']
lm = LogManager()
logger = lm.logger
connection = Connection(os.environ['MONGO_URI'])
db = connection[os.environ['MONGO_DATABASE']]
while (True):
for endpoint in endpoints:
processed_requests = 0
script_stats = increment_running_count_in_stats()
logger.info('downloading requests from {0}...'.format(endpoint))
city = three.city(endpoint)
download_requests()
logger.info('setting geospatial index on loc field')
db.requests.ensure_index([("loc", GEO2D)])
mark_requests_with_boundaries()
update_stats(script_stats)
logger.debug('requests downloaded; sleeping for 1 hour')
def __init__(self):
super(Haedong, self).__init__()
self.log, self.res, self.err_log = LogManager.__call__().get_logger()
dir_name = os.path.join(cwd, 'ion_files')
try:
# Create ion files target Directory
os.mkdir(dir_name)
except FileExistsError:
# remove old ion files
files = os.path.join(dir_name, '*.10n')
for file in glob.glob(files):
os.unlink(file)
# remove old json files
files = os.path.join(dir_name, '*.json')
for file in glob.glob(files):
os.unlink(file)
manager = LogManager(sequence_counter=random.randint(1, 101) << 16,
max_events=100,
send_period=600,
path=dir_name)
manager.set_identity(
hw_version='17.27.0.C',
hw_id=bytes.fromhex('2b9c5d351a879a25b86851adc36acea6'),
hw_client_id='62081957540',
hw_card_id='000229047600',
ams_id=bytes.fromhex(
'026b45850456f79041d9fcf54b8fddf51ad41d8cd98f00b204e9800998ecf8427e'),
ams_panel=1,
app_version='1.16.1.9')
try:
manager.start()
power_states_activity(manager)
import sys
from clint.textui import progress
from lxml import html
import notify2
import requests
from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions
from selenium.webdriver.support.ui import WebDriverWait
from urllib.parse import unquote
from log_manager import LogManager
logger = LogManager.getLogger('downloader')
def get_embedded_video_links(gogoanime_episode_url):
"""
TODO:
When we are downloading a series,
Common url is:
http://www.gogoanime.com/battery-episode-3
But, some episodes will have urls like
http://www.gogoanime.com/battery-episode-3-episode-3
So, this function if it could not find videos
in the common url. It will go to previous page
if it exists and clicks <Next episode>.
Sometimes, <Next episode> leads to a `movie/special/ova/ona`
page, so it will skip those and gets the correct url.
def __init__(self):
self.logger = LogManager("chatApp")
self.chat_message_repository = ChatMessageRepository()
class OutputManager(object):
def __init__(self, config, training_manager, sess, batch_tensor_val):
""" If we want to visualize the outputs """
#terminal_draw_tool.start_curses()
#terminal_draw_tool.curses_started = True
self._batch_size = config.batch_size
self._training_manager = training_manager
self._sess = sess # the session from tensorflow that is going to be used
self._config = config
self._training_start_time = time.time()
self._logger = LogManager(config, training_manager, sess,
self._config.use_curses)
self.tensorboard_scalars()
self.tensorboard_images()
self._merged = tf.summary.merge_all()
self._validater = ValidationManager(config, training_manager, sess,
batch_tensor_val, self._merged)
self.first_time = True
self.store_steer = True
def tensorboard_scalars(self):
#with tf.device('/gpu:0'):
""" This is the program general loss """
tf.summary.scalar('Loss',
tf.reduce_mean(self._training_manager.get_loss()))
""" This is the loss energy vec """
energy_tensor_vec = convert_mat_to_tensor(
self._training_manager.get_variable_energy(),
self._config.branch_config)
print 'energy'
print energy_tensor_vec
for i in range(len(energy_tensor_vec)):
for j in range(len(
self._config.branch_config[i])): # for other branches
#print tf.squeeze(energy_tensor_vec[i +j])
tf.summary.scalar(
'Energy_B_' + str(i) + '_' +
self._config.branch_config[i][j],
tf.squeeze(energy_tensor_vec[i][j]))
print 'error'
variables_tensor_vec = convert_mat_to_tensor(
self._training_manager.get_variable_error(),
self._config.branch_config)
for i in range(len(variables_tensor_vec)):
for j in range(len(
self._config.branch_config[i])): # for other branches
#print tf.squeeze(variables_tensor_vec[i +j])
tf.summary.scalar(
'Error_B_' + str(i) + '_' +
self._config.branch_config[i][j],
tf.squeeze(variables_tensor_vec[i][j]))
""" This is the error vecs for the training """
self._train_writer = tf.summary.FileWriter(
self._config.train_path_write, self._sess.graph)
def tensorboard_images(self):
tf.summary.image('Image_input', self._training_manager._input_images)
#tf.summary.image('Image_vbp',self._training_manager._vis_images)
def write_tensorboard_summary(self, i):
feedDict = self._training_manager.get_feed_dict()
feedDict[self._training_manager._dout] = [1.0] * len(
self._config.dropout)
summary = self._sess.run(self._merged, feed_dict=feedDict)
self._train_writer.add_summary(summary, i)
def print_outputs(self, i, duration):
# the dictonary of the data used for training
if i % self._config.print_interval == 0:
self._logger.update_log_state(i, duration)
""" Writing summary """
if i % self._config.summary_writing_period == 0 or self.first_time:
#print 'Summari'
self._logger.write_summary(i)
#self._logger.write_images()
self.write_tensorboard_summary(i)
#terminal_draw_tool.clear()
self.first_time = False
#self._sess.run(self._training_manager._vis_images,feed_dict=self._training_manager.get_feed_dict())
self._logger.print_screen_track(i, duration)
#""" Validating """
if i % self._config.validation_period == 0:
self._validater.run(i)
'''if self.store_steer == True:
def init_logger(self):
self.log, self.res, self.err_log = LogManager.__call__().get_logger()
configure_app(app)
extend_app(app)
with app.app_context():
from cache_manager import CacheManager
from data_manager import DataManager
from image_manager import ImageManager
from log_manager import LogManager
from permissions_manager import PermissionsManager
from stats_manager import StatsManager
from task_manager import TaskManager
# Create the logging client+server
logger = LogManager(
__about__.__tag__.lower() + '_' + str(os.getpid()),
app.config['DEBUG'],
app.config['LOGGING_SERVER'],
app.config['LOGGING_SERVER_PORT']
)
app.log = logger
LogManager.run_server(
app.config['LOGGING_SERVER'],
app.config['LOGGING_SERVER_PORT'],
__about__.__tag__.lower() + '.log',
app.config['DEBUG']
)
# Capture Flask's internal logging
app.logger.addHandler(logger.logging_handler)
# Announce startup
logger.info(__about__.__title__ + ' v' + __about__.__version__ + ' engine startup')
logger.info('Using settings ' + app.config['_SETTINGS_IN_USE'])
class DM:
def __init__(self, config):
self.config = config
self.api = DB_API(self.config)
self.logger = LogManager(self.config)
self.cash_output = None
self.cash_command = None
self.cash_slot = None
def get_recommendation(self, slot, target, type='passive'):
'''
slot: dict
key: genre ジャンル
key: person 人名
key: sort_by 並び替え条件(eva_gt/eval_lt/eval_eq/day_gt/day_lt/day_eq)
key: history 他にフラグ
'''
# DBのmainテーブルから映画情報を取得
if slot['genre'] is not None and slot['person'] is None:
df = self.api.search_movie_by_genre(slot['genre'])
elif slot['person'] is not None and slot['genre'] is None:
pid = self.api.person2id(slot['person'])
df = self.api.search_movie_by_crew(pid)
elif slot['genre'] is not None and slot['person'] is not None:
pid = self.api.person2id(slot['person'])
df_genre = self.api.search_movie_by_genre(slot['genre'])
df_person = self.api.search_movie_by_crew(pid)
df = pd.merge(df_genre, df_person)
else:
df = self.api.search_movie()
# 取得した映画群を条件でソート
if slot['sort_by'] == 'eval_gt' or slot[
'sort_by'] == 'eval_lt' or slot['sort_by'] == 'eval_eq':
# 一定の投票数以下の作品は除く
df = df[df['vote'] > self.config['DM']['vote_min']]
# 履歴の参照
used_mid_list = self.logger.get_topic_history()
prev_mid = used_mid_list[-1]
prev_score = self.api.get_evaluation(prev_mid)
if slot['sort_by'] == 'eval_gt':
df = df.sort_values('evaluation', ascending=False)
df = df[df['evaluation'] > prev_score]
elif slot['sort_by'] == 'eval_lt':
df = df.sort_values('evaluation', ascending=True)
df = df[df['evaluation'] < prev_score]
else:
df = df.sort_values('evaluation', ascending=False)
df = df[(df['evaluation'] > prev_score - 1)]
df = df[(df['evaluation'] < prev_score + 1)]
else:
print("#############")
df = df.dropna(subset=['pronunciation'])
df = df.sort_values('popularity', ascending=False)
if slot['history']:
N = int(self.config['DM']['N'])
df = df[:N]
# 履歴の参照
used_mid_list = self.logger.get_intoduced_mid_list()
df = df[~df['movie_id'].isin(used_mid_list)]
if len(df) > 0:
# ランダムに選ぶ
info = df.sample()
pron = info['pronunciation'].iloc[0]
if pron is not None:
topic = pron
else:
topic = info['title'].iloc[0]
mid = info['movie_id'].iloc[0]
else:
topic = ''
mid = None
pron = None
gid = slot['genre']
if gid is None:
genre = None
else:
genre = self.api.id2genre(gid)
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=str(mid),
command='recommendation',
type=type)
id = self.logger.write(data_dict, slot, [topic])
output = {'topic': topic, 'mid': mid, 'pron': pron, 'genre': genre}
return output, id
def get_cast(self, slot, target, type='passive'):
'''
slot: dict
key: title 映画タイトル
key: history 他にフラグ
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
job_id = self.config['DM']['job_id_cast']
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
cast_list = self.api.get_crew(mid, job_id)['name_ja'].tolist()
if cast_list[0] is None:
cast_list = self.api.get_crew(mid, job_id)['name_en'].tolist()
# 話題に上がっていない場合
else:
df = self.api.search_movie_by_title('title')
if len(df) > 0:
movie_info = df.iloc[0]
mid = movie_info['movie_id']
cast_list = self.api.get_crew(mid, job_id)['name_ja'].tolist()
if cast_list[0] is None:
cast_list = self.api.get_crew(mid,
job_id)['name_en'].tolist()
else:
cast_list = []
mid = -1
# history=Trueなら履歴を参照する
N = int(self.config['DM']['cast_num'])
if slot['history']:
introduced_cast_list = self.logger.get_intoduced_list('cast', mid)
cnt = 0
cast_list_new = []
for cast in cast_list:
if cast not in introduced_cast_list:
cast_list_new.append(cast)
cnt += 1
if cnt >= N:
break
if len(cast_list) > len(introduced_cast_list) + N:
state = 1
else:
state = 0
else:
cast_list_new = cast_list[:N]
if len(cast_list) > N:
state = 1
else:
state = 0
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='cast',
state=state,
type=type)
id = self.logger.write(data_dict, slot, cast_list_new)
output = {
'person_list': cast_list_new,
'topic': title,
'mid': mid,
'history': slot['history']
}
return output, id
def get_director(self, slot, target, type='passive'):
'''
slot: dict
key: title 映画タイトル
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
job_id = self.config['DM']['job_id_director']
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
director_list = self.api.get_crew(mid, job_id)['name_ja'].tolist()
if director_list[0] is None:
director_list = self.api.get_crew(mid,
job_id)['name_en'].tolist()
# 話題に上がっていない場合
else:
df = self.api.search_movie_by_title('title')
if len(df) > 0:
movie_info = df.iloc[0]
mid = movie_info['movie_id']
director_list = self.api.get_crew(mid,
job_id)['name_ja'].tolist()
if director_list[0] is None:
director_list = self.api.get_crew(
mid, job_id)['name_en'].tolist()
else:
director_list = []
mid = -1
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='director',
type=type)
id = self.logger.write(data_dict, slot, director_list)
output = {'person_list': director_list, 'topic': title, 'mid': mid}
return output, id
def get_cast_detail(self, slot, target, type='passive'):
'''
slot: dict
key: person 人物名
key: history 他にフラグ
'''
pid = self.api.person2id(slot['person'])
if pid is not None:
df = self.api.get_credit(pid)
topic_list = df['title'].tolist()
pron_list = df['pron'].tolist()
N = int(self.config['DM']['cast_detail_num'])
if slot['history']:
introduced_cast_detail_list = self.logger.get_intoduced_list(
'cast_detail', pid)
cnt = 0
topic_list_new = []
for i in range(len(topic_list)):
if pron_list[i] is not None:
topic = pron_list[i]
else:
topic = topic_list[i]
if topic not in introduced_cast_detail_list:
topic_list_new.append(topic)
cnt += 1
if cnt >= N:
break
if len(topic_list) > len(introduced_cast_detail_list) + N:
state = 1
else:
state = 0
else:
topic_list_new = topic_list[:N]
if len(topic_list) > N:
state = 1
else:
state = 0
else:
topic_list_new = []
state = 0
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=pid,
command='cast_detail',
state=state,
type=type)
id = self.logger.write(data_dict, slot, topic_list_new)
topic = self.logger.get_topic_title()
mid = self.logger.get_topic_mid()
output = {'cast_detail': topic_list_new, 'topic': topic, 'mid': mid}
print(output)
return output, id
def get_director_detail(self, slot, target, type='passive'):
'''
slot: dict
key: person 人物名
key: history 他にフラグ
'''
pid = self.api.person2id(slot['person'])
if pid is not None:
df = self.api.get_credit(pid)
topic_list = df['title'].tolist()
N = int(self.config['DM']['director_detail_num'])
if slot['history']:
introduced_director_detail_list = self.logger.get_intoduced_list(
'director_detail', pid)
cnt = 0
topic_list_new = []
for topic in topic_list:
if topic not in introduced_director_detail_list:
topic_list_new.append(topic)
cnt += 1
if cnt >= N:
break
if len(topic_list) > len(introduced_director_detail_list) + N:
state = 1
else:
state = 0
else:
topic_list_new = topic_list[:N]
if len(topic_list) > N:
state = 1
else:
state = 0
else:
topic_list_new = []
state = 0
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=pid,
command='director_detail',
state=state,
type=type)
id = self.logger.write(data_dict, slot, topic_list_new)
topic = self.logger.get_topic_title()
mid = self.logger.get_topic_mid()
output = {
'director_detail': topic_list_new,
'topic': topic,
'mid': mid
}
return output, id
def get_tips(self, slot, target, type='passive'):
'''
slot: dict
key: title 映画タイトル
key: tag 情報の種類 ex. overview/series
key: history 他にフラグ
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
df_tips = self.api.get_tips(mid)
if slot['tag'] is not None:
tip_list = df_tips[df_tips['tag'] ==
slot['tag']]['tips'].tolist()
else:
tip_list = df_tips['tips'].tolist()
# 話題に上がっていない場合
else:
df = self.api.search_movie_by_title('title')
if len(df) > 0:
movie_info = df.iloc[0]
mid = movie_info['movie_id']
df_tips = self.api.get_tips(mid)
if slot['tag'] is not None:
tip_list = df_tips[df_tips['tag'] ==
slot['tag']]['tips'].tolist()
else:
tip_list = df_tips['tips'].tolist()
else:
df_tips = pd.DataFrame({})
tip_list = []
mid = -1
# history=Trueなら履歴を参照する
if slot['history']:
introduced_tips_list = self.logger.get_intoduced_list('tips', mid)
output = None
for tip in tip_list:
if tip not in introduced_tips_list:
output = tip
break
if len(df_tips) > len(introduced_tips_list) + 1:
state = 1
else:
state = 0
else:
if len(df_tips) > 1:
state = 1
output = tip_list[0]
elif len(df_tips) == 1:
state = 0
output = tip_list[0]
else:
state = 0
output = None
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='tips',
state=state,
type=type)
id = self.logger.write(data_dict, slot, [output])
output = {'tips': output, 'topic': title, 'mid': mid}
return output, id
def get_review(self, slot, target, type='passive'):
'''
slot: dict
key: title 映画タイトル
key: history 他にフラグ
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
review_list = self.api.get_review(mid)['review'].tolist()
# 話題に上がっていない場合
else:
df = self.api.search_movie_by_title('title')
if len(df) > 0:
movie_info = df.iloc[0]
mid = movie_info['movie_id']
review_list = self.api.get_tips(mid)['review'].tolist()
else:
review_list = []
mid = -1
# history=Trueなら履歴を参照する
if slot['history']:
introduced_review_list = self.logger.get_intoduced_list(
'review', mid)
output = None
for review in review_list:
if review not in introduced_review_list:
output = review
break
if len(review_list) > len(introduced_review_list) + 1:
state = 1
else:
state = 0
else:
if len(review_list) > 1:
state = 1
output = review_list[0]
elif len(review_list) == 1:
state = 0
output = review_list[0]
else:
state = 0
output = None
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='review',
state=state,
type=type)
id = self.logger.write(data_dict, slot, [output])
output = {'review': output, 'topic': title, 'mid': mid}
return output, id
def get_evaluation(self, slot, target, type='passive'):
'''
slot: dict
key: title 映画タイトル
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
df = self.api.search_movie_by_id(mid)
if len(df) > 0:
assert len(df) == 1, '1 id has multiple movies mid: {}'.format(
mid)
score = df['evaluation'].iloc[0]
else:
score = None
mid = -1
# 話題に上がっていない場合
else:
df = self.api.search_movie_by_title('title')
if len(df) > 0:
assert len(
df) == 1, '1 title has multiple movies mid: {}'.format(
title)
score = df['evaluation']
else:
score = None
mid = -1
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='evaluation',
type=type)
id = self.logger.write(data_dict, slot, [score])
output = {'evaluation': score, 'topic': title, 'mid': mid}
return output, id
def get_genres(self, slot, target, type='passive'):
'''
slot: dict
key: title 映画タイトル
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
genre_list = self.api.get_genre(mid)['genre_id'].tolist()
# 話題に上がっていない場合
else:
df = self.api.search_movie_by_title('title')
if len(df) > 0:
movie_info = df.iloc[0]
mid = movie_info['movie_id']
genre_list = self.api.get_genre(mid)['genre_id'].tolist()
else:
genre_list = []
mid = -1
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='genre',
type=type)
id = self.logger.write(data_dict, slot, genre_list)
genres = [self.api.id2genre(gid) for gid in genre_list]
output = {'genres': genres, 'topic': title, 'mid': mid}
return output, id
def get_question(self, slot, target, type='active'):
'''
slot: dict
key: title 映画タイトル
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
# 話題に上がっていない場合
else:
mid = None
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='question',
type=type)
id = self.logger.write(data_dict, slot, [])
output = {'topic': title, 'mid': mid}
return output, id
def get_title(self, slot, target, type='correcrion'):
'''
slot: dict
key: title 映画タイトル
'''
title = slot['title']
title_list = self.logger.get_topic_history()
mid_list = self.logger.get_mid_history()
# すでに話題に上がっている場合
if title in title_list:
mid = mid_list[title_list.index(title)]
# 話題に上がっていない場合
else:
mid = None
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='title',
type=type)
id = self.logger.write(data_dict, slot, [])
output = {'topic': title, 'mid': mid}
return output, id
def get_repeat(self, slot, target, type='correction'):
'''
slot: dict
key:
'''
mid_list = self.logger.get_mid_history()
if len(mid_list) > 0:
mid = mid_list[-1]
else:
mid = None
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
topic=mid,
command='repeat',
type=type)
id = self.logger.write(data_dict, slot, [])
output = self.cash_output
output["command"] = self.cash_command
output["slot"] = self.cash_slot
return output, id
def main(self, command, slot, target, type='passive'):
'''
DB, 対話履歴を参照してNLGに渡す情報を決定
条件に応じた発話を生成
Parameters
------------
command: str
命令 ex.recommend, person, overview
slot: dict
命令の引数 ex. recommend->{"genre": _, "actor": _, "director": _}
------------
commandの種類
1. recommend slot: {"genre": _, "person": _"sort_by":_, "history":_}, "それでは、{topic}はどうでしょう？"
2. cast slot: {"title": _, "job": _, "history":_}, "{person}が出演しています"
3. director slot: {"title": _, "job": _}, "監督は{person}です"
4. cast_detail slot: {"person_name", "history":_}, "~や~に出演しています"
5. director_detail slot: {"person_name", "history":_}, "~や~を手掛けています"
6. tips slot: {"title": _, "history":_}, "XXのシリーズY作目の映画です"
7. review slot: {"title": _, "history":_}, "~だったって"
8. evaluation slot: {"title": _}, "評価はが{score}点だよ"
9. genre slot: {"title": _}, "{genre}だよ"
10. detail_active slot: None, 2,3,7~10から選ぶ
11. pardon slot: None, "もう一回言ってもらえますか？"
12. unknown slot: None, "ちょっとわからないなぁ"
13.start slot: None, "どんな映画が観たいですか？"
14.end slot: None, "行ってらっしゃい"
15.yes slot: None, "はい、そうです"
16.no slot: None, "違います"
17.question slot: None, "XXは興味ありますか？"
18.sumarize slot: NONE, "観に行く映画は決まりましたか？"
'''
# commandを履歴に保存
if 'recommendation' in command:
output, id = self.get_recommendation(slot, target, type)
elif command == 'cast':
output, id = self.get_cast(slot, target, type)
elif command == 'director':
output, id = self.get_director(slot, target, type)
elif command == 'cast_detail':
output, id = self.get_cast_detail(slot, target, type)
elif command == 'director_detail':
output, id = self.get_director_detail(slot, target, type)
elif command == 'tips':
output, id = self.get_tips(slot, target, type)
elif command == 'review':
output, id = self.get_review(slot, target, type)
elif command == 'evaluation':
output, id = self.get_evaluation(slot, target, type)
elif command == 'genre':
output, id = self.get_genres(slot, target, type)
elif command == 'question':
output, id = self.get_question(slot, target, type)
elif command == 'title':
output, id = self.get_title(slot, target, type)
elif command == 'repeat':
output, id = self.get_repeat(slot, target, type)
elif command in ["yes", "no", "unknown", "start", "end", "summarize"]:
# 対話履歴をセット
data_dict = self.logger.get_main_data_dict()
data_dict.update(action='utter',
target=target,
command=command,
type=type)
id = self.logger.write(data_dict, slot, [])
output = {}
else:
id = None
output = {}
self.cash_output = output
self.cash_command = command
self.cash_slot = slot
return output, id
def __init__(self, section):
self.chat_db_config = self.read_db_config(section) # Open Database connection
self.logger = LogManager("chatApp")
same time
"""
import datetime
import json
import os
import sys
import requests
from lxml import html
from selenium import webdriver
from downloader import downloader
from log_manager import LogManager
from db.data_ops import DAO
logger = LogManager.getLogger('scraper')
# dao = DAO()
# Assuming `prev.json` is not in use by another process.
resources = os.path.join(
os.path.abspath(os.path.join(__file__, os.path.pardir)), 'resources')
prev_file = os.path.join(resources, 'prev.json')
with open(prev_file, 'r', encoding='utf-8') as f:
prev = json.load(f)
# prev = dao.get_to_be_downloaded()
logger.info("Loaded the want-to-download anime list")
home = os.path.expanduser("~")
driver = webdriver.Chrome(os.path.join(home, 'locallib/chromedriver'))
driver.maximize_window()
import os
import hashlib
import requests
import socket
from requests.exceptions import RequestException, Timeout
from pymongo import Connection
from config import MONGO, UPDATE_NUM, REQUEST_TIMEOUT
from torrentparser import TorrentParser, ParsingError
from log_manager import LogManager
# TOOD single file
mongo = Connection(host=MONGO['host'], port=MONGO['port'])
db = mongo[MONGO['db']]
logger = LogManager("application.log")
# TODO implement it in C
tp = TorrentParser.get_instance()
#parse torrent file
def parse_torrent_file(file):
try:
tp.parse_torrent(file)
return {
"name": tp.get_torrent_name(),
"file_list": tp.get_files_details(),
"creation_date": tp.get_creation_date(),
"tracker_url": tp.get_tracker_url(),
"client_name": tp.get_client_name(),
def power_states_activity(m: LogManager):
timestamp = datetime.utcnow()
m.clear_state(timestamp)
context = device_context(timestamp)
context.rcu_version = "** SCENARIO: POWER STATES **"
m.push_event(context)
power_on = PowerStatusEvent(timestamp, PowerStateType.POWER_ON, False)
m.push_event(power_on)
timestamp += timedelta(seconds=1)
display_on = VideoOutputEvent(timestamp, True, '', '1.x', '1.x', '1080i',
'50', '2b9c5d351a879a25b86851adc36acea6')
m.push_event(display_on)
timestamp += timedelta(seconds=1)
player = PageViewEvent(timestamp, 'player')
m.push_event(player)
timestamp += timedelta(seconds=1)
viewing_start = timestamp
viewing_dur = 60
event = get_live_event()
view_1 = make_live_play_event(timestamp, event)
m.push_event(view_1)
timestamp += timedelta(seconds=viewing_dur)
stop_1 = make_live_stop_event(timestamp, viewing_start, event, viewing_dur)
m.push_event(stop_1)
standby = PageViewEvent(timestamp, 'standby')
m.push_event(standby)
power_standby = PowerStatusEvent(timestamp, PowerStateType.STANDBY, True)
m.push_event(power_standby)
display_off = VideoOutputEvent(timestamp, False)
m.push_event(display_off)
timestamp += timedelta(hours=8)
active = PowerStatusEvent(timestamp, PowerStateType.ACTIVE, True)
m.push_event(active)
timestamp += timedelta(seconds=1)
display_on.timestamp = timestamp
m.push_event(display_on)
timestamp += timedelta(seconds=1)
player.timestamp = timestamp
m.push_event(player)
def channel_surfing(m: LogManager):
timestamp = datetime.utcnow()
m.clear_state(timestamp)
context = device_context(timestamp)
context.rcu_version = "** SCENARIO: CHANNEL SURFING **"
m.push_event(context)
player = PageViewEvent(timestamp, 'player')
m.push_event(player)
viewing_start = timestamp
f8d_events = request_channel_events('F8D')
shc_events = request_channel_events('SHC')
sha_events = request_channel_events('SHA')
event = find_event_on_air(timestamp, f8d_events)
view_1 = make_live_play_event(timestamp, event)
m.push_event(view_1)
timestamp = event.start_time + event.duration
event = live_event_change(m, timestamp, event,
find_event_on_air(timestamp, f8d_events),
viewing_start)
viewing_start = timestamp
timestamp += timedelta(seconds=90)
mini_guide = PageViewEvent(timestamp, 'miniGuide')
m.push_event(mini_guide)
timestamp += timedelta(seconds=5)
event = live_event_change(m, timestamp, event,
find_event_on_air(timestamp, shc_events),
viewing_start)
viewing_start = timestamp
timestamp += timedelta(seconds=5)
live_event_change(m, timestamp, event,
find_event_on_air(timestamp, sha_events), viewing_start)
timestamp += timedelta(seconds=5)
player = PageViewEvent(timestamp, 'player')
m.push_event(player)
from clint.textui import progress
from lxml import html
import notify2
import requests
from selenium import webdriver
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions
from selenium.webdriver.support.ui import WebDriverWait
from urllib.parse import unquote
from log_manager import LogManager
logger = LogManager.getLogger('downloader')
def get_embedded_video_links(gogoanime_episode_url):
"""
TODO:
When we are downloading a series,
Common url is:
http://www.gogoanime.com/battery-episode-3
But, some episodes will have urls like
http://www.gogoanime.com/battery-episode-3-episode-3
So, this function if it could not find videos
in the common url. It will go to previous page
if it exists and clicks <Next episode>.
Sometimes, <Next episode> leads to a `movie/special/ova/ona`
page, so it will skip those and gets the correct url.
class Target(object):
"""Base class representing a Fuchsia deployment target."""
def __init__(self, out_dir, target_cpu, logs_dir):
self._out_dir = out_dir
self._target_cpu = target_cpu
self._command_runner = None
self._symbolizer_proc = None
self._log_listener_proc = None
self._dry_run = False
self._started = False
self._log_manager = LogManager(logs_dir)
self._ffx_runner = ffx_session.FfxRunner(self._log_manager)
@staticmethod
def CreateFromArgs(args):
raise NotImplementedError()
@staticmethod
def RegisterArgs(arg_parser):
pass
# Functions used by the Python context manager for teardown.
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
try:
self.Stop()
finally:
# Stop the ffx daemon, since the target device is going / has gone away.
# This ensures that the daemon does not become "hung" if the target device
# stops responding to network I/O (e.g., due to emulator instance
# teardown). The daemon will be automatically restarted by the next `ffx`
# call.
self._ffx_runner.daemon_stop()
# Stop the log manager only after the last use of _ffx_runner.
self._log_manager.Stop()
def Start(self):
"""Handles the instantiation and connection process for the Fuchsia
target instance."""
raise NotImplementedError()
def IsStarted(self):
"""Returns True if the Fuchsia target instance is ready to accept
commands."""
return self._started
def GetFfxTarget(self):
"""Returns the FfxTarget instance to use to interact with this target."""
raise NotImplementedError()
def Stop(self):
"""Stop all subprocesses and close log streams."""
if self._symbolizer_proc:
self._symbolizer_proc.kill()
if self._log_listener_proc:
self._log_listener_proc.kill()
def IsNewInstance(self):
"""Returns True if the connected target instance is newly provisioned."""
return True
def GetCommandRunner(self):
"""Returns CommandRunner that can be used to execute commands on the
target. Most clients should prefer RunCommandPiped() and RunCommand()."""
self._AssertIsStarted()
if self._command_runner is None:
host, port = self._GetEndpoint()
self._command_runner = \
remote_cmd.CommandRunner(self._GetSshConfigPath(), host, port)
return self._command_runner
def StartSystemLog(self, package_paths):
"""Start a system log reader as a long-running SSH task."""
system_log = self._log_manager.Open('system_log')
if package_paths:
self._log_listener_proc = self.RunCommandPiped(['log_listener'],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
self._symbolizer_proc = RunSymbolizer(self._log_listener_proc.stdout,
system_log,
BuildIdsPaths(package_paths))
else:
self._log_listener_proc = self.RunCommandPiped(['log_listener'],
stdout=system_log,
stderr=subprocess.STDOUT)
def RunCommandPiped(self, command, **kwargs):
"""Starts a remote command and immediately returns a Popen object for the
command. The caller may interact with the streams, inspect the status code,
wait on command termination, etc.
command: A list of strings representing the command and arguments.
kwargs: A dictionary of parameters to be passed to subprocess.Popen().
The parameters can be used to override stdin and stdout, for
example.
Returns: a Popen object.
Note: method does not block.
"""
logging.debug('running (non-blocking) \'%s\'.', ' '.join(command))
return self.GetCommandRunner().RunCommandPiped(command, **kwargs)
def RunCommand(self, command, silent=False, timeout_secs=None):
"""Executes a remote command and waits for it to finish executing.
Returns the exit code of the command.
"""
logging.debug('running \'%s\'.', ' '.join(command))
return self.GetCommandRunner().RunCommand(command, silent,
timeout_secs=timeout_secs)
def EnsureIsolatedPathsExist(self, for_package, for_realms):
"""Ensures that the package's isolated /data and /tmp exist."""
for isolated_directory in ['/data', '/tmp']:
self.RunCommand([
'mkdir', '-p',
_MapIsolatedPathsForPackage(for_package, 0,
for_realms)(isolated_directory)
])
def PutFile(self,
source,
dest,
recursive=False,
for_package=None,
for_realms=()):
"""Copies a file from the local filesystem to the target filesystem.
source: The path of the file being copied.
dest: The path on the remote filesystem which will be copied to.
recursive: If true, performs a recursive copy.
for_package: If specified, isolated paths in the |dest| are mapped to their
obsolute paths for the package, on the target. This currently
affects the /data and /tmp directories.
for_realms: If specified, identifies the sub-realm of 'sys' under which
isolated paths (see |for_package|) are stored.
"""
assert type(source) is str
self.PutFiles([source], dest, recursive, for_package, for_realms)
def PutFiles(self,
sources,
dest,
recursive=False,
for_package=None,
for_realms=()):
"""Copies files from the local filesystem to the target filesystem.
sources: List of local file paths to copy from, or a single path.
dest: The path on the remote filesystem which will be copied to.
recursive: If true, performs a recursive copy.
for_package: If specified, /data in the |dest| is mapped to the package's
isolated /data location.
for_realms: If specified, identifies the sub-realm of 'sys' under which
isolated paths (see |for_package|) are stored.
"""
assert type(sources) is tuple or type(sources) is list
if for_package:
self.EnsureIsolatedPathsExist(for_package, for_realms)
dest = _MapIsolatedPathsForPackage(for_package, 0, for_realms)(dest)
logging.debug('copy local:%s => remote:%s', sources, dest)
self.GetCommandRunner().RunScp(sources, dest, remote_cmd.COPY_TO_TARGET,
recursive)
def GetFile(self,
source,
dest,
for_package=None,
for_realms=(),
recursive=False):
"""Copies a file from the target filesystem to the local filesystem.
source: The path of the file being copied.
dest: The path on the local filesystem which will be copied to.
for_package: If specified, /data in paths in |sources| is mapped to the
package's isolated /data location.
for_realms: If specified, identifies the sub-realm of 'sys' under which
isolated paths (see |for_package|) are stored.
recursive: If true, performs a recursive copy.
"""
assert type(source) is str
self.GetFiles([source], dest, for_package, for_realms, recursive)
def GetFiles(self,
sources,
dest,
for_package=None,
for_realms=(),
recursive=False):
"""Copies files from the target filesystem to the local filesystem.
sources: List of remote file paths to copy.
dest: The path on the local filesystem which will be copied to.
for_package: If specified, /data in paths in |sources| is mapped to the
package's isolated /data location.
for_realms: If specified, identifies the sub-realm of 'sys' under which
isolated paths (see |for_package|) are stored.
recursive: If true, performs a recursive copy.
"""
assert type(sources) is tuple or type(sources) is list
self._AssertIsStarted()
if for_package:
sources = map(_MapIsolatedPathsForPackage(for_package, 0, for_realms),
sources)
logging.debug('copy remote:%s => local:%s', sources, dest)
return self.GetCommandRunner().RunScp(sources, dest,
remote_cmd.COPY_FROM_TARGET,
recursive)
def GetFileAsString(self, source):
"""Reads a file on the device and returns it as a string.
source: The remote file path to read.
"""
cat_proc = self.RunCommandPiped(['cat', source],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
stdout, _ = cat_proc.communicate()
if cat_proc.returncode != 0:
raise Exception('Could not read file %s on device.', source)
return stdout.decode('utf-8')
def _GetEndpoint(self):
"""Returns a (host, port) tuple for the SSH connection to the target."""
raise NotImplementedError()
def _GetTargetSdkArch(self):
"""Returns the Fuchsia SDK architecture name for the target CPU."""
if self._target_cpu == 'arm64' or self._target_cpu == 'x64':
return self._target_cpu
raise FuchsiaTargetException('Unknown target_cpu:' + self._target_cpu)
def _AssertIsStarted(self):
assert self.IsStarted()
def _ConnectToTarget(self):
logging.info('Connecting to Fuchsia using SSH.')
host, port = self._GetEndpoint()
end_time = time.time() + common.ATTACH_RETRY_SECONDS
ssh_diagnostic_log = self._log_manager.Open('ssh_diagnostic_log')
while time.time() < end_time:
runner = remote_cmd.CommandRunner(self._GetSshConfigPath(), host, port)
ssh_proc = runner.RunCommandPiped(['true'],
ssh_args=['-v'],
stdout=ssh_diagnostic_log,
stderr=subprocess.STDOUT)
if ssh_proc.wait() == 0:
logging.info('Connected!')
self._started = True
self._command_runner = runner
return True
time.sleep(_ATTACH_RETRY_INTERVAL)
logging.error('Timeout limit reached.')
raise FuchsiaTargetException('Couldn\'t connect using SSH.')
def _DisconnectFromTarget(self):
pass
def _GetSshConfigPath(self, path):
raise NotImplementedError()
def GetPkgRepo(self):
"""Returns an PkgRepo instance which serves packages for this Target.
Callers should typically call GetPkgRepo() in a |with| statement, and
install and execute commands inside the |with| block, so that the returned
PkgRepo can teardown correctly, if necessary.
"""
raise NotImplementedError()
def InstallPackage(self, package_paths):
"""Installs a package and it's dependencies on the device. If the package is
already installed then it will be updated to the new version.
package_paths: Paths to the .far files to install.
"""
with self.GetPkgRepo() as pkg_repo:
# Publish all packages to the serving TUF repository under |tuf_root|.
for package_path in package_paths:
pkg_repo.PublishPackage(package_path)
# Resolve all packages, to have them pulled into the device/VM cache.
for package_path in package_paths:
package_name, package_version = _GetPackageInfo(package_path)
logging.info('Installing %s...', package_name)
return_code = self.RunCommand(
['pkgctl', 'resolve',
_GetPackageUri(package_name), '>/dev/null'],
timeout_secs=_INSTALL_TIMEOUT_SECS)
if return_code != 0:
raise Exception(
'Error {} while resolving {}.'.format(return_code, package_name))
# Verify that the newly resolved versions of packages are reported.
for package_path in package_paths:
# Use pkgctl get-hash to determine which version will be resolved.
package_name, package_version = _GetPackageInfo(package_path)
pkgctl = self.RunCommandPiped(
['pkgctl', 'get-hash',
_GetPackageUri(package_name)],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
pkgctl_out, pkgctl_err = pkgctl.communicate()
# Read the expected version from the meta.far Merkel hash file alongside
# the package's FAR.
meta_far_path = os.path.join(os.path.dirname(package_path), 'meta.far')
meta_far_merkel = subprocess.check_output(
[common.GetHostToolPathFromPlatform('merkleroot'),
meta_far_path]).split()[0]
if pkgctl_out != meta_far_merkel:
raise Exception('Hash mismatch for %s after resolve (%s vs %s).' %
(package_name, pkgctl_out, meta_far_merkel))
def RunFFXCommand(self, ffx_args):
"""Automatically gets the FFX path and runs FFX based on the
arguments provided.
Args:
ffx_args: The arguments for a ffx command.
Returns:
A Popen object for the command.
"""
return self._ffx_runner.open_ffx(ffx_args)