file_name
large_stringlengths 4
140
| prefix
large_stringlengths 0
12.1k
| suffix
large_stringlengths 0
12k
| middle
large_stringlengths 0
7.51k
| fim_type
large_stringclasses 4
values |
|---|---|---|---|---|
zplsc_c_echogram.py | 35
TVR = []
VTX = []
BP = []
EL = []
DS = []
# Freq 38kHz
TVR.append(1.691999969482e2)
VTX.append(1.533999938965e2)
BP.append(8.609999902546e-3)
EL.append(1.623000030518e2)
DS.append(2.280000038445e-2)
# Freq 125kHz
TVR.append(1.668999938965e2)
VTX.append(5.8e+01)
BP.append(1.530999969691e-2)
EL.append(1.376999969482e2)
DS.append(2.280000038445e-2)
# Freq 200kHz
TVR.append(1.688999938965e2)
VTX.append(9.619999694824e1)
BP.append(1.530999969691e-2)
EL.append(1.456000061035e2)
DS.append(2.250000089407e-2)
# Freq 455kHz
TVR.append(1.696000061035e2)
VTX.append(1.301000061035e2)
BP.append(8.609999902546e-3)
EL.append(1.491999969482e2)
DS.append(2.300000004470e-2)
class ZPLSCCPlot(object):
font_size_small = 14
font_size_large = 18
num_xticks = 25
num_yticks = 7
interplot_spacing = 0.1
lower_percentile = 5
upper_percentile = 95
def __init__(self, data_times, channel_data_dict, frequency_dict, depth_range, _min_db=None, _max_db=None):
self.fig = None
self.power_data_dict = self._transpose_and_flip(channel_data_dict)
if (_min_db is None) or (_max_db is None):
self.min_db, self.max_db = self._get_power_range(channel_data_dict)
else:
self.min_db = _min_db
self.max_db = _max_db
self.frequency_dict = frequency_dict
# convert ntp time, i.e. seconds since 1900-01-01 00:00:00 to matplotlib time
self.data_times = (data_times / (60 * 60 * 24)) + REF_TIME
max_depth, _ = self.power_data_dict[1].shape
self._setup_plot(depth_range, max_depth)
def generate_plots(self):
"""
Generate plots for all channels in data set
"""
freq_to_channel = {v: k for k, v in self.frequency_dict.iteritems()}
data_axes = None
for index, frequency in enumerate(sorted(freq_to_channel)):
channel = freq_to_channel[frequency]
td_f = self.frequency_dict[channel]
title = 'Volume Backscatter (Sv) :Channel #%d: Frequency: %.1f kHz' % (channel, td_f)
data_axes = self._generate_plot(self.ax[index], self.power_data_dict[channel], title,
self.min_db, self.max_db)
if data_axes:
self._display_x_labels(self.ax[2], self.data_times)
self.fig.tight_layout(rect=[0, 0.0, 0.97, 1.0])
self._display_colorbar(self.fig, data_axes)
def write_image(self, filename):
self.fig.savefig(filename)
plt.close(self.fig)
self.fig = None
def _setup_plot(self, depth_range, max_depth):
# subset the yticks so that we don't plot every one
yticks = np.linspace(0, max_depth, self.num_yticks)
# create range vector (depth in meters)
yticklabels = np.round(np.linspace(depth_range[0][-1], depth_range[0][0], self.num_yticks)).astype(int)
self.fig, self.ax = plt.subplots(len(self.frequency_dict), sharex=True, sharey=True)
self.fig.subplots_adjust(hspace=self.interplot_spacing)
self.fig.set_size_inches(40, 19)
for axes in self.ax:
axes.grid(False)
axes.set_ylabel('depth (m)', fontsize=self.font_size_small)
axes.set_yticks(yticks)
axes.set_yticklabels(yticklabels, fontsize=self.font_size_small)
axes.tick_params(axis="both", labelcolor="k", pad=4, direction='out', length=5, width=2)
axes.spines['top'].set_visible(False)
axes.spines['right'].set_visible(False)
axes.spines['bottom'].set_visible(False)
axes.spines['left'].set_visible(False)
@staticmethod
def _get_power_range(power_dict):
# Calculate the power data range across all channels
all_power_data = np.concatenate(power_dict.values())
max_db = np.nanpercentile(all_power_data, ZPLSCCPlot.upper_percentile)
min_db = np.nanpercentile(all_power_data, ZPLSCCPlot.lower_percentile)
return min_db, max_db
@staticmethod
def | (power_dict):
for channel in power_dict:
# Transpose array data so we have time on the x-axis and depth on the y-axis
power_dict[channel] = power_dict[channel].transpose()
# reverse the Y axis (so depth is measured from the surface (at the top) to the ZPLS (at the bottom)
power_dict[channel] = power_dict[channel][::-1]
return power_dict
@staticmethod
def _generate_plot(ax, power_data, title, min_db, max_db):
"""
Generate a ZPLS plot for an individual channel
:param ax: matplotlib axis to receive the plot image
:param power_data: Transducer data array
:param title: plot title
:param min_db: minimum power level
:param max_db: maximum power level
"""
# only generate plots for the transducers that have data
if power_data.size <= 0:
return
ax.set_title(title, fontsize=ZPLSCCPlot.font_size_large)
return imshow(ax, power_data, interpolation='none', aspect='auto', cmap='jet', vmin=min_db, vmax=max_db)
@staticmethod
def _display_x_labels(ax, data_times):
time_format = '%Y-%m-%d\n%H:%M:%S'
time_length = data_times.size
# X axis label
# subset the xticks so that we don't plot every one
if time_length < ZPLSCCPlot.num_xticks:
ZPLSCCPlot.num_xticks = time_length
xticks = np.linspace(0, time_length, ZPLSCCPlot.num_xticks)
xstep = int(round(xticks[1]))
# format trans_array_time array so that it can be used to label the x-axis
xticklabels = [i for i in num2date(data_times[::xstep])] + [num2date(data_times[-1])]
xticklabels = [i.strftime(time_format) for i in xticklabels]
# rotates and right aligns the x labels, and moves the bottom of the
# axes up to make room for them
ax.set_xlabel('time (UTC)', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels, rotation=45, horizontalalignment='center', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xlim(0, time_length)
@staticmethod
def _display_colorbar(fig, data_axes):
# Add a colorbar to the specified figure using the data from the given axes
ax = fig.add_axes([0.965, 0.12, 0.01, 0.775])
cb = fig.colorbar(data_axes, cax=ax, use_gridspec=True)
cb.set_label('dB', fontsize=ZPLSCCPlot.font_size_large)
cb.ax.tick_params(labelsize=ZPLSCCPlot.font_size_small)
class ZPLSCCEchogram(object):
def __init__(self):
self.cc = ZplscCCalibrationCoefficients()
self.params = ZplscCParameters()
def compute_backscatter(self, profile_hdr, chan_data, sound_speed, depth_range, sea_absorb | _transpose_and_flip | identifier_name |
zplsc_c_echogram.py | (1.696000061035e2)
VTX.append(1.301000061035e2)
BP.append(8.609999902546e-3)
EL.append(1.491999969482e2)
DS.append(2.300000004470e-2)
class ZPLSCCPlot(object):
font_size_small = 14
font_size_large = 18
num_xticks = 25
num_yticks = 7
interplot_spacing = 0.1
lower_percentile = 5
upper_percentile = 95
def __init__(self, data_times, channel_data_dict, frequency_dict, depth_range, _min_db=None, _max_db=None):
self.fig = None
self.power_data_dict = self._transpose_and_flip(channel_data_dict)
if (_min_db is None) or (_max_db is None):
self.min_db, self.max_db = self._get_power_range(channel_data_dict)
else:
self.min_db = _min_db
self.max_db = _max_db
self.frequency_dict = frequency_dict
# convert ntp time, i.e. seconds since 1900-01-01 00:00:00 to matplotlib time
self.data_times = (data_times / (60 * 60 * 24)) + REF_TIME
max_depth, _ = self.power_data_dict[1].shape
self._setup_plot(depth_range, max_depth)
def generate_plots(self):
"""
Generate plots for all channels in data set
"""
freq_to_channel = {v: k for k, v in self.frequency_dict.iteritems()}
data_axes = None
for index, frequency in enumerate(sorted(freq_to_channel)):
channel = freq_to_channel[frequency]
td_f = self.frequency_dict[channel]
title = 'Volume Backscatter (Sv) :Channel #%d: Frequency: %.1f kHz' % (channel, td_f)
data_axes = self._generate_plot(self.ax[index], self.power_data_dict[channel], title,
self.min_db, self.max_db)
if data_axes:
self._display_x_labels(self.ax[2], self.data_times)
self.fig.tight_layout(rect=[0, 0.0, 0.97, 1.0])
self._display_colorbar(self.fig, data_axes)
def write_image(self, filename):
self.fig.savefig(filename)
plt.close(self.fig)
self.fig = None
def _setup_plot(self, depth_range, max_depth):
# subset the yticks so that we don't plot every one
yticks = np.linspace(0, max_depth, self.num_yticks)
# create range vector (depth in meters)
yticklabels = np.round(np.linspace(depth_range[0][-1], depth_range[0][0], self.num_yticks)).astype(int)
self.fig, self.ax = plt.subplots(len(self.frequency_dict), sharex=True, sharey=True)
self.fig.subplots_adjust(hspace=self.interplot_spacing)
self.fig.set_size_inches(40, 19)
for axes in self.ax:
axes.grid(False)
axes.set_ylabel('depth (m)', fontsize=self.font_size_small)
axes.set_yticks(yticks)
axes.set_yticklabels(yticklabels, fontsize=self.font_size_small)
axes.tick_params(axis="both", labelcolor="k", pad=4, direction='out', length=5, width=2)
axes.spines['top'].set_visible(False)
axes.spines['right'].set_visible(False)
axes.spines['bottom'].set_visible(False)
axes.spines['left'].set_visible(False)
@staticmethod
def _get_power_range(power_dict):
# Calculate the power data range across all channels
all_power_data = np.concatenate(power_dict.values())
max_db = np.nanpercentile(all_power_data, ZPLSCCPlot.upper_percentile)
min_db = np.nanpercentile(all_power_data, ZPLSCCPlot.lower_percentile)
return min_db, max_db
@staticmethod
def _transpose_and_flip(power_dict):
for channel in power_dict:
# Transpose array data so we have time on the x-axis and depth on the y-axis
power_dict[channel] = power_dict[channel].transpose()
# reverse the Y axis (so depth is measured from the surface (at the top) to the ZPLS (at the bottom)
power_dict[channel] = power_dict[channel][::-1]
return power_dict
@staticmethod
def _generate_plot(ax, power_data, title, min_db, max_db):
"""
Generate a ZPLS plot for an individual channel
:param ax: matplotlib axis to receive the plot image
:param power_data: Transducer data array
:param title: plot title
:param min_db: minimum power level
:param max_db: maximum power level
"""
# only generate plots for the transducers that have data
if power_data.size <= 0:
return
ax.set_title(title, fontsize=ZPLSCCPlot.font_size_large)
return imshow(ax, power_data, interpolation='none', aspect='auto', cmap='jet', vmin=min_db, vmax=max_db)
@staticmethod
def _display_x_labels(ax, data_times):
time_format = '%Y-%m-%d\n%H:%M:%S'
time_length = data_times.size
# X axis label
# subset the xticks so that we don't plot every one
if time_length < ZPLSCCPlot.num_xticks:
ZPLSCCPlot.num_xticks = time_length
xticks = np.linspace(0, time_length, ZPLSCCPlot.num_xticks)
xstep = int(round(xticks[1]))
# format trans_array_time array so that it can be used to label the x-axis
xticklabels = [i for i in num2date(data_times[::xstep])] + [num2date(data_times[-1])]
xticklabels = [i.strftime(time_format) for i in xticklabels]
# rotates and right aligns the x labels, and moves the bottom of the
# axes up to make room for them
ax.set_xlabel('time (UTC)', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels, rotation=45, horizontalalignment='center', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xlim(0, time_length)
@staticmethod
def _display_colorbar(fig, data_axes):
# Add a colorbar to the specified figure using the data from the given axes
ax = fig.add_axes([0.965, 0.12, 0.01, 0.775])
cb = fig.colorbar(data_axes, cax=ax, use_gridspec=True)
cb.set_label('dB', fontsize=ZPLSCCPlot.font_size_large)
cb.ax.tick_params(labelsize=ZPLSCCPlot.font_size_small)
class ZPLSCCEchogram(object):
def __init__(self):
self.cc = ZplscCCalibrationCoefficients()
self.params = ZplscCParameters()
def compute_backscatter(self, profile_hdr, chan_data, sound_speed, depth_range, sea_absorb):
"""
Compute the backscatter volumes values for one zplsc_c profile data record.
This code was borrowed from ASL MatLab code that reads in zplsc-c raw data
and performs calculations in order to compute the backscatter volume in db.
:param profile_hdr: Raw profile header with metadata from the zplsc-c instrument.
:param chan_data: Raw frequency data from the zplsc-c instrument.
:param sound_speed: Speed of sound at based on speed of sound, pressure and salinity.
:param depth_range: Range of the depth of the measurements
:param sea_absorb: Seawater absorption coefficient for each frequency
:return: sv: Volume backscatter in db
"""
_N = []
if self.params.Bins2Avg > 1:
for chan in range(profile_hdr.num_channels):
el = self.cc.EL[chan] - 2.5/self.cc.DS[chan] + np.array(chan_data[chan])/(26214*self.cc.DS[chan])
power = 10**(el/10)
# Perform bin averaging
num_bins = len(chan_data[chan])/self.params.Bins2Avg
pwr_avg = []
for _bin in range(num_bins):
pwr_avg.append(np.mean(power[_bin*self.params.Bins2Avg:(_bin+1)*self.params.Bins2Avg]))
el_avg = 10*np.log10(pwr_avg)
_N.append(np.round(26214*self.cc.DS[chan]*(el_avg - self.cc.EL[chan] + 2.5/self.cc.DS[chan])))
else:
| for chan in range(profile_hdr.num_channels):
_N.append(np.array(chan_data[chan])) | conditional_block |
|
zplsc_c_echogram.py | 35
TVR = []
VTX = []
BP = []
EL = []
DS = []
# Freq 38kHz
TVR.append(1.691999969482e2)
VTX.append(1.533999938965e2)
BP.append(8.609999902546e-3)
EL.append(1.623000030518e2)
DS.append(2.280000038445e-2)
# Freq 125kHz
TVR.append(1.668999938965e2)
VTX.append(5.8e+01)
BP.append(1.530999969691e-2)
EL.append(1.376999969482e2)
DS.append(2.280000038445e-2)
# Freq 200kHz
TVR.append(1.688999938965e2)
VTX.append(9.619999694824e1)
BP.append(1.530999969691e-2)
EL.append(1.456000061035e2)
DS.append(2.250000089407e-2)
# Freq 455kHz
TVR.append(1.696000061035e2)
VTX.append(1.301000061035e2)
BP.append(8.609999902546e-3)
EL.append(1.491999969482e2)
DS.append(2.300000004470e-2)
class ZPLSCCPlot(object):
font_size_small = 14
font_size_large = 18
num_xticks = 25
num_yticks = 7
interplot_spacing = 0.1
lower_percentile = 5
upper_percentile = 95
def __init__(self, data_times, channel_data_dict, frequency_dict, depth_range, _min_db=None, _max_db=None):
self.fig = None
self.power_data_dict = self._transpose_and_flip(channel_data_dict)
if (_min_db is None) or (_max_db is None):
self.min_db, self.max_db = self._get_power_range(channel_data_dict)
else:
self.min_db = _min_db
self.max_db = _max_db
self.frequency_dict = frequency_dict
# convert ntp time, i.e. seconds since 1900-01-01 00:00:00 to matplotlib time
self.data_times = (data_times / (60 * 60 * 24)) + REF_TIME
max_depth, _ = self.power_data_dict[1].shape
self._setup_plot(depth_range, max_depth)
def generate_plots(self):
"""
Generate plots for all channels in data set
"""
freq_to_channel = {v: k for k, v in self.frequency_dict.iteritems()}
data_axes = None
for index, frequency in enumerate(sorted(freq_to_channel)):
channel = freq_to_channel[frequency]
td_f = self.frequency_dict[channel]
title = 'Volume Backscatter (Sv) :Channel #%d: Frequency: %.1f kHz' % (channel, td_f)
data_axes = self._generate_plot(self.ax[index], self.power_data_dict[channel], title,
self.min_db, self.max_db)
if data_axes:
self._display_x_labels(self.ax[2], self.data_times)
self.fig.tight_layout(rect=[0, 0.0, 0.97, 1.0])
self._display_colorbar(self.fig, data_axes)
def write_image(self, filename):
self.fig.savefig(filename)
plt.close(self.fig)
self.fig = None
def _setup_plot(self, depth_range, max_depth):
# subset the yticks so that we don't plot every one
yticks = np.linspace(0, max_depth, self.num_yticks)
# create range vector (depth in meters)
yticklabels = np.round(np.linspace(depth_range[0][-1], depth_range[0][0], self.num_yticks)).astype(int)
self.fig, self.ax = plt.subplots(len(self.frequency_dict), sharex=True, sharey=True)
self.fig.subplots_adjust(hspace=self.interplot_spacing)
self.fig.set_size_inches(40, 19)
for axes in self.ax:
axes.grid(False)
axes.set_ylabel('depth (m)', fontsize=self.font_size_small)
axes.set_yticks(yticks)
axes.set_yticklabels(yticklabels, fontsize=self.font_size_small)
axes.tick_params(axis="both", labelcolor="k", pad=4, direction='out', length=5, width=2)
axes.spines['top'].set_visible(False)
axes.spines['right'].set_visible(False)
axes.spines['bottom'].set_visible(False)
axes.spines['left'].set_visible(False)
@staticmethod
def _get_power_range(power_dict):
# Calculate the power data range across all channels
all_power_data = np.concatenate(power_dict.values())
max_db = np.nanpercentile(all_power_data, ZPLSCCPlot.upper_percentile)
min_db = np.nanpercentile(all_power_data, ZPLSCCPlot.lower_percentile)
return min_db, max_db
@staticmethod
def _transpose_and_flip(power_dict):
for channel in power_dict:
# Transpose array data so we have time on the x-axis and depth on the y-axis
power_dict[channel] = power_dict[channel].transpose()
# reverse the Y axis (so depth is measured from the surface (at the top) to the ZPLS (at the bottom)
power_dict[channel] = power_dict[channel][::-1]
return power_dict
@staticmethod
def _generate_plot(ax, power_data, title, min_db, max_db):
"""
Generate a ZPLS plot for an individual channel
:param ax: matplotlib axis to receive the plot image
:param power_data: Transducer data array
:param title: plot title
:param min_db: minimum power level
:param max_db: maximum power level
"""
# only generate plots for the transducers that have data
if power_data.size <= 0:
return
ax.set_title(title, fontsize=ZPLSCCPlot.font_size_large)
return imshow(ax, power_data, interpolation='none', aspect='auto', cmap='jet', vmin=min_db, vmax=max_db)
@staticmethod
def _display_x_labels(ax, data_times):
|
@staticmethod
def _display_colorbar(fig, data_axes):
# Add a colorbar to the specified figure using the data from the given axes
ax = fig.add_axes([0.965, 0.12, 0.01, 0.775])
cb = fig.colorbar(data_axes, cax=ax, use_gridspec=True)
cb.set_label('dB', fontsize=ZPLSCCPlot.font_size_large)
cb.ax.tick_params(labelsize=ZPLSCCPlot.font_size_small)
class ZPLSCCEchogram(object):
def __init__(self):
self.cc = ZplscCCalibrationCoefficients()
self.params = ZplscCParameters()
def compute_backscatter(self, profile_hdr, chan_data, sound_speed, depth_range, sea_absorb | time_format = '%Y-%m-%d\n%H:%M:%S'
time_length = data_times.size
# X axis label
# subset the xticks so that we don't plot every one
if time_length < ZPLSCCPlot.num_xticks:
ZPLSCCPlot.num_xticks = time_length
xticks = np.linspace(0, time_length, ZPLSCCPlot.num_xticks)
xstep = int(round(xticks[1]))
# format trans_array_time array so that it can be used to label the x-axis
xticklabels = [i for i in num2date(data_times[::xstep])] + [num2date(data_times[-1])]
xticklabels = [i.strftime(time_format) for i in xticklabels]
# rotates and right aligns the x labels, and moves the bottom of the
# axes up to make room for them
ax.set_xlabel('time (UTC)', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels, rotation=45, horizontalalignment='center', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xlim(0, time_length) | identifier_body |
zplsc_c_echogram.py | self.fig.tight_layout(rect=[0, 0.0, 0.97, 1.0])
self._display_colorbar(self.fig, data_axes)
def write_image(self, filename):
self.fig.savefig(filename)
plt.close(self.fig)
self.fig = None
def _setup_plot(self, depth_range, max_depth):
# subset the yticks so that we don't plot every one
yticks = np.linspace(0, max_depth, self.num_yticks)
# create range vector (depth in meters)
yticklabels = np.round(np.linspace(depth_range[0][-1], depth_range[0][0], self.num_yticks)).astype(int)
self.fig, self.ax = plt.subplots(len(self.frequency_dict), sharex=True, sharey=True)
self.fig.subplots_adjust(hspace=self.interplot_spacing)
self.fig.set_size_inches(40, 19)
for axes in self.ax:
axes.grid(False)
axes.set_ylabel('depth (m)', fontsize=self.font_size_small)
axes.set_yticks(yticks)
axes.set_yticklabels(yticklabels, fontsize=self.font_size_small)
axes.tick_params(axis="both", labelcolor="k", pad=4, direction='out', length=5, width=2)
axes.spines['top'].set_visible(False)
axes.spines['right'].set_visible(False)
axes.spines['bottom'].set_visible(False)
axes.spines['left'].set_visible(False)
@staticmethod
def _get_power_range(power_dict):
# Calculate the power data range across all channels
all_power_data = np.concatenate(power_dict.values())
max_db = np.nanpercentile(all_power_data, ZPLSCCPlot.upper_percentile)
min_db = np.nanpercentile(all_power_data, ZPLSCCPlot.lower_percentile)
return min_db, max_db
@staticmethod
def _transpose_and_flip(power_dict):
for channel in power_dict:
# Transpose array data so we have time on the x-axis and depth on the y-axis
power_dict[channel] = power_dict[channel].transpose()
# reverse the Y axis (so depth is measured from the surface (at the top) to the ZPLS (at the bottom)
power_dict[channel] = power_dict[channel][::-1]
return power_dict
@staticmethod
def _generate_plot(ax, power_data, title, min_db, max_db):
"""
Generate a ZPLS plot for an individual channel
:param ax: matplotlib axis to receive the plot image
:param power_data: Transducer data array
:param title: plot title
:param min_db: minimum power level
:param max_db: maximum power level
"""
# only generate plots for the transducers that have data
if power_data.size <= 0:
return
ax.set_title(title, fontsize=ZPLSCCPlot.font_size_large)
return imshow(ax, power_data, interpolation='none', aspect='auto', cmap='jet', vmin=min_db, vmax=max_db)
@staticmethod
def _display_x_labels(ax, data_times):
time_format = '%Y-%m-%d\n%H:%M:%S'
time_length = data_times.size
# X axis label
# subset the xticks so that we don't plot every one
if time_length < ZPLSCCPlot.num_xticks:
ZPLSCCPlot.num_xticks = time_length
xticks = np.linspace(0, time_length, ZPLSCCPlot.num_xticks)
xstep = int(round(xticks[1]))
# format trans_array_time array so that it can be used to label the x-axis
xticklabels = [i for i in num2date(data_times[::xstep])] + [num2date(data_times[-1])]
xticklabels = [i.strftime(time_format) for i in xticklabels]
# rotates and right aligns the x labels, and moves the bottom of the
# axes up to make room for them
ax.set_xlabel('time (UTC)', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xticks(xticks)
ax.set_xticklabels(xticklabels, rotation=45, horizontalalignment='center', fontsize=ZPLSCCPlot.font_size_small)
ax.set_xlim(0, time_length)
@staticmethod
def _display_colorbar(fig, data_axes):
# Add a colorbar to the specified figure using the data from the given axes
ax = fig.add_axes([0.965, 0.12, 0.01, 0.775])
cb = fig.colorbar(data_axes, cax=ax, use_gridspec=True)
cb.set_label('dB', fontsize=ZPLSCCPlot.font_size_large)
cb.ax.tick_params(labelsize=ZPLSCCPlot.font_size_small)
class ZPLSCCEchogram(object):
def __init__(self):
self.cc = ZplscCCalibrationCoefficients()
self.params = ZplscCParameters()
def compute_backscatter(self, profile_hdr, chan_data, sound_speed, depth_range, sea_absorb):
"""
Compute the backscatter volumes values for one zplsc_c profile data record.
This code was borrowed from ASL MatLab code that reads in zplsc-c raw data
and performs calculations in order to compute the backscatter volume in db.
:param profile_hdr: Raw profile header with metadata from the zplsc-c instrument.
:param chan_data: Raw frequency data from the zplsc-c instrument.
:param sound_speed: Speed of sound at based on speed of sound, pressure and salinity.
:param depth_range: Range of the depth of the measurements
:param sea_absorb: Seawater absorption coefficient for each frequency
:return: sv: Volume backscatter in db
"""
_N = []
if self.params.Bins2Avg > 1:
for chan in range(profile_hdr.num_channels):
el = self.cc.EL[chan] - 2.5/self.cc.DS[chan] + np.array(chan_data[chan])/(26214*self.cc.DS[chan])
power = 10**(el/10)
# Perform bin averaging
num_bins = len(chan_data[chan])/self.params.Bins2Avg
pwr_avg = []
for _bin in range(num_bins):
pwr_avg.append(np.mean(power[_bin*self.params.Bins2Avg:(_bin+1)*self.params.Bins2Avg]))
el_avg = 10*np.log10(pwr_avg)
_N.append(np.round(26214*self.cc.DS[chan]*(el_avg - self.cc.EL[chan] + 2.5/self.cc.DS[chan])))
else:
for chan in range(profile_hdr.num_channels):
_N.append(np.array(chan_data[chan]))
sv = []
for chan in range(profile_hdr.num_channels):
# Calculate correction to Sv due to non square transmit pulse
sv_offset = zf.compute_sv_offset(profile_hdr.frequency[chan], profile_hdr.pulse_length[chan])
sv.append(self.cc.EL[chan]-2.5/self.cc.DS[chan] + _N[chan]/(26214*self.cc.DS[chan]) - self.cc.TVR[chan] -
20*np.log10(self.cc.VTX[chan]) + 20*np.log10(depth_range[chan]) +
2*sea_absorb[chan]*depth_range[chan] -
10*np.log10(0.5*sound_speed*profile_hdr.pulse_length[chan]/1e6*self.cc.BP[chan]) +
sv_offset)
return sv
def compute_echogram_metadata(self, profile_hdr):
"""
Compute the metadata parameters needed to compute the zplsc-c valume backscatter values.
:param profile_hdr: Raw profile header with metadata from the zplsc-c instrument.
:return: sound_speed : Speed of sound based on temperature, pressure and salinity.
depth_range : Range of depth values of the zplsc-c data.
sea_absorb : Sea absorbtion based on temperature, pressure, salinity and frequency.
"""
# If the temperature sensor is available, compute the temperature from the counts.
temperature = 0
if profile_hdr.is_sensor_available:
temperature = zf.zplsc_c_temperature(profile_hdr.temperature, self.cc.ka, self.cc.kb, self.cc.kc,
self.cc.A, self.cc.B, self.cc.C)
sound_speed = zf.zplsc_c_ss(temperature, self.params.Pressure, self.params.Salinity)
_m = []
depth_range = []
for chan in range(profile_hdr.num_channels): | _m.append(np.array([x for x in range(1, (profile_hdr.num_bins[chan]/self.params.Bins2Avg)+1)]))
depth_range.append(sound_speed*profile_hdr.lockout_index[0]/(2*profile_hdr.digitization_rate[0]) +
(sound_speed/4)*(((2*_m[chan]-1)*profile_hdr.range_samples[0]*self.params.Bins2Avg-1) /
float(profile_hdr.digitization_rate[0]) +
profile_hdr.pulse_length[0]/1e6)) | random_line_split |
|
index.js | extends Component {
_isMounted = false
constructor(props) {
super(props);
this.state = {
items: {},
isDialogVisible: false,
notifyEvents: this.notify(props.navigation.state.params.events),
pushNotficationToken: '',
timeToNotify: 1,
synchronizedEvents:
this.structureSynchronizedEvents(props.navigation.state.params.events.items)
};
}
async componentDidMount() {
this.registerForPushNotificationsAsync();
this._isMounted = true;
if (Platform.OS === 'android') {
Notifications.createChannelAndroidAsync('reminders', {
name: 'Reminders',
priority: 'max',
vibrate: [0, 250, 250, 250],
});
}
}
componentWillUnmount() {
this._isMounted = false;
}
/**
* Registers device to receive push notifications
*/
registerForPushNotificationsAsync = async () => {
const { status } = await Permissions.askAsync(Permissions.NOTIFICATIONS);
if (status !== 'granted') {
Alert.alert(i18n.t('permissionNotGranted'),
i18n.t('allowNotifications'),
[
{ text: 'ok' }
]);
}
}
/**
*
* @param {object} day - information of the current day
* formats items with information of the day
*/
loadItems = (day) => {
setTimeout(() => {
const uppderBoundForSync = 85;
const lowerBoundForSync = -15;
for (let i = lowerBoundForSync; i < uppderBoundForSync; i++) {
const time = day.timestamp + i * 24 * 60 * 60 * 1000;
const strTime = this.timeToString(time);
if (!this.state.items[strTime]) {
this.state.items[strTime] = [];
const todayEvents = this.state.synchronizedEvents
.filter((event) => { return strTime === event.date; });
const numItems = todayEvents.length;
for (let j = 0; j < numItems; j++) {
this.state.items[strTime].push({
name: todayEvents[j].title,
startTime: todayEvents[j].startTime,
endTime: todayEvents[j].endTime,
description: todayEvents[j].description,
address: todayEvents[j].address,
height: 80
});
}
}
}
const newItems = {};
Object.keys(this.state.items).forEach((key) => { newItems[key] = this.state.items[key]; });
if (this._isMounted) {
this.setState({
items: newItems
});
}
}, 1000);
}
/**
*
* @param {object} events - All the user events
* Formats the events to only return required events
*/
notify = (events) => {
const notifyArray = [];
events.items.forEach((element) => {
const date = new Date(element.start.dateTime);
if (element.summary) {
if (element.summary.includes('conpass') && date.getTime() > (new Date()).getTime()) {
notifyArray.push({
startDate: element.start.dateTime,
summary: element.summary,
});
}
}
});
return notifyArray;
};
/**
* Schedules push notifications to user upon adjusting the timer
*/
sendPushNotification = () => {
Notifications.cancelAllScheduledNotificationsAsync();
this.state.notifyEvents.forEach((element) => {
const localNotification = {
to: this.state.pushNotficationToken,
sound: 'default',
priority: 'high',
title: 'Conpass Notification',
body: element.summary,
channelId: 'reminders',
ios: { _displayInForeground: true }
};
const date = new Date(element.startDate);
const t = date.getTime() - this.state.timeToNotify * 60 * 1000;
const schedulingOptions = {
time: t
};
Notifications.scheduleLocalNotificationAsync(localNotification, schedulingOptions);
});
return 'Notifications sent';
}
/**
* @param {boolean} boolean - True or false
* Shows or hides the dialong box of 'Adjust time' button
*/
showDialog=(boolean) => {
if (this._isMounted) {
this.setState({ isDialogVisible: boolean });
}
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
sendInput = (number) => {
if (/^\d+$/.test(number.toString())) {
if (this._isMounted) {
this.setState({ timeToNotify: number });
this.setState({ isDialogVisible: false });
}
} else {
// your call back function
Alert.alert(i18n.t('numbersOnly'),
'',
[
{ text: 'ok' }
]);
return;
}
setTimeout(() => {
this.sendPushNotification();
}, 100);
}
/**
* Fetches new events on google calendar
*/
refreshCalendar =async () => {
const accessToken = await AsyncStorage.getItem('accessToken');
const userInfoResponse = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events?key=AIzaSyBAHObp5Ic3CbJpkX2500tNhf53e_3wBMA&timeMin=2020-01-01T01:00:00.000Z', {
headers: { Authorization: `Bearer ${accessToken}` },
});
const jsonFile = await userInfoResponse.json();
const { error } = jsonFile;
if (error) {
firebase.auth().signOut();
this.props.navigation.navigate('LoginScreen');
Alert.alert(i18n.t('logInAgain'),
'',
[
{ text: 'ok' }
]);
return;
}
const stringFile = JSON.stringify(jsonFile);
AsyncStorage.setItem('events', stringFile);
this.props.navigation.navigate('FetchScreen');
}
/**
* @param {String} description - A location to go to
* Navigates to the home component
*/
sendDirections = (description) => {
if (!description) {
Alert.alert(i18n.t('noAddress'),
'',
[
{ text: 'ok' }
]);
return '';
}
this.props.navigation.navigate('HomeScreen', { description });
return 'address sent';
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
rowHasChanged(r1, r2) {
return r1.name !== r2.name;
}
/**
* @param {integer} time - time of the event
* restructure time in a certain format
*/
timeToString(time) {
const date = new Date(time);
return date.toISOString().split('T')[0];
}
/**
* @param {object} events - All the events the user has
* Structures all the events the user has
*/
structureSynchronizedEvents(events) {
const tempArray = [];
events.forEach((event) => {
tempArray.push(
{
date: event.start.dateTime != null ? event.start.dateTime.substring(0, event.start.dateTime.indexOf('T')) : event.start.date,
title: event.summary != null ? event.summary : 'No Title For this Event',
startTime: event.start.dateTime != null ? event.start.dateTime : event.start.date,
endTime: event.end.dateTime != null ? event.end.dateTime : event.end.date,
description: event.description != null ? event.description : '',
address: event.location != null ? event.location : ''
}
);
});
if (this._isMounted) {
this.setState({
synchronizedEvents: this.tempArray
});
}
return tempArray;
}
/**
* @param {object} item - information of item
* present event in the agenda
*/
renderItem(item) {
const { address } = item;
const { description } = item;
return (
<TouchableOpacity
style={[styles.item, { height: item.height }]}
onPress={() => {
return Alert.alert(item.name,
`${item.startTime} - ${item.endTime}\n${item.description}\n${item.address}`,
[
{ text: i18n.t('cancel') },
{
text: i18n.t('getDirections'),
onPress: () => {
if (address) { this.sendDirections(address.split(',')[0]); } else { this.sendDirections(description.split('\n')[0]); }
}
},
],
{ cancelable: false });
}}
>
<Text style={{ color: 'white' }}>{item.name}</Text>
</TouchableOpacity>
);
}
/**
* add line to empty day
*/
renderEmptyDate = () => {
return (
<View
style={{
borderBottomColor: 'rgba(105,105,105,0.1)',
borderBottomWidth: 1,
}}
/>
);
}
render() {
return (
<View
style={{ height: '100%', width: | DashboardScreen | identifier_name |
|
index.js | _isMounted = false
constructor(props) {
super(props);
this.state = {
items: {},
isDialogVisible: false,
notifyEvents: this.notify(props.navigation.state.params.events),
pushNotficationToken: '',
timeToNotify: 1,
synchronizedEvents:
this.structureSynchronizedEvents(props.navigation.state.params.events.items)
};
}
async componentDidMount() {
this.registerForPushNotificationsAsync();
this._isMounted = true;
if (Platform.OS === 'android') {
Notifications.createChannelAndroidAsync('reminders', {
name: 'Reminders',
priority: 'max',
vibrate: [0, 250, 250, 250],
});
}
}
componentWillUnmount() {
this._isMounted = false;
}
/**
* Registers device to receive push notifications
*/
registerForPushNotificationsAsync = async () => {
const { status } = await Permissions.askAsync(Permissions.NOTIFICATIONS);
if (status !== 'granted') {
Alert.alert(i18n.t('permissionNotGranted'),
i18n.t('allowNotifications'),
[
{ text: 'ok' }
]);
}
}
/**
*
* @param {object} day - information of the current day
* formats items with information of the day
*/
loadItems = (day) => {
setTimeout(() => {
const uppderBoundForSync = 85;
const lowerBoundForSync = -15;
for (let i = lowerBoundForSync; i < uppderBoundForSync; i++) {
const time = day.timestamp + i * 24 * 60 * 60 * 1000;
const strTime = this.timeToString(time);
if (!this.state.items[strTime]) {
this.state.items[strTime] = [];
const todayEvents = this.state.synchronizedEvents
.filter((event) => { return strTime === event.date; });
const numItems = todayEvents.length;
for (let j = 0; j < numItems; j++) {
this.state.items[strTime].push({
name: todayEvents[j].title,
startTime: todayEvents[j].startTime,
endTime: todayEvents[j].endTime,
description: todayEvents[j].description,
address: todayEvents[j].address,
height: 80
});
}
}
}
const newItems = {};
Object.keys(this.state.items).forEach((key) => { newItems[key] = this.state.items[key]; });
if (this._isMounted) {
this.setState({
items: newItems
});
}
}, 1000);
}
/**
*
* @param {object} events - All the user events
* Formats the events to only return required events
*/
notify = (events) => {
const notifyArray = [];
events.items.forEach((element) => {
const date = new Date(element.start.dateTime);
if (element.summary) {
if (element.summary.includes('conpass') && date.getTime() > (new Date()).getTime()) |
}
});
return notifyArray;
};
/**
* Schedules push notifications to user upon adjusting the timer
*/
sendPushNotification = () => {
Notifications.cancelAllScheduledNotificationsAsync();
this.state.notifyEvents.forEach((element) => {
const localNotification = {
to: this.state.pushNotficationToken,
sound: 'default',
priority: 'high',
title: 'Conpass Notification',
body: element.summary,
channelId: 'reminders',
ios: { _displayInForeground: true }
};
const date = new Date(element.startDate);
const t = date.getTime() - this.state.timeToNotify * 60 * 1000;
const schedulingOptions = {
time: t
};
Notifications.scheduleLocalNotificationAsync(localNotification, schedulingOptions);
});
return 'Notifications sent';
}
/**
* @param {boolean} boolean - True or false
* Shows or hides the dialong box of 'Adjust time' button
*/
showDialog=(boolean) => {
if (this._isMounted) {
this.setState({ isDialogVisible: boolean });
}
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
sendInput = (number) => {
if (/^\d+$/.test(number.toString())) {
if (this._isMounted) {
this.setState({ timeToNotify: number });
this.setState({ isDialogVisible: false });
}
} else {
// your call back function
Alert.alert(i18n.t('numbersOnly'),
'',
[
{ text: 'ok' }
]);
return;
}
setTimeout(() => {
this.sendPushNotification();
}, 100);
}
/**
* Fetches new events on google calendar
*/
refreshCalendar =async () => {
const accessToken = await AsyncStorage.getItem('accessToken');
const userInfoResponse = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events?key=AIzaSyBAHObp5Ic3CbJpkX2500tNhf53e_3wBMA&timeMin=2020-01-01T01:00:00.000Z', {
headers: { Authorization: `Bearer ${accessToken}` },
});
const jsonFile = await userInfoResponse.json();
const { error } = jsonFile;
if (error) {
firebase.auth().signOut();
this.props.navigation.navigate('LoginScreen');
Alert.alert(i18n.t('logInAgain'),
'',
[
{ text: 'ok' }
]);
return;
}
const stringFile = JSON.stringify(jsonFile);
AsyncStorage.setItem('events', stringFile);
this.props.navigation.navigate('FetchScreen');
}
/**
* @param {String} description - A location to go to
* Navigates to the home component
*/
sendDirections = (description) => {
if (!description) {
Alert.alert(i18n.t('noAddress'),
'',
[
{ text: 'ok' }
]);
return '';
}
this.props.navigation.navigate('HomeScreen', { description });
return 'address sent';
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
rowHasChanged(r1, r2) {
return r1.name !== r2.name;
}
/**
* @param {integer} time - time of the event
* restructure time in a certain format
*/
timeToString(time) {
const date = new Date(time);
return date.toISOString().split('T')[0];
}
/**
* @param {object} events - All the events the user has
* Structures all the events the user has
*/
structureSynchronizedEvents(events) {
const tempArray = [];
events.forEach((event) => {
tempArray.push(
{
date: event.start.dateTime != null ? event.start.dateTime.substring(0, event.start.dateTime.indexOf('T')) : event.start.date,
title: event.summary != null ? event.summary : 'No Title For this Event',
startTime: event.start.dateTime != null ? event.start.dateTime : event.start.date,
endTime: event.end.dateTime != null ? event.end.dateTime : event.end.date,
description: event.description != null ? event.description : '',
address: event.location != null ? event.location : ''
}
);
});
if (this._isMounted) {
this.setState({
synchronizedEvents: this.tempArray
});
}
return tempArray;
}
/**
* @param {object} item - information of item
* present event in the agenda
*/
renderItem(item) {
const { address } = item;
const { description } = item;
return (
<TouchableOpacity
style={[styles.item, { height: item.height }]}
onPress={() => {
return Alert.alert(item.name,
`${item.startTime} - ${item.endTime}\n${item.description}\n${item.address}`,
[
{ text: i18n.t('cancel') },
{
text: i18n.t('getDirections'),
onPress: () => {
if (address) { this.sendDirections(address.split(',')[0]); } else { this.sendDirections(description.split('\n')[0]); }
}
},
],
{ cancelable: false });
}}
>
<Text style={{ color: 'white' }}>{item.name}</Text>
</TouchableOpacity>
);
}
/**
* add line to empty day
*/
renderEmptyDate = () => {
return (
<View
style={{
borderBottomColor: 'rgba(105,105,105,0.1)',
borderBottomWidth: 1,
}}
/>
);
}
render() {
return (
<View
style={{ height: '100%', width: '10 | {
notifyArray.push({
startDate: element.start.dateTime,
summary: element.summary,
});
} | conditional_block |
index.js | _isMounted = false
constructor(props) {
super(props);
this.state = {
items: {},
isDialogVisible: false,
notifyEvents: this.notify(props.navigation.state.params.events),
pushNotficationToken: '',
timeToNotify: 1,
synchronizedEvents:
this.structureSynchronizedEvents(props.navigation.state.params.events.items)
};
}
async componentDidMount() {
this.registerForPushNotificationsAsync();
this._isMounted = true;
if (Platform.OS === 'android') {
Notifications.createChannelAndroidAsync('reminders', {
name: 'Reminders',
priority: 'max',
vibrate: [0, 250, 250, 250],
});
}
}
componentWillUnmount() {
this._isMounted = false;
}
/**
* Registers device to receive push notifications
*/
registerForPushNotificationsAsync = async () => {
const { status } = await Permissions.askAsync(Permissions.NOTIFICATIONS);
if (status !== 'granted') {
Alert.alert(i18n.t('permissionNotGranted'),
i18n.t('allowNotifications'),
[
{ text: 'ok' }
]);
}
}
/**
*
* @param {object} day - information of the current day
* formats items with information of the day
*/
loadItems = (day) => {
setTimeout(() => {
const uppderBoundForSync = 85;
const lowerBoundForSync = -15;
for (let i = lowerBoundForSync; i < uppderBoundForSync; i++) {
const time = day.timestamp + i * 24 * 60 * 60 * 1000;
const strTime = this.timeToString(time);
if (!this.state.items[strTime]) {
this.state.items[strTime] = [];
const todayEvents = this.state.synchronizedEvents
.filter((event) => { return strTime === event.date; });
const numItems = todayEvents.length;
for (let j = 0; j < numItems; j++) {
this.state.items[strTime].push({
name: todayEvents[j].title,
startTime: todayEvents[j].startTime,
endTime: todayEvents[j].endTime,
description: todayEvents[j].description,
address: todayEvents[j].address,
height: 80
});
}
}
}
const newItems = {};
Object.keys(this.state.items).forEach((key) => { newItems[key] = this.state.items[key]; });
if (this._isMounted) {
this.setState({
items: newItems
});
}
}, 1000);
}
/**
*
* @param {object} events - All the user events
* Formats the events to only return required events
*/
notify = (events) => {
const notifyArray = [];
events.items.forEach((element) => {
const date = new Date(element.start.dateTime);
if (element.summary) {
if (element.summary.includes('conpass') && date.getTime() > (new Date()).getTime()) {
notifyArray.push({
startDate: element.start.dateTime,
summary: element.summary,
});
}
}
});
return notifyArray;
};
/**
* Schedules push notifications to user upon adjusting the timer
*/
sendPushNotification = () => {
Notifications.cancelAllScheduledNotificationsAsync();
this.state.notifyEvents.forEach((element) => {
const localNotification = {
to: this.state.pushNotficationToken,
sound: 'default',
priority: 'high',
title: 'Conpass Notification',
body: element.summary,
channelId: 'reminders',
ios: { _displayInForeground: true }
};
const date = new Date(element.startDate);
const t = date.getTime() - this.state.timeToNotify * 60 * 1000;
const schedulingOptions = {
time: t
};
Notifications.scheduleLocalNotificationAsync(localNotification, schedulingOptions);
});
return 'Notifications sent';
}
/**
* @param {boolean} boolean - True or false
* Shows or hides the dialong box of 'Adjust time' button
*/
showDialog=(boolean) => {
if (this._isMounted) {
this.setState({ isDialogVisible: boolean });
}
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
sendInput = (number) => {
if (/^\d+$/.test(number.toString())) {
if (this._isMounted) {
this.setState({ timeToNotify: number });
this.setState({ isDialogVisible: false });
}
} else {
// your call back function
Alert.alert(i18n.t('numbersOnly'),
'',
[
{ text: 'ok' }
]);
return;
}
setTimeout(() => {
this.sendPushNotification();
}, 100);
}
/**
* Fetches new events on google calendar
*/
refreshCalendar =async () => {
const accessToken = await AsyncStorage.getItem('accessToken');
const userInfoResponse = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events?key=AIzaSyBAHObp5Ic3CbJpkX2500tNhf53e_3wBMA&timeMin=2020-01-01T01:00:00.000Z', {
headers: { Authorization: `Bearer ${accessToken}` },
});
const jsonFile = await userInfoResponse.json();
const { error } = jsonFile;
if (error) {
firebase.auth().signOut();
this.props.navigation.navigate('LoginScreen');
Alert.alert(i18n.t('logInAgain'),
'',
[
{ text: 'ok' }
]);
return;
}
const stringFile = JSON.stringify(jsonFile);
AsyncStorage.setItem('events', stringFile);
this.props.navigation.navigate('FetchScreen');
}
/**
* @param {String} description - A location to go to
* Navigates to the home component
*/
sendDirections = (description) => {
if (!description) {
Alert.alert(i18n.t('noAddress'),
'',
[
{ text: 'ok' }
]);
return '';
}
this.props.navigation.navigate('HomeScreen', { description });
return 'address sent';
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
rowHasChanged(r1, r2) |
/**
* @param {integer} time - time of the event
* restructure time in a certain format
*/
timeToString(time) {
const date = new Date(time);
return date.toISOString().split('T')[0];
}
/**
* @param {object} events - All the events the user has
* Structures all the events the user has
*/
structureSynchronizedEvents(events) {
const tempArray = [];
events.forEach((event) => {
tempArray.push(
{
date: event.start.dateTime != null ? event.start.dateTime.substring(0, event.start.dateTime.indexOf('T')) : event.start.date,
title: event.summary != null ? event.summary : 'No Title For this Event',
startTime: event.start.dateTime != null ? event.start.dateTime : event.start.date,
endTime: event.end.dateTime != null ? event.end.dateTime : event.end.date,
description: event.description != null ? event.description : '',
address: event.location != null ? event.location : ''
}
);
});
if (this._isMounted) {
this.setState({
synchronizedEvents: this.tempArray
});
}
return tempArray;
}
/**
* @param {object} item - information of item
* present event in the agenda
*/
renderItem(item) {
const { address } = item;
const { description } = item;
return (
<TouchableOpacity
style={[styles.item, { height: item.height }]}
onPress={() => {
return Alert.alert(item.name,
`${item.startTime} - ${item.endTime}\n${item.description}\n${item.address}`,
[
{ text: i18n.t('cancel') },
{
text: i18n.t('getDirections'),
onPress: () => {
if (address) { this.sendDirections(address.split(',')[0]); } else { this.sendDirections(description.split('\n')[0]); }
}
},
],
{ cancelable: false });
}}
>
<Text style={{ color: 'white' }}>{item.name}</Text>
</TouchableOpacity>
);
}
/**
* add line to empty day
*/
renderEmptyDate = () => {
return (
<View
style={{
borderBottomColor: 'rgba(105,105,105,0.1)',
borderBottomWidth: 1,
}}
/>
);
}
render() {
return (
<View
style={{ height: '100%', width: '10 | {
return r1.name !== r2.name;
} | identifier_body |
index.js | {
_isMounted = false
constructor(props) {
super(props);
this.state = {
items: {},
isDialogVisible: false,
notifyEvents: this.notify(props.navigation.state.params.events),
pushNotficationToken: '',
timeToNotify: 1,
synchronizedEvents:
this.structureSynchronizedEvents(props.navigation.state.params.events.items)
};
}
async componentDidMount() {
this.registerForPushNotificationsAsync();
this._isMounted = true;
if (Platform.OS === 'android') {
Notifications.createChannelAndroidAsync('reminders', {
name: 'Reminders',
priority: 'max',
vibrate: [0, 250, 250, 250],
});
}
}
componentWillUnmount() {
this._isMounted = false;
}
/**
* Registers device to receive push notifications
*/
registerForPushNotificationsAsync = async () => {
const { status } = await Permissions.askAsync(Permissions.NOTIFICATIONS);
if (status !== 'granted') {
Alert.alert(i18n.t('permissionNotGranted'),
i18n.t('allowNotifications'),
[ |
/**
*
* @param {object} day - information of the current day
* formats items with information of the day
*/
loadItems = (day) => {
setTimeout(() => {
const uppderBoundForSync = 85;
const lowerBoundForSync = -15;
for (let i = lowerBoundForSync; i < uppderBoundForSync; i++) {
const time = day.timestamp + i * 24 * 60 * 60 * 1000;
const strTime = this.timeToString(time);
if (!this.state.items[strTime]) {
this.state.items[strTime] = [];
const todayEvents = this.state.synchronizedEvents
.filter((event) => { return strTime === event.date; });
const numItems = todayEvents.length;
for (let j = 0; j < numItems; j++) {
this.state.items[strTime].push({
name: todayEvents[j].title,
startTime: todayEvents[j].startTime,
endTime: todayEvents[j].endTime,
description: todayEvents[j].description,
address: todayEvents[j].address,
height: 80
});
}
}
}
const newItems = {};
Object.keys(this.state.items).forEach((key) => { newItems[key] = this.state.items[key]; });
if (this._isMounted) {
this.setState({
items: newItems
});
}
}, 1000);
}
/**
*
* @param {object} events - All the user events
* Formats the events to only return required events
*/
notify = (events) => {
const notifyArray = [];
events.items.forEach((element) => {
const date = new Date(element.start.dateTime);
if (element.summary) {
if (element.summary.includes('conpass') && date.getTime() > (new Date()).getTime()) {
notifyArray.push({
startDate: element.start.dateTime,
summary: element.summary,
});
}
}
});
return notifyArray;
};
/**
* Schedules push notifications to user upon adjusting the timer
*/
sendPushNotification = () => {
Notifications.cancelAllScheduledNotificationsAsync();
this.state.notifyEvents.forEach((element) => {
const localNotification = {
to: this.state.pushNotficationToken,
sound: 'default',
priority: 'high',
title: 'Conpass Notification',
body: element.summary,
channelId: 'reminders',
ios: { _displayInForeground: true }
};
const date = new Date(element.startDate);
const t = date.getTime() - this.state.timeToNotify * 60 * 1000;
const schedulingOptions = {
time: t
};
Notifications.scheduleLocalNotificationAsync(localNotification, schedulingOptions);
});
return 'Notifications sent';
}
/**
* @param {boolean} boolean - True or false
* Shows or hides the dialong box of 'Adjust time' button
*/
showDialog=(boolean) => {
if (this._isMounted) {
this.setState({ isDialogVisible: boolean });
}
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
sendInput = (number) => {
if (/^\d+$/.test(number.toString())) {
if (this._isMounted) {
this.setState({ timeToNotify: number });
this.setState({ isDialogVisible: false });
}
} else {
// your call back function
Alert.alert(i18n.t('numbersOnly'),
'',
[
{ text: 'ok' }
]);
return;
}
setTimeout(() => {
this.sendPushNotification();
}, 100);
}
/**
* Fetches new events on google calendar
*/
refreshCalendar =async () => {
const accessToken = await AsyncStorage.getItem('accessToken');
const userInfoResponse = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events?key=AIzaSyBAHObp5Ic3CbJpkX2500tNhf53e_3wBMA&timeMin=2020-01-01T01:00:00.000Z', {
headers: { Authorization: `Bearer ${accessToken}` },
});
const jsonFile = await userInfoResponse.json();
const { error } = jsonFile;
if (error) {
firebase.auth().signOut();
this.props.navigation.navigate('LoginScreen');
Alert.alert(i18n.t('logInAgain'),
'',
[
{ text: 'ok' }
]);
return;
}
const stringFile = JSON.stringify(jsonFile);
AsyncStorage.setItem('events', stringFile);
this.props.navigation.navigate('FetchScreen');
}
/**
* @param {String} description - A location to go to
* Navigates to the home component
*/
sendDirections = (description) => {
if (!description) {
Alert.alert(i18n.t('noAddress'),
'',
[
{ text: 'ok' }
]);
return '';
}
this.props.navigation.navigate('HomeScreen', { description });
return 'address sent';
}
/**
* @param {integer} number - Time in minutes
* Sets the minutes in which the user wants to get notfications before
*/
rowHasChanged(r1, r2) {
return r1.name !== r2.name;
}
/**
* @param {integer} time - time of the event
* restructure time in a certain format
*/
timeToString(time) {
const date = new Date(time);
return date.toISOString().split('T')[0];
}
/**
* @param {object} events - All the events the user has
* Structures all the events the user has
*/
structureSynchronizedEvents(events) {
const tempArray = [];
events.forEach((event) => {
tempArray.push(
{
date: event.start.dateTime != null ? event.start.dateTime.substring(0, event.start.dateTime.indexOf('T')) : event.start.date,
title: event.summary != null ? event.summary : 'No Title For this Event',
startTime: event.start.dateTime != null ? event.start.dateTime : event.start.date,
endTime: event.end.dateTime != null ? event.end.dateTime : event.end.date,
description: event.description != null ? event.description : '',
address: event.location != null ? event.location : ''
}
);
});
if (this._isMounted) {
this.setState({
synchronizedEvents: this.tempArray
});
}
return tempArray;
}
/**
* @param {object} item - information of item
* present event in the agenda
*/
renderItem(item) {
const { address } = item;
const { description } = item;
return (
<TouchableOpacity
style={[styles.item, { height: item.height }]}
onPress={() => {
return Alert.alert(item.name,
`${item.startTime} - ${item.endTime}\n${item.description}\n${item.address}`,
[
{ text: i18n.t('cancel') },
{
text: i18n.t('getDirections'),
onPress: () => {
if (address) { this.sendDirections(address.split(',')[0]); } else { this.sendDirections(description.split('\n')[0]); }
}
},
],
{ cancelable: false });
}}
>
<Text style={{ color: 'white' }}>{item.name}</Text>
</TouchableOpacity>
);
}
/**
* add line to empty day
*/
renderEmptyDate = () => {
return (
<View
style={{
borderBottomColor: 'rgba(105,105,105,0.1)',
borderBottomWidth: 1,
}}
/>
);
}
render() {
return (
<View
style={{ height: '100%', width: '10 | { text: 'ok' }
]);
}
} | random_line_split |
browse.ts | /api';
import { SettingsProvider } from '../../../providers/settings/settings';
import { Network } from '@ionic-native/network';
import { CoursePage } from '../course/course';
/**
* Generated class for the BrowsePage page.
*
* See https://ionicframework.com/docs/components/#navigation for more info on
* Ionic pages and navigation.
*/
@IonicPage()
@Component({
selector: 'page-browse',
templateUrl: 'browse.html',
})
export class BrowsePage {
@ViewChild(InfiniteScroll) infiniteScroll:InfiniteScroll;
@ViewChild(Content) content: Content;
public isOn: boolean = false;
public isCategory: boolean = false;
public courses;
public error:boolean = false;
private loading;
public settings;
public currency;
public exchangeRate;
public params= {
filter:'',
sort:'',
group:'',
type:''
};
public currentPage=1;
public showLoading:boolean = false;
public sortLib ={
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
public catLib = {};
public networkPresent= true;
public showRetry=false;
constructor(public popoverCtrl: PopoverController,public app:App,public navCtrl: NavController, public navParams: NavParams, private apiService:ApiProvider,public loadingController: LoadingController,public toastController: ToastController,public settingService:SettingsProvider,public actionSheetController: ActionSheetController,public network:Network) {
// this.params = {
// filter:'',
// sort:'',
// group:'',
// type:''
// };
}
private clearParams(){
this.params = {
filter:'',
sort:'',
group:'',
type:'',
};
}
async ionViewWillEnter(){
this.currency = await this.settingService.getCurrency();
console.log('Entered browse view');
}
async ngOnInit() {
this.params = {
filter:'',
sort:'',
group:'',
type:''
};
this.sortLib = {
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
console.log(this.params);
console.log(this.sortLib);
// let data = await this.settingService.getSetting('widgets');
this.networkCheck();
//get courses
this.showLoading= true;
this.loadCourses(1).subscribe(response=>{
this.courses= response['records'];
console.log(response);
this.currentPage = 1;
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
this.currency = await this.settingService.getCurrency();
this.settingService.getSettings().then(val => {
this.settings = val;
//load category library
for(let i=0; i < this.settings.categories.length; i++){
this.catLib[this.settings.categories[i].session_category_id] = this.settings.categories[i].category_name;
}
console.log('showing cat lib');
console.log(this.catLib);
// let currency = val.student_currency;
// //get exchange rate for currency
// let currencyList = val.currencies;
// let currencyObj:any;
// for(let i=0; i<currencyList.length;i++){
// let obj = currencyList[i];
// if(obj.currency_id==currency){
// currencyObj = obj;
// }
// }
// this.currency = currencyObj;
});
}
networkCheck(){
// watch network for a disconnection
let disconnectSubscription = this.network.onDisconnect().subscribe(() => {
console.log('network was disconnected :-(');
this.networkPresent= false;
});
// stop disconnect watch
disconnectSubscription.unsubscribe();
// watch network for a connection
let connectSubscription = this.network.onConnect().subscribe(() => {
console.log('network connected!');
// We just got a connection but we need to wait briefly
// before we determine the connection type. Might need to wait.
// prior to doing any api requests as well.
setTimeout(() => {
if (this.network.type === 'wifi') {
console.log('we got a wifi connection, woohoo!');
this.networkPresent= true;
}
}, 3000);
});
}
search(){
this.showLoading = true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
private loadCourses(page){
this.showRetry= false;
// this.currentPage = page;
//this.infiniteScroll.enable(true);
return this.apiService.getSessions(page,30,this.params.group,this.params.filter,this.params.sort,this.params.type);
}
async | () {
this.loading = await this.loadingController.create({
content: 'Loading. Please wait...',
duration: 2000000000
});
return await this.loading.present();
}
getButtonText(): string {
return `Switch ${ this.isOn ? 'Off' : 'On' }`;
}
setState(): void {
this.isOn = !this.isOn;
}
toggleCategory(){
this.content.scrollToTop();
this.isCategory = !this.isCategory;
}
toggleDetails() {
this.isOn = !this.isOn;
if(!this.isOn && this.params.filter != ""){
this.params.filter = "";
this.showLoading= true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading= false;
});
}
}
clearSearch(){
console.log('clear clicked');
}
loadData(event){
this.currentPage++;
console.log('scroll starting: '+this.currentPage);
this.loadCourses(this.currentPage).subscribe(response=>{
//console.log(response['records']);
this.courses= this.courses.concat(response['records']);
console.log(this.courses);
event.complete();
//determine if this was the last page
let totalPages = Math.ceil((response['total']/response['rows_per_page']));
console.log(totalPages);
if(this.currentPage >= totalPages){
// this.currentPage--;
// event.enable(false);
}
}, err => {
event.complete();
this.presentToast('Network error! Please check your Internet Connection and try again');
console.log(err.message);
})
}
reloadCourses(page){
this.content.scrollToTop();
this.showLoading=true;
this.currentPage=page;
this.loadCourses(page).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading=false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
async presentActionSheet() {
const actionSheet = await this.actionSheetController.create({
title: 'Sort By',
buttons: [{
text: 'Alphabetical (asc)',
icon: 'arrow-round-up',
handler: () => {
this.params.sort = "asc";
this.reloadCourses(1);
}
}, {
text: 'Alphabetical (desc)',
icon: 'arrow-round-down',
handler: () => {
this.params.sort = "desc";
this.reloadCourses(1);
}
}, {
text: 'Most Recent',
icon: 'time',
handler: () => {
this.params.sort = "recent";
this.reloadCourses(1);
}
}, {
text: 'Price (Lowest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceAsc";
this.reloadCourses(1);
}
},{
text: 'Price (Highest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceDesc";
this.reloadCourses(1);
}
},
{
text: 'Online Courses',
icon: 'globe',
handler: () => {
this.params.type = "c";
this.reloadCourses(1);
}
},{
text: 'Training Sessions',
icon: 'people',
handler: () => {
this.params.type = "s-b";
this.reloadCourses(1);
}
}, {
text: 'Reset',
icon: 'refresh',
handler: () => {
this.params.type = "";
this.params.sort = "";
this.reloadCourses(1);
}
}]
});
await actionSheet.present();
}
loadCategory(category){
this.params.group= category;
this.isCategory = false;
this.reloadCourses(1);
}
async presentToast(message:string) {
const toast = await this.toastController.create({
message: message,
duration: 3000
});
toast.present();
}
| presentLoading | identifier_name |
browse.ts | /api';
import { SettingsProvider } from '../../../providers/settings/settings';
import { Network } from '@ionic-native/network';
import { CoursePage } from '../course/course';
/**
* Generated class for the BrowsePage page.
*
* See https://ionicframework.com/docs/components/#navigation for more info on
* Ionic pages and navigation.
*/
@IonicPage()
@Component({
selector: 'page-browse',
templateUrl: 'browse.html',
})
export class BrowsePage {
@ViewChild(InfiniteScroll) infiniteScroll:InfiniteScroll;
@ViewChild(Content) content: Content;
public isOn: boolean = false;
public isCategory: boolean = false;
public courses;
public error:boolean = false;
private loading;
public settings;
public currency;
public exchangeRate;
public params= {
filter:'',
sort:'',
group:'',
type:''
};
public currentPage=1;
public showLoading:boolean = false;
public sortLib ={
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
public catLib = {};
public networkPresent= true;
public showRetry=false;
constructor(public popoverCtrl: PopoverController,public app:App,public navCtrl: NavController, public navParams: NavParams, private apiService:ApiProvider,public loadingController: LoadingController,public toastController: ToastController,public settingService:SettingsProvider,public actionSheetController: ActionSheetController,public network:Network) {
// this.params = {
// filter:'',
// sort:'',
// group:'',
// type:''
// };
}
private clearParams(){
this.params = {
filter:'',
sort:'',
group:'',
type:'',
};
}
async ionViewWillEnter(){
this.currency = await this.settingService.getCurrency();
console.log('Entered browse view');
}
async ngOnInit() {
this.params = {
filter:'',
sort:'',
group:'',
type:''
};
this.sortLib = {
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
console.log(this.params);
console.log(this.sortLib);
// let data = await this.settingService.getSetting('widgets');
this.networkCheck();
//get courses
this.showLoading= true;
this.loadCourses(1).subscribe(response=>{
this.courses= response['records'];
console.log(response);
this.currentPage = 1;
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
this.currency = await this.settingService.getCurrency();
this.settingService.getSettings().then(val => {
this.settings = val;
//load category library
for(let i=0; i < this.settings.categories.length; i++){
this.catLib[this.settings.categories[i].session_category_id] = this.settings.categories[i].category_name;
}
console.log('showing cat lib');
console.log(this.catLib);
// let currency = val.student_currency;
// //get exchange rate for currency
// let currencyList = val.currencies;
// let currencyObj:any;
// for(let i=0; i<currencyList.length;i++){
// let obj = currencyList[i];
// if(obj.currency_id==currency){
// currencyObj = obj;
// }
// }
// this.currency = currencyObj;
});
}
networkCheck(){
// watch network for a disconnection
let disconnectSubscription = this.network.onDisconnect().subscribe(() => {
console.log('network was disconnected :-(');
this.networkPresent= false;
});
// stop disconnect watch
disconnectSubscription.unsubscribe();
// watch network for a connection
let connectSubscription = this.network.onConnect().subscribe(() => {
console.log('network connected!');
// We just got a connection but we need to wait briefly
// before we determine the connection type. Might need to wait.
// prior to doing any api requests as well.
setTimeout(() => {
if (this.network.type === 'wifi') {
console.log('we got a wifi connection, woohoo!');
this.networkPresent= true;
}
}, 3000);
});
}
search(){
this.showLoading = true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
private loadCourses(page){
this.showRetry= false;
// this.currentPage = page;
//this.infiniteScroll.enable(true);
return this.apiService.getSessions(page,30,this.params.group,this.params.filter,this.params.sort,this.params.type);
}
async presentLoading() {
this.loading = await this.loadingController.create({
content: 'Loading. Please wait...',
duration: 2000000000
});
return await this.loading.present();
}
getButtonText(): string {
return `Switch ${ this.isOn ? 'Off' : 'On' }`;
}
setState(): void {
this.isOn = !this.isOn;
}
toggleCategory(){
this.content.scrollToTop();
this.isCategory = !this.isCategory;
}
toggleDetails() {
this.isOn = !this.isOn;
if(!this.isOn && this.params.filter != ""){
this.params.filter = "";
this.showLoading= true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading= false;
});
}
}
clearSearch(){
console.log('clear clicked');
}
loadData(event){
this.currentPage++;
console.log('scroll starting: '+this.currentPage);
this.loadCourses(this.currentPage).subscribe(response=>{
//console.log(response['records']);
this.courses= this.courses.concat(response['records']);
console.log(this.courses);
event.complete();
//determine if this was the last page
let totalPages = Math.ceil((response['total']/response['rows_per_page']));
console.log(totalPages);
if(this.currentPage >= totalPages){
// this.currentPage--;
// event.enable(false);
}
}, err => {
event.complete();
this.presentToast('Network error! Please check your Internet Connection and try again');
console.log(err.message);
})
}
reloadCourses(page){
this.content.scrollToTop();
this.showLoading=true;
this.currentPage=page;
this.loadCourses(page).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading=false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
async presentActionSheet() | handler: () => {
this.params.sort = "recent";
this.reloadCourses(1);
}
}, {
text: 'Price (Lowest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceAsc";
this.reloadCourses(1);
}
},{
text: 'Price (Highest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceDesc";
this.reloadCourses(1);
}
},
{
text: 'Online Courses',
icon: 'globe',
handler: () => {
this.params.type = "c";
this.reloadCourses(1);
}
},{
text: 'Training Sessions',
icon: 'people',
handler: () => {
this.params.type = "s-b";
this.reloadCourses(1);
}
}, {
text: 'Reset',
icon: 'refresh',
handler: () => {
this.params.type = "";
this.params.sort = "";
this.reloadCourses(1);
}
}]
});
await actionSheet.present();
}
loadCategory(category){
this.params.group= category;
this.isCategory = false;
this.reloadCourses(1);
}
async presentToast(message:string) {
const toast = await this.toastController.create({
message: message,
duration: 3000
});
toast.present();
}
| {
const actionSheet = await this.actionSheetController.create({
title: 'Sort By',
buttons: [{
text: 'Alphabetical (asc)',
icon: 'arrow-round-up',
handler: () => {
this.params.sort = "asc";
this.reloadCourses(1);
}
}, {
text: 'Alphabetical (desc)',
icon: 'arrow-round-down',
handler: () => {
this.params.sort = "desc";
this.reloadCourses(1);
}
}, {
text: 'Most Recent',
icon: 'time', | identifier_body |
browse.ts | ';
import { SettingsProvider } from '../../../providers/settings/settings';
import { Network } from '@ionic-native/network';
import { CoursePage } from '../course/course';
/**
* Generated class for the BrowsePage page.
*
* See https://ionicframework.com/docs/components/#navigation for more info on
* Ionic pages and navigation.
*/
@IonicPage()
@Component({
selector: 'page-browse',
templateUrl: 'browse.html',
})
export class BrowsePage {
@ViewChild(InfiniteScroll) infiniteScroll:InfiniteScroll;
@ViewChild(Content) content: Content;
public isOn: boolean = false;
public isCategory: boolean = false;
public courses;
public error:boolean = false;
private loading;
public settings;
public currency;
public exchangeRate;
public params= {
filter:'',
sort:'',
group:'',
type:''
};
public currentPage=1;
public showLoading:boolean = false;
public sortLib ={
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
public catLib = {};
public networkPresent= true;
public showRetry=false;
constructor(public popoverCtrl: PopoverController,public app:App,public navCtrl: NavController, public navParams: NavParams, private apiService:ApiProvider,public loadingController: LoadingController,public toastController: ToastController,public settingService:SettingsProvider,public actionSheetController: ActionSheetController,public network:Network) {
// this.params = {
// filter:'',
// sort:'',
// group:'',
// type:''
// };
}
private clearParams(){
this.params = {
filter:'',
sort:'',
group:'',
type:'',
};
}
async ionViewWillEnter(){
this.currency = await this.settingService.getCurrency();
console.log('Entered browse view');
}
async ngOnInit() {
this.params = {
filter:'',
sort:'',
group:'',
type:''
};
this.sortLib = {
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
console.log(this.params);
console.log(this.sortLib);
// let data = await this.settingService.getSetting('widgets');
this.networkCheck();
//get courses
this.showLoading= true;
this.loadCourses(1).subscribe(response=>{
this.courses= response['records'];
console.log(response);
this.currentPage = 1;
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
this.currency = await this.settingService.getCurrency();
this.settingService.getSettings().then(val => {
this.settings = val;
//load category library
for(let i=0; i < this.settings.categories.length; i++){
this.catLib[this.settings.categories[i].session_category_id] = this.settings.categories[i].category_name;
}
console.log('showing cat lib');
console.log(this.catLib);
// let currency = val.student_currency;
// //get exchange rate for currency
// let currencyList = val.currencies;
// let currencyObj:any;
// for(let i=0; i<currencyList.length;i++){
// let obj = currencyList[i];
// if(obj.currency_id==currency){
// currencyObj = obj;
// }
// }
// this.currency = currencyObj;
});
}
networkCheck(){
// watch network for a disconnection
let disconnectSubscription = this.network.onDisconnect().subscribe(() => {
console.log('network was disconnected :-(');
this.networkPresent= false;
});
// stop disconnect watch
disconnectSubscription.unsubscribe();
// watch network for a connection
let connectSubscription = this.network.onConnect().subscribe(() => {
console.log('network connected!');
// We just got a connection but we need to wait briefly
// before we determine the connection type. Might need to wait.
// prior to doing any api requests as well.
setTimeout(() => {
if (this.network.type === 'wifi') |
}, 3000);
});
}
search(){
this.showLoading = true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
private loadCourses(page){
this.showRetry= false;
// this.currentPage = page;
//this.infiniteScroll.enable(true);
return this.apiService.getSessions(page,30,this.params.group,this.params.filter,this.params.sort,this.params.type);
}
async presentLoading() {
this.loading = await this.loadingController.create({
content: 'Loading. Please wait...',
duration: 2000000000
});
return await this.loading.present();
}
getButtonText(): string {
return `Switch ${ this.isOn ? 'Off' : 'On' }`;
}
setState(): void {
this.isOn = !this.isOn;
}
toggleCategory(){
this.content.scrollToTop();
this.isCategory = !this.isCategory;
}
toggleDetails() {
this.isOn = !this.isOn;
if(!this.isOn && this.params.filter != ""){
this.params.filter = "";
this.showLoading= true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading= false;
});
}
}
clearSearch(){
console.log('clear clicked');
}
loadData(event){
this.currentPage++;
console.log('scroll starting: '+this.currentPage);
this.loadCourses(this.currentPage).subscribe(response=>{
//console.log(response['records']);
this.courses= this.courses.concat(response['records']);
console.log(this.courses);
event.complete();
//determine if this was the last page
let totalPages = Math.ceil((response['total']/response['rows_per_page']));
console.log(totalPages);
if(this.currentPage >= totalPages){
// this.currentPage--;
// event.enable(false);
}
}, err => {
event.complete();
this.presentToast('Network error! Please check your Internet Connection and try again');
console.log(err.message);
})
}
reloadCourses(page){
this.content.scrollToTop();
this.showLoading=true;
this.currentPage=page;
this.loadCourses(page).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading=false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
async presentActionSheet() {
const actionSheet = await this.actionSheetController.create({
title: 'Sort By',
buttons: [{
text: 'Alphabetical (asc)',
icon: 'arrow-round-up',
handler: () => {
this.params.sort = "asc";
this.reloadCourses(1);
}
}, {
text: 'Alphabetical (desc)',
icon: 'arrow-round-down',
handler: () => {
this.params.sort = "desc";
this.reloadCourses(1);
}
}, {
text: 'Most Recent',
icon: 'time',
handler: () => {
this.params.sort = "recent";
this.reloadCourses(1);
}
}, {
text: 'Price (Lowest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceAsc";
this.reloadCourses(1);
}
},{
text: 'Price (Highest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceDesc";
this.reloadCourses(1);
}
},
{
text: 'Online Courses',
icon: 'globe',
handler: () => {
this.params.type = "c";
this.reloadCourses(1);
}
},{
text: 'Training Sessions',
icon: 'people',
handler: () => {
this.params.type = "s-b";
this.reloadCourses(1);
}
}, {
text: 'Reset',
icon: 'refresh',
handler: () => {
this.params.type = "";
this.params.sort = "";
this.reloadCourses(1);
}
}]
});
await actionSheet.present();
}
loadCategory(category){
this.params.group= category;
this.isCategory = false;
this.reloadCourses(1);
}
async presentToast(message:string) {
const toast = await this.toastController.create({
message: message,
duration: 3000
});
toast.present();
}
| {
console.log('we got a wifi connection, woohoo!');
this.networkPresent= true;
} | conditional_block |
browse.ts | /api';
import { SettingsProvider } from '../../../providers/settings/settings';
import { Network } from '@ionic-native/network';
import { CoursePage } from '../course/course';
/**
* Generated class for the BrowsePage page.
*
* See https://ionicframework.com/docs/components/#navigation for more info on
* Ionic pages and navigation.
*/
@IonicPage()
@Component({
selector: 'page-browse',
templateUrl: 'browse.html',
})
export class BrowsePage {
@ViewChild(InfiniteScroll) infiniteScroll:InfiniteScroll;
@ViewChild(Content) content: Content;
public isOn: boolean = false;
public isCategory: boolean = false;
public courses;
public error:boolean = false;
private loading;
public settings;
public currency;
public exchangeRate;
public params= {
filter:'',
sort:'',
group:'',
type:''
};
public currentPage=1;
public showLoading:boolean = false;
public sortLib ={
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
public catLib = {};
public networkPresent= true;
public showRetry=false;
constructor(public popoverCtrl: PopoverController,public app:App,public navCtrl: NavController, public navParams: NavParams, private apiService:ApiProvider,public loadingController: LoadingController,public toastController: ToastController,public settingService:SettingsProvider,public actionSheetController: ActionSheetController,public network:Network) {
// this.params = {
// filter:'',
// sort:'',
// group:'',
// type:''
// };
}
private clearParams(){
this.params = {
filter:'',
sort:'',
group:'',
type:'',
};
}
async ionViewWillEnter(){
this.currency = await this.settingService.getCurrency();
console.log('Entered browse view');
}
async ngOnInit() {
this.params = {
filter:'',
sort:'', | type:''
};
this.sortLib = {
asc : "Alphabetical (asc)",
desc: "Alphabetical (desc)",
recent : "Most Recent",
priceAsc : "Price (Lowest)",
priceDesc : "Price (Highest)",
c : "Online Courses",
"s-b" : "Training Sessions"
};
console.log(this.params);
console.log(this.sortLib);
// let data = await this.settingService.getSetting('widgets');
this.networkCheck();
//get courses
this.showLoading= true;
this.loadCourses(1).subscribe(response=>{
this.courses= response['records'];
console.log(response);
this.currentPage = 1;
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
this.currency = await this.settingService.getCurrency();
this.settingService.getSettings().then(val => {
this.settings = val;
//load category library
for(let i=0; i < this.settings.categories.length; i++){
this.catLib[this.settings.categories[i].session_category_id] = this.settings.categories[i].category_name;
}
console.log('showing cat lib');
console.log(this.catLib);
// let currency = val.student_currency;
// //get exchange rate for currency
// let currencyList = val.currencies;
// let currencyObj:any;
// for(let i=0; i<currencyList.length;i++){
// let obj = currencyList[i];
// if(obj.currency_id==currency){
// currencyObj = obj;
// }
// }
// this.currency = currencyObj;
});
}
networkCheck(){
// watch network for a disconnection
let disconnectSubscription = this.network.onDisconnect().subscribe(() => {
console.log('network was disconnected :-(');
this.networkPresent= false;
});
// stop disconnect watch
disconnectSubscription.unsubscribe();
// watch network for a connection
let connectSubscription = this.network.onConnect().subscribe(() => {
console.log('network connected!');
// We just got a connection but we need to wait briefly
// before we determine the connection type. Might need to wait.
// prior to doing any api requests as well.
setTimeout(() => {
if (this.network.type === 'wifi') {
console.log('we got a wifi connection, woohoo!');
this.networkPresent= true;
}
}, 3000);
});
}
search(){
this.showLoading = true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading = false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
private loadCourses(page){
this.showRetry= false;
// this.currentPage = page;
//this.infiniteScroll.enable(true);
return this.apiService.getSessions(page,30,this.params.group,this.params.filter,this.params.sort,this.params.type);
}
async presentLoading() {
this.loading = await this.loadingController.create({
content: 'Loading. Please wait...',
duration: 2000000000
});
return await this.loading.present();
}
getButtonText(): string {
return `Switch ${ this.isOn ? 'Off' : 'On' }`;
}
setState(): void {
this.isOn = !this.isOn;
}
toggleCategory(){
this.content.scrollToTop();
this.isCategory = !this.isCategory;
}
toggleDetails() {
this.isOn = !this.isOn;
if(!this.isOn && this.params.filter != ""){
this.params.filter = "";
this.showLoading= true;
this.loadCourses(1).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading= false;
});
}
}
clearSearch(){
console.log('clear clicked');
}
loadData(event){
this.currentPage++;
console.log('scroll starting: '+this.currentPage);
this.loadCourses(this.currentPage).subscribe(response=>{
//console.log(response['records']);
this.courses= this.courses.concat(response['records']);
console.log(this.courses);
event.complete();
//determine if this was the last page
let totalPages = Math.ceil((response['total']/response['rows_per_page']));
console.log(totalPages);
if(this.currentPage >= totalPages){
// this.currentPage--;
// event.enable(false);
}
}, err => {
event.complete();
this.presentToast('Network error! Please check your Internet Connection and try again');
console.log(err.message);
})
}
reloadCourses(page){
this.content.scrollToTop();
this.showLoading=true;
this.currentPage=page;
this.loadCourses(page).subscribe(resp=>{
this.courses = resp['records'];
this.showLoading=false;
}, err => {
this.showRetry = true;
this.showLoading= false;
this.presentToast('Network error! Please check your Internet connection');
console.log(err.message);
});
}
async presentActionSheet() {
const actionSheet = await this.actionSheetController.create({
title: 'Sort By',
buttons: [{
text: 'Alphabetical (asc)',
icon: 'arrow-round-up',
handler: () => {
this.params.sort = "asc";
this.reloadCourses(1);
}
}, {
text: 'Alphabetical (desc)',
icon: 'arrow-round-down',
handler: () => {
this.params.sort = "desc";
this.reloadCourses(1);
}
}, {
text: 'Most Recent',
icon: 'time',
handler: () => {
this.params.sort = "recent";
this.reloadCourses(1);
}
}, {
text: 'Price (Lowest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceAsc";
this.reloadCourses(1);
}
},{
text: 'Price (Highest)',
icon: 'cash',
handler: () => {
this.params.sort = "priceDesc";
this.reloadCourses(1);
}
},
{
text: 'Online Courses',
icon: 'globe',
handler: () => {
this.params.type = "c";
this.reloadCourses(1);
}
},{
text: 'Training Sessions',
icon: 'people',
handler: () => {
this.params.type = "s-b";
this.reloadCourses(1);
}
}, {
text: 'Reset',
icon: 'refresh',
handler: () => {
this.params.type = "";
this.params.sort = "";
this.reloadCourses(1);
}
}]
});
await actionSheet.present();
}
loadCategory(category){
this.params.group= category;
this.isCategory = false;
this.reloadCourses(1);
}
async presentToast(message:string) {
const toast = await this.toastController.create({
message: message,
duration: 3000
});
toast.present();
}
| group:'', | random_line_split |
lib.rs | coords.iter().copied().collect() }
}
}
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum ConwayCube {
Void,
Inactive,
Active,
}
impl ConwayCube {
/// Construct cube from input character.
#[must_use]
pub fn from_char(cube: char) -> ConwayCube {
match cube {
'.' => ConwayCube::Inactive,
'#' => ConwayCube::Active,
_ => {
let e = format!("invalid cube character {}", cube);
panic!(e);
}
}
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct InfiniteGrid {
cubes: Vec<ConwayCube>,
dim: usize,
edge: i32,
}
impl fmt::Display for InfiniteGrid {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let half_edge = self.edge / 2;
let mut s = String::new();
for coords in (0..self.dim).map(|_i| 0..self.edge).multi_cartesian_product() {
if coords[self.dim - 2] == 0 && coords[self.dim - 1] == 0 {
let axes = vec!['z', 'w', 'v', 'u'];
for d in 2..self.dim {
if d > 2 {
s += ", ";
}
let label = format!("{}={}", axes[d - 2], coords[self.dim - d - 1] - half_edge);
s += &label;
}
s += "\n";
}
let pos = Position::from(&coords);
s += match self.cube_at(&pos) {
ConwayCube::Void => "_",
ConwayCube::Inactive => ".",
ConwayCube::Active => "#",
};
if coords[self.dim - 1] >= self.edge - 1 {
s += "\n";
}
}
write!(f, "{}", s)
}
}
pub struct InfiniteGridIter {
layout: InfiniteGrid,
}
impl Iterator for InfiniteGridIter {
type Item = InfiniteGrid;
fn next(&mut self) -> Option<Self::Item> {
let prev_layout = self.layout.clone();
self.layout = prev_layout.cube_round();
Some(self.layout.clone())
}
}
impl InfiniteGrid {
/// Return edge length.
#[must_use]
pub fn edge(&self) -> i32 {
self.edge
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from file at `path`.
///
/// # Errors
///
/// Returns `Err` if the input file cannot be opened, or if line is
/// found with invalid format.
pub fn read_from_file(path: &str, dim: usize) -> Result<InfiniteGrid> {
let s: String = fs::read_to_string(path)?;
InfiniteGrid::from_input(&s, dim)
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from `input` string.
///
/// # Errors
///
/// Returns `Err` if a line is found with invalid format.
pub fn from_input(input: &str, dim: usize) -> Result<InfiniteGrid> {
let edge = i32::try_from(input.lines().next().unwrap().len()).unwrap();
let half_edge = edge / 2;
// parse and store initial 2D grid plane:
let cubes_2d: Vec<ConwayCube> = input
.lines()
.flat_map(|line| line.trim().chars().map(ConwayCube::from_char))
.collect();
// create empty nD grid, and copy initial 2D grid plane to it
// (in the middle of each dimension beyond the first two):
let max_i = InfiniteGrid::index_size(edge, dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for y in 0..edge {
for x in 0..edge {
let from_i = usize::try_from(y * edge + x).unwrap();
let mut dims = vec![half_edge; dim];
dims[dim-1] = x;
dims[dim-2] = y;
let to_i = Position::from(&dims).index_for(edge);
cubes[to_i] = cubes_2d[from_i];
}
}
Ok(Self { cubes, dim, edge })
}
#[must_use]
fn index_size(edge: i32, dim: usize) -> usize {
let mut s = 1_i32;
for _i in 0..dim {
s *= edge;
}
usize::try_from(s).unwrap()
}
#[must_use]
pub fn iter(&self) -> InfiniteGridIter {
InfiniteGridIter {
layout: self.clone(),
}
}
/// Return `ConwayCube` at the given position.
#[must_use]
pub fn cube_at(&self, pos: &Position) -> ConwayCube {
for c in &pos.coords {
if *c < 0 || *c >= self.edge {
return ConwayCube::Void;
}
}
self.cubes[pos.index_for(self.edge)]
}
/// Return count of active cubes.
#[must_use]
pub fn active_cubes(&self) -> usize {
self.cubes.iter().filter(|&c| *c == ConwayCube::Active).count()
}
/// Return count of active neighbor cubes of the cube at the given
/// position.
#[must_use]
pub fn active_neighbors_at(&self, pos: &Position) -> usize {
let mut n_active: usize = 0;
for deltas in (0..self.dim).map(|_i| -1..=1).multi_cartesian_product() {
if deltas.iter().all(|dc| *dc == 0) {
continue;
}
let d_coords: Vec<i32> = pos.coords
.iter()
.enumerate()
.map(|(i, dc)| *dc + deltas[i])
.collect();
let d_pos = Position::from(&d_coords);
if self.cube_at(&d_pos) == ConwayCube::Active {
n_active += 1;
}
}
n_active
}
/// Do one round of cube life. Returns a new grid which is one unit
/// bigger in all directions (its edge increases by 2 in all
/// dimensions).
#[must_use]
pub fn cube_round(&self) -> InfiniteGrid {
let edge = self.edge + 2;
let max_i = InfiniteGrid::index_size(edge, self.dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for coords in (0..self.dim).map(|_i| 0..edge).multi_cartesian_product() {
let from_coords: Vec<i32> = coords.iter().map(|c| c - 1).collect();
let from_pos = Position::from(&from_coords);
let pos = Position::from(&coords);
cubes[pos.index_for(edge)] = self.new_cube_at(&from_pos);
}
InfiniteGrid { cubes, dim: self.dim, edge }
}
fn new_cube_at(&self, pos: &Position) -> ConwayCube {
match self.cube_at(&pos) {
ConwayCube::Active => {
let n = self.active_neighbors_at(&pos);
if n == 2 || n == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
_ => {
if self.active_neighbors_at(&pos) == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const TINY_LAYOUT: &'static str = ".#.\n..#\n###\n";
#[test]
fn test_from_input() |
#[test]
fn test_grid_indexing() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, 0, 1]);
assert_eq!(ConwayCube::Active, grid.cube_at(&pos));
let pos = Position::from(&[1, 1, 0]);
assert_eq!(ConwayCube::Inactive, grid.cube_at(&pos));
let pos = Position::from(&[0, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_z() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[-1, 0, 1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[3, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_y | {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
assert_eq!(3, grid.edge);
assert_eq!(5, grid.active_cubes());
} | identifier_body |
lib.rs | : coords.iter().copied().collect() }
}
}
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum ConwayCube {
Void,
Inactive,
Active,
}
impl ConwayCube {
/// Construct cube from input character.
#[must_use]
pub fn from_char(cube: char) -> ConwayCube {
match cube {
'.' => ConwayCube::Inactive,
'#' => ConwayCube::Active,
_ => {
let e = format!("invalid cube character {}", cube);
panic!(e);
}
}
}
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct InfiniteGrid {
cubes: Vec<ConwayCube>,
dim: usize,
edge: i32,
}
impl fmt::Display for InfiniteGrid {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let half_edge = self.edge / 2;
let mut s = String::new();
for coords in (0..self.dim).map(|_i| 0..self.edge).multi_cartesian_product() {
if coords[self.dim - 2] == 0 && coords[self.dim - 1] == 0 {
let axes = vec!['z', 'w', 'v', 'u'];
for d in 2..self.dim {
if d > 2 {
s += ", ";
}
let label = format!("{}={}", axes[d - 2], coords[self.dim - d - 1] - half_edge);
s += &label;
}
s += "\n";
}
let pos = Position::from(&coords);
s += match self.cube_at(&pos) {
ConwayCube::Void => "_",
ConwayCube::Inactive => ".",
ConwayCube::Active => "#",
};
if coords[self.dim - 1] >= self.edge - 1 {
s += "\n";
}
}
write!(f, "{}", s)
}
}
pub struct InfiniteGridIter {
layout: InfiniteGrid,
}
impl Iterator for InfiniteGridIter {
type Item = InfiniteGrid;
fn next(&mut self) -> Option<Self::Item> {
let prev_layout = self.layout.clone();
self.layout = prev_layout.cube_round();
Some(self.layout.clone())
}
}
impl InfiniteGrid {
/// Return edge length.
#[must_use]
pub fn edge(&self) -> i32 {
self.edge
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from file at `path`.
///
/// # Errors
///
/// Returns `Err` if the input file cannot be opened, or if line is
/// found with invalid format.
pub fn read_from_file(path: &str, dim: usize) -> Result<InfiniteGrid> {
let s: String = fs::read_to_string(path)?;
InfiniteGrid::from_input(&s, dim)
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from `input` string.
///
/// # Errors
///
/// Returns `Err` if a line is found with invalid format.
pub fn from_input(input: &str, dim: usize) -> Result<InfiniteGrid> {
let edge = i32::try_from(input.lines().next().unwrap().len()).unwrap();
let half_edge = edge / 2;
// parse and store initial 2D grid plane:
let cubes_2d: Vec<ConwayCube> = input | // create empty nD grid, and copy initial 2D grid plane to it
// (in the middle of each dimension beyond the first two):
let max_i = InfiniteGrid::index_size(edge, dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for y in 0..edge {
for x in 0..edge {
let from_i = usize::try_from(y * edge + x).unwrap();
let mut dims = vec![half_edge; dim];
dims[dim-1] = x;
dims[dim-2] = y;
let to_i = Position::from(&dims).index_for(edge);
cubes[to_i] = cubes_2d[from_i];
}
}
Ok(Self { cubes, dim, edge })
}
#[must_use]
fn index_size(edge: i32, dim: usize) -> usize {
let mut s = 1_i32;
for _i in 0..dim {
s *= edge;
}
usize::try_from(s).unwrap()
}
#[must_use]
pub fn iter(&self) -> InfiniteGridIter {
InfiniteGridIter {
layout: self.clone(),
}
}
/// Return `ConwayCube` at the given position.
#[must_use]
pub fn cube_at(&self, pos: &Position) -> ConwayCube {
for c in &pos.coords {
if *c < 0 || *c >= self.edge {
return ConwayCube::Void;
}
}
self.cubes[pos.index_for(self.edge)]
}
/// Return count of active cubes.
#[must_use]
pub fn active_cubes(&self) -> usize {
self.cubes.iter().filter(|&c| *c == ConwayCube::Active).count()
}
/// Return count of active neighbor cubes of the cube at the given
/// position.
#[must_use]
pub fn active_neighbors_at(&self, pos: &Position) -> usize {
let mut n_active: usize = 0;
for deltas in (0..self.dim).map(|_i| -1..=1).multi_cartesian_product() {
if deltas.iter().all(|dc| *dc == 0) {
continue;
}
let d_coords: Vec<i32> = pos.coords
.iter()
.enumerate()
.map(|(i, dc)| *dc + deltas[i])
.collect();
let d_pos = Position::from(&d_coords);
if self.cube_at(&d_pos) == ConwayCube::Active {
n_active += 1;
}
}
n_active
}
/// Do one round of cube life. Returns a new grid which is one unit
/// bigger in all directions (its edge increases by 2 in all
/// dimensions).
#[must_use]
pub fn cube_round(&self) -> InfiniteGrid {
let edge = self.edge + 2;
let max_i = InfiniteGrid::index_size(edge, self.dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for coords in (0..self.dim).map(|_i| 0..edge).multi_cartesian_product() {
let from_coords: Vec<i32> = coords.iter().map(|c| c - 1).collect();
let from_pos = Position::from(&from_coords);
let pos = Position::from(&coords);
cubes[pos.index_for(edge)] = self.new_cube_at(&from_pos);
}
InfiniteGrid { cubes, dim: self.dim, edge }
}
fn new_cube_at(&self, pos: &Position) -> ConwayCube {
match self.cube_at(&pos) {
ConwayCube::Active => {
let n = self.active_neighbors_at(&pos);
if n == 2 || n == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
_ => {
if self.active_neighbors_at(&pos) == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const TINY_LAYOUT: &'static str = ".#.\n..#\n###\n";
#[test]
fn test_from_input() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
assert_eq!(3, grid.edge);
assert_eq!(5, grid.active_cubes());
}
#[test]
fn test_grid_indexing() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, 0, 1]);
assert_eq!(ConwayCube::Active, grid.cube_at(&pos));
let pos = Position::from(&[1, 1, 0]);
assert_eq!(ConwayCube::Inactive, grid.cube_at(&pos));
let pos = Position::from(&[0, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_z() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[-1, 0, 1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[3, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_y() {
| .lines()
.flat_map(|line| line.trim().chars().map(ConwayCube::from_char))
.collect(); | random_line_split |
lib.rs | ={}", axes[d - 2], coords[self.dim - d - 1] - half_edge);
s += &label;
}
s += "\n";
}
let pos = Position::from(&coords);
s += match self.cube_at(&pos) {
ConwayCube::Void => "_",
ConwayCube::Inactive => ".",
ConwayCube::Active => "#",
};
if coords[self.dim - 1] >= self.edge - 1 {
s += "\n";
}
}
write!(f, "{}", s)
}
}
pub struct InfiniteGridIter {
layout: InfiniteGrid,
}
impl Iterator for InfiniteGridIter {
type Item = InfiniteGrid;
fn next(&mut self) -> Option<Self::Item> {
let prev_layout = self.layout.clone();
self.layout = prev_layout.cube_round();
Some(self.layout.clone())
}
}
impl InfiniteGrid {
/// Return edge length.
#[must_use]
pub fn edge(&self) -> i32 {
self.edge
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from file at `path`.
///
/// # Errors
///
/// Returns `Err` if the input file cannot be opened, or if line is
/// found with invalid format.
pub fn read_from_file(path: &str, dim: usize) -> Result<InfiniteGrid> {
let s: String = fs::read_to_string(path)?;
InfiniteGrid::from_input(&s, dim)
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from `input` string.
///
/// # Errors
///
/// Returns `Err` if a line is found with invalid format.
pub fn from_input(input: &str, dim: usize) -> Result<InfiniteGrid> {
let edge = i32::try_from(input.lines().next().unwrap().len()).unwrap();
let half_edge = edge / 2;
// parse and store initial 2D grid plane:
let cubes_2d: Vec<ConwayCube> = input
.lines()
.flat_map(|line| line.trim().chars().map(ConwayCube::from_char))
.collect();
// create empty nD grid, and copy initial 2D grid plane to it
// (in the middle of each dimension beyond the first two):
let max_i = InfiniteGrid::index_size(edge, dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for y in 0..edge {
for x in 0..edge {
let from_i = usize::try_from(y * edge + x).unwrap();
let mut dims = vec![half_edge; dim];
dims[dim-1] = x;
dims[dim-2] = y;
let to_i = Position::from(&dims).index_for(edge);
cubes[to_i] = cubes_2d[from_i];
}
}
Ok(Self { cubes, dim, edge })
}
#[must_use]
fn index_size(edge: i32, dim: usize) -> usize {
let mut s = 1_i32;
for _i in 0..dim {
s *= edge;
}
usize::try_from(s).unwrap()
}
#[must_use]
pub fn iter(&self) -> InfiniteGridIter {
InfiniteGridIter {
layout: self.clone(),
}
}
/// Return `ConwayCube` at the given position.
#[must_use]
pub fn cube_at(&self, pos: &Position) -> ConwayCube {
for c in &pos.coords {
if *c < 0 || *c >= self.edge {
return ConwayCube::Void;
}
}
self.cubes[pos.index_for(self.edge)]
}
/// Return count of active cubes.
#[must_use]
pub fn active_cubes(&self) -> usize {
self.cubes.iter().filter(|&c| *c == ConwayCube::Active).count()
}
/// Return count of active neighbor cubes of the cube at the given
/// position.
#[must_use]
pub fn active_neighbors_at(&self, pos: &Position) -> usize {
let mut n_active: usize = 0;
for deltas in (0..self.dim).map(|_i| -1..=1).multi_cartesian_product() {
if deltas.iter().all(|dc| *dc == 0) {
continue;
}
let d_coords: Vec<i32> = pos.coords
.iter()
.enumerate()
.map(|(i, dc)| *dc + deltas[i])
.collect();
let d_pos = Position::from(&d_coords);
if self.cube_at(&d_pos) == ConwayCube::Active {
n_active += 1;
}
}
n_active
}
/// Do one round of cube life. Returns a new grid which is one unit
/// bigger in all directions (its edge increases by 2 in all
/// dimensions).
#[must_use]
pub fn cube_round(&self) -> InfiniteGrid {
let edge = self.edge + 2;
let max_i = InfiniteGrid::index_size(edge, self.dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for coords in (0..self.dim).map(|_i| 0..edge).multi_cartesian_product() {
let from_coords: Vec<i32> = coords.iter().map(|c| c - 1).collect();
let from_pos = Position::from(&from_coords);
let pos = Position::from(&coords);
cubes[pos.index_for(edge)] = self.new_cube_at(&from_pos);
}
InfiniteGrid { cubes, dim: self.dim, edge }
}
fn new_cube_at(&self, pos: &Position) -> ConwayCube {
match self.cube_at(&pos) {
ConwayCube::Active => {
let n = self.active_neighbors_at(&pos);
if n == 2 || n == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
_ => {
if self.active_neighbors_at(&pos) == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const TINY_LAYOUT: &'static str = ".#.\n..#\n###\n";
#[test]
fn test_from_input() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
assert_eq!(3, grid.edge);
assert_eq!(5, grid.active_cubes());
}
#[test]
fn test_grid_indexing() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, 0, 1]);
assert_eq!(ConwayCube::Active, grid.cube_at(&pos));
let pos = Position::from(&[1, 1, 0]);
assert_eq!(ConwayCube::Inactive, grid.cube_at(&pos));
let pos = Position::from(&[0, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_z() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[-1, 0, 1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[3, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_y() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, -1, 1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[1, 3, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_x() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, 0, -1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[1, 1, 3]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_6_rounds() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let mut n_active: usize = 0;
for (i, g) in grid.iter().enumerate() {
if i >= N_ROUNDS - 1 {
n_active = g.active_cubes();
break;
}
}
assert_eq!(112, n_active);
}
#[test]
fn | test_6_rounds_4d | identifier_name |
|
lib.rs | Iter {
layout: InfiniteGrid,
}
impl Iterator for InfiniteGridIter {
type Item = InfiniteGrid;
fn next(&mut self) -> Option<Self::Item> {
let prev_layout = self.layout.clone();
self.layout = prev_layout.cube_round();
Some(self.layout.clone())
}
}
impl InfiniteGrid {
/// Return edge length.
#[must_use]
pub fn edge(&self) -> i32 {
self.edge
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from file at `path`.
///
/// # Errors
///
/// Returns `Err` if the input file cannot be opened, or if line is
/// found with invalid format.
pub fn read_from_file(path: &str, dim: usize) -> Result<InfiniteGrid> {
let s: String = fs::read_to_string(path)?;
InfiniteGrid::from_input(&s, dim)
}
/// Construct `InfiniteGrid` of dimension `dim` by reading initial grid
/// plane from `input` string.
///
/// # Errors
///
/// Returns `Err` if a line is found with invalid format.
pub fn from_input(input: &str, dim: usize) -> Result<InfiniteGrid> {
let edge = i32::try_from(input.lines().next().unwrap().len()).unwrap();
let half_edge = edge / 2;
// parse and store initial 2D grid plane:
let cubes_2d: Vec<ConwayCube> = input
.lines()
.flat_map(|line| line.trim().chars().map(ConwayCube::from_char))
.collect();
// create empty nD grid, and copy initial 2D grid plane to it
// (in the middle of each dimension beyond the first two):
let max_i = InfiniteGrid::index_size(edge, dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for y in 0..edge {
for x in 0..edge {
let from_i = usize::try_from(y * edge + x).unwrap();
let mut dims = vec![half_edge; dim];
dims[dim-1] = x;
dims[dim-2] = y;
let to_i = Position::from(&dims).index_for(edge);
cubes[to_i] = cubes_2d[from_i];
}
}
Ok(Self { cubes, dim, edge })
}
#[must_use]
fn index_size(edge: i32, dim: usize) -> usize {
let mut s = 1_i32;
for _i in 0..dim {
s *= edge;
}
usize::try_from(s).unwrap()
}
#[must_use]
pub fn iter(&self) -> InfiniteGridIter {
InfiniteGridIter {
layout: self.clone(),
}
}
/// Return `ConwayCube` at the given position.
#[must_use]
pub fn cube_at(&self, pos: &Position) -> ConwayCube {
for c in &pos.coords {
if *c < 0 || *c >= self.edge {
return ConwayCube::Void;
}
}
self.cubes[pos.index_for(self.edge)]
}
/// Return count of active cubes.
#[must_use]
pub fn active_cubes(&self) -> usize {
self.cubes.iter().filter(|&c| *c == ConwayCube::Active).count()
}
/// Return count of active neighbor cubes of the cube at the given
/// position.
#[must_use]
pub fn active_neighbors_at(&self, pos: &Position) -> usize {
let mut n_active: usize = 0;
for deltas in (0..self.dim).map(|_i| -1..=1).multi_cartesian_product() {
if deltas.iter().all(|dc| *dc == 0) {
continue;
}
let d_coords: Vec<i32> = pos.coords
.iter()
.enumerate()
.map(|(i, dc)| *dc + deltas[i])
.collect();
let d_pos = Position::from(&d_coords);
if self.cube_at(&d_pos) == ConwayCube::Active {
n_active += 1;
}
}
n_active
}
/// Do one round of cube life. Returns a new grid which is one unit
/// bigger in all directions (its edge increases by 2 in all
/// dimensions).
#[must_use]
pub fn cube_round(&self) -> InfiniteGrid {
let edge = self.edge + 2;
let max_i = InfiniteGrid::index_size(edge, self.dim);
let mut cubes: Vec<ConwayCube> = vec![ConwayCube::Void; max_i];
for coords in (0..self.dim).map(|_i| 0..edge).multi_cartesian_product() {
let from_coords: Vec<i32> = coords.iter().map(|c| c - 1).collect();
let from_pos = Position::from(&from_coords);
let pos = Position::from(&coords);
cubes[pos.index_for(edge)] = self.new_cube_at(&from_pos);
}
InfiniteGrid { cubes, dim: self.dim, edge }
}
fn new_cube_at(&self, pos: &Position) -> ConwayCube {
match self.cube_at(&pos) {
ConwayCube::Active => {
let n = self.active_neighbors_at(&pos);
if n == 2 || n == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
_ => {
if self.active_neighbors_at(&pos) == 3 {
ConwayCube::Active
} else {
ConwayCube::Inactive
}
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const TINY_LAYOUT: &'static str = ".#.\n..#\n###\n";
#[test]
fn test_from_input() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
assert_eq!(3, grid.edge);
assert_eq!(5, grid.active_cubes());
}
#[test]
fn test_grid_indexing() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, 0, 1]);
assert_eq!(ConwayCube::Active, grid.cube_at(&pos));
let pos = Position::from(&[1, 1, 0]);
assert_eq!(ConwayCube::Inactive, grid.cube_at(&pos));
let pos = Position::from(&[0, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_z() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[-1, 0, 1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[3, 1, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_y() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, -1, 1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[1, 3, 0]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_grid_indexing_void_x() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let pos = Position::from(&[1, 0, -1]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
let pos = Position::from(&[1, 1, 3]);
assert_eq!(ConwayCube::Void, grid.cube_at(&pos));
}
#[test]
fn test_6_rounds() {
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 3).unwrap();
let mut n_active: usize = 0;
for (i, g) in grid.iter().enumerate() {
if i >= N_ROUNDS - 1 {
n_active = g.active_cubes();
break;
}
}
assert_eq!(112, n_active);
}
#[test]
fn test_6_rounds_4d() {
// the full N_ROUNDS takes a while so:
let n_rounds = 1; // = N_ROUNDS;
let grid = InfiniteGrid::from_input(TINY_LAYOUT, 4).unwrap();
let mut n_active: usize = 0;
for (i, g) in grid.iter().enumerate() {
if i >= n_rounds - 1 {
n_active = g.active_cubes();
break;
}
}
let expect = if n_rounds == 1 | { 3*4 + 5 + 3*4 } | conditional_block |
|
encoder.rs | om_codec_cx_pkt_kind::AOM_CODEC_CUSTOM_PKT => {
let b = to_buffer(unsafe { pkt.data.raw });
AOMPacket::Custom(b)
}
_ => panic!("No packet defined"),
}
}
}
#[cfg(target_os = "windows")]
fn map_fmt_to_img(img: &mut aom_image, fmt: &Formaton) {
img.cp = fmt.get_primaries() as i32;
img.tc = fmt.get_xfer() as i32;
img.mc = fmt.get_matrix() as i32;
}
#[cfg(not(target_os = "windows"))]
fn map_fmt_to_img(img: &mut aom_image, fmt: &Formaton) {
img.cp = fmt.get_primaries() as u32;
img.tc = fmt.get_xfer() as u32;
img.mc = fmt.get_matrix() as u32;
}
// TODO: Extend
fn map_formaton(img: &mut aom_image, fmt: &Formaton) {
if fmt == YUV420 {
img.fmt = aom_img_fmt::AOM_IMG_FMT_I420;
} else {
unimplemented!();
}
img.bit_depth = 8;
img.bps = 12;
img.x_chroma_shift = 1;
img.y_chroma_shift = 1;
map_fmt_to_img(img, fmt);
}
fn img_from_frame(frame: &Frame) -> aom_image {
let mut img: aom_image = unsafe { mem::zeroed() };
if let MediaKind::Video(ref v) = frame.kind {
map_formaton(&mut img, &v.format);
img.w = v.width as u32;
img.h = v.height as u32;
img.d_w = v.width as u32;
img.d_h = v.height as u32;
}
// populate the buffers
for i in 0..frame.buf.count() {
let s: &[u8] = frame.buf.as_slice(i).unwrap();
img.planes[i] = s.as_ptr() as *mut u8;
img.stride[i] = frame.buf.linesize(i).unwrap() as i32;
}
img
}
/// AV1 Encoder
pub struct AV1Encoder {
pub(crate) ctx: aom_codec_ctx_t,
pub(crate) iter: aom_codec_iter_t,
}
unsafe impl Send for AV1Encoder {} // TODO: Make sure it cannot be abused
impl AV1Encoder {
/// Create a new encoder using the provided configuration
///
/// You may use `get_encoder` instead.
pub fn new(cfg: &mut AV1EncoderConfig) -> Result<AV1Encoder, aom_codec_err_t::Type> {
let mut ctx = MaybeUninit::uninit();
let ret = unsafe {
aom_codec_enc_init_ver(
ctx.as_mut_ptr(),
aom_codec_av1_cx(),
cfg.cfg(),
0,
AOM_ENCODER_ABI_VERSION as i32,
)
};
match ret {
aom_codec_err_t::AOM_CODEC_OK => {
let ctx = unsafe { ctx.assume_init() };
let mut enc = AV1Encoder {
ctx,
iter: ptr::null(),
};
// Apparently aom 2.0 would crash if a CPUUSED is not set explicitly.
enc.control(aome_enc_control_id::AOME_SET_CPUUSED, 2)
.expect("Cannot set CPUUSED");
Ok(enc)
}
_ => Err(ret),
}
}
/// Update the encoder parameters after-creation
///
/// It calls `aom_codec_control_`
pub fn control(
&mut self,
id: aome_enc_control_id::Type,
val: i32,
) -> Result<(), aom_codec_err_t::Type> {
let ret = unsafe { aom_codec_control(&mut self.ctx, id as i32, val) };
match ret {
aom_codec_err_t::AOM_CODEC_OK => Ok(()),
_ => Err(ret),
}
}
// TODO: Cache the image information
//
/// Send an uncompressed frame to the encoder
///
/// Call [`get_packet`] to receive the compressed data.
///
/// It calls `aom_codec_encode`.
///
/// [`get_packet`]: #method.get_packet
pub fn encode(&mut self, frame: &Frame) -> Result<(), aom_codec_err_t::Type> {
let img = img_from_frame(frame);
let ret = unsafe { aom_codec_encode(&mut self.ctx, &img, frame.t.pts.unwrap(), 1, 0) };
self.iter = ptr::null();
match ret {
aom_codec_err_t::AOM_CODEC_OK => Ok(()),
_ => Err(ret),
}
}
/// Notify the encoder that no more data will be sent
///
/// Call [`get_packet`] to receive the compressed data.
///
/// It calls `aom_codec_encode` with NULL arguments.
///
/// [`get_packet`]: #method.get_packet
pub fn flush(&mut self) -> Result<(), aom_codec_err_t::Type> {
let ret = unsafe { aom_codec_encode(&mut self.ctx, ptr::null_mut(), 0, 1, 0) };
self.iter = ptr::null();
match ret {
aom_codec_err_t::AOM_CODEC_OK => Ok(()),
_ => Err(ret),
}
}
/// Retrieve the compressed data
///
/// To be called until it returns `None`.
///
/// It calls `aom_codec_get_cx_data`.
pub fn get_packet(&mut self) -> Option<AOMPacket> {
let pkt = unsafe { aom_codec_get_cx_data(&mut self.ctx, &mut self.iter) };
if pkt.is_null() {
None
} else {
Some(AOMPacket::new(unsafe { *pkt }))
}
}
}
impl Drop for AV1Encoder {
fn drop(&mut self) {
unsafe { aom_codec_destroy(&mut self.ctx) };
}
}
impl AOMCodec for AV1Encoder {
fn get_context(&mut self) -> &mut aom_codec_ctx {
&mut self.ctx
}
}
#[cfg(feature = "codec-trait")]
mod encoder_trait {
use super::*;
use av_codec::encoder::*;
use av_codec::error::*;
use av_data::frame::ArcFrame;
use av_data::params::{CodecParams, MediaKind, VideoInfo};
use av_data::value::Value;
pub struct Des {
descr: Descr,
}
pub struct Enc {
cfg: AV1EncoderConfig,
enc: Option<AV1Encoder>,
}
impl Descriptor for Des {
type OutputEncoder = Enc;
fn create(&self) -> Self::OutputEncoder {
Enc {
cfg: AV1EncoderConfig::new().unwrap(),
enc: None,
}
}
fn describe(&self) -> &Descr {
&self.descr
}
}
impl Encoder for Enc {
fn | (&mut self) -> Result<()> {
if self.enc.is_none() {
self.cfg
.get_encoder()
.map(|enc| {
self.enc = Some(enc);
})
.map_err(|_err| Error::ConfigurationIncomplete)
} else {
unimplemented!()
}
}
// TODO: have it as default impl?
fn get_extradata(&self) -> Option<Vec<u8>> {
None
}
fn send_frame(&mut self, frame: &ArcFrame) -> Result<()> {
let enc = self.enc.as_mut().unwrap();
enc.encode(frame).map_err(|_| unimplemented!())
}
fn receive_packet(&mut self) -> Result<Packet> {
let enc = self.enc.as_mut().unwrap();
if let Some(p) = enc.get_packet() {
match p {
AOMPacket::Packet(pkt) => Ok(pkt),
_ => unimplemented!(),
}
} else {
Err(Error::MoreDataNeeded)
}
}
fn flush(&mut self) -> Result<()> {
let enc = self.enc.as_mut().unwrap();
enc.flush().map_err(|_| unimplemented!())
}
fn set_option<'a>(&mut self, key: &str, val: Value<'a>) -> Result<()> {
match (key, val) {
("w", Value::U64(v)) => self.cfg.g_w = v as u32,
("h", Value::U64(v)) => self.cfg.g_h = v as u32,
("qmin", Value::U64(v)) => self.cfg.rc_min_quantizer = v as u32,
("qmax", Value::U64(v)) => self.cfg.rc_max_quantizer = v as u32,
("timebase", Value::Pair(num, den)) => {
self.cfg.g_timebase.num = num as i32;
self.cfg.g_timebase.den = den as i32;
}
_ => unimplemented!(),
}
Ok(())
}
fn get_params(&self) -> Result<CodecParams> {
use std::sync::Arc;
Ok(CodecParams {
kind: Some(MediaKind::Video(VideoInfo {
height: self.cfg | configure | identifier_name |
encoder.rs | method.get_packet
pub fn flush(&mut self) -> Result<(), aom_codec_err_t::Type> {
let ret = unsafe { aom_codec_encode(&mut self.ctx, ptr::null_mut(), 0, 1, 0) };
self.iter = ptr::null();
match ret {
aom_codec_err_t::AOM_CODEC_OK => Ok(()),
_ => Err(ret),
}
}
/// Retrieve the compressed data
///
/// To be called until it returns `None`.
///
/// It calls `aom_codec_get_cx_data`.
pub fn get_packet(&mut self) -> Option<AOMPacket> {
let pkt = unsafe { aom_codec_get_cx_data(&mut self.ctx, &mut self.iter) };
if pkt.is_null() {
None
} else {
Some(AOMPacket::new(unsafe { *pkt }))
}
}
}
impl Drop for AV1Encoder {
fn drop(&mut self) {
unsafe { aom_codec_destroy(&mut self.ctx) };
}
}
impl AOMCodec for AV1Encoder {
fn get_context(&mut self) -> &mut aom_codec_ctx {
&mut self.ctx
}
}
#[cfg(feature = "codec-trait")]
mod encoder_trait {
use super::*;
use av_codec::encoder::*;
use av_codec::error::*;
use av_data::frame::ArcFrame;
use av_data::params::{CodecParams, MediaKind, VideoInfo};
use av_data::value::Value;
pub struct Des {
descr: Descr,
}
pub struct Enc {
cfg: AV1EncoderConfig,
enc: Option<AV1Encoder>,
}
impl Descriptor for Des {
type OutputEncoder = Enc;
fn create(&self) -> Self::OutputEncoder {
Enc {
cfg: AV1EncoderConfig::new().unwrap(),
enc: None,
}
}
fn describe(&self) -> &Descr {
&self.descr
}
}
impl Encoder for Enc {
fn configure(&mut self) -> Result<()> {
if self.enc.is_none() {
self.cfg
.get_encoder()
.map(|enc| {
self.enc = Some(enc);
})
.map_err(|_err| Error::ConfigurationIncomplete)
} else {
unimplemented!()
}
}
// TODO: have it as default impl?
fn get_extradata(&self) -> Option<Vec<u8>> {
None
}
fn send_frame(&mut self, frame: &ArcFrame) -> Result<()> {
let enc = self.enc.as_mut().unwrap();
enc.encode(frame).map_err(|_| unimplemented!())
}
fn receive_packet(&mut self) -> Result<Packet> {
let enc = self.enc.as_mut().unwrap();
if let Some(p) = enc.get_packet() {
match p {
AOMPacket::Packet(pkt) => Ok(pkt),
_ => unimplemented!(),
}
} else {
Err(Error::MoreDataNeeded)
}
}
fn flush(&mut self) -> Result<()> {
let enc = self.enc.as_mut().unwrap();
enc.flush().map_err(|_| unimplemented!())
}
fn set_option<'a>(&mut self, key: &str, val: Value<'a>) -> Result<()> {
match (key, val) {
("w", Value::U64(v)) => self.cfg.g_w = v as u32,
("h", Value::U64(v)) => self.cfg.g_h = v as u32,
("qmin", Value::U64(v)) => self.cfg.rc_min_quantizer = v as u32,
("qmax", Value::U64(v)) => self.cfg.rc_max_quantizer = v as u32,
("timebase", Value::Pair(num, den)) => {
self.cfg.g_timebase.num = num as i32;
self.cfg.g_timebase.den = den as i32;
}
_ => unimplemented!(),
}
Ok(())
}
fn get_params(&self) -> Result<CodecParams> {
use std::sync::Arc;
Ok(CodecParams {
kind: Some(MediaKind::Video(VideoInfo {
height: self.cfg.g_h as usize,
width: self.cfg.g_w as usize,
format: Some(Arc::new(*YUV420)), // TODO: support more formats
})),
codec_id: Some("av1".to_owned()),
extradata: None,
bit_rate: 0, // TODO: expose the information
convergence_window: 0,
delay: 0,
})
}
fn set_params(&mut self, params: &CodecParams) -> Result<()> {
if let Some(MediaKind::Video(ref info)) = params.kind {
self.cfg.g_w = info.width as u32;
self.cfg.g_h = info.height as u32;
}
Ok(())
}
}
/// AV1 Encoder
///
/// To be used with [av-codec](https://docs.rs/av-codec) `Encoder Context`.
pub const AV1_DESCR: &Des = &Des {
descr: Descr {
codec: "av1",
name: "aom",
desc: "libaom AV1 encoder",
mime: "video/AV1",
},
};
}
#[cfg(feature = "codec-trait")]
pub use self::encoder_trait::AV1_DESCR;
#[cfg(test)]
pub(crate) mod tests {
use super::*;
#[test]
fn init() {
let mut c = AV1EncoderConfig::new().unwrap();
let mut e = c.get_encoder().unwrap();
println!("{}", e.error_to_str());
}
use av_data::rational::*;
use av_data::timeinfo::TimeInfo;
pub fn setup(w: u32, h: u32, t: &TimeInfo) -> AV1Encoder {
if (w % 2) != 0 || (h % 2) != 0 {
panic!("Invalid frame size: w: {} h: {}", w, h);
}
let mut cfg = AV1EncoderConfig::new()
.unwrap()
.width(w)
.height(h)
.timebase(t.timebase.unwrap())
.rc_min_quantizer(0)
.rc_min_quantizer(0)
.threads(4)
.pass(aom_enc_pass::AOM_RC_ONE_PASS)
.rc_end_usage(aom_rc_mode::AOM_CQ);
let mut enc = cfg.get_encoder().unwrap();
enc.control(aome_enc_control_id::AOME_SET_CQ_LEVEL, 4)
.unwrap();
enc.control(aome_enc_control_id::AOME_SET_CPUUSED, 2)
.unwrap();
enc
}
pub fn setup_frame(w: u32, h: u32, t: &TimeInfo) -> Frame {
use av_data::frame::*;
use av_data::pixel::formats;
use std::sync::Arc;
let v = VideoInfo::new(
w as usize,
h as usize,
false,
FrameType::OTHER,
Arc::new(*formats::YUV420),
);
Frame::new_default_frame(v, Some(t.clone()))
}
#[test]
fn encode() {
let w = 200;
let h = 200;
let t = TimeInfo {
pts: Some(0),
dts: Some(0),
duration: Some(1),
timebase: Some(Rational64::new(1, 1000)),
user_private: None,
};
let mut e = setup(w, h, &t);
let mut f = setup_frame(w, h, &t);
let mut out = 0;
// TODO write some pattern
for i in 0..100 {
e.encode(&f).unwrap();
f.t.pts = Some(i);
// println!("{:#?}", f);
loop {
let p = e.get_packet();
if p.is_none() {
break;
} else {
out = 1;
// println!("{:#?}", p.unwrap());
}
}
}
if out != 1 {
panic!("No packet produced");
}
}
#[cfg(all(test, feature = "codec-trait"))]
#[test]
fn encode_codec_trait() | {
use super::AV1_DESCR;
use av_codec::common::CodecList;
use av_codec::encoder::*;
use av_codec::error::*;
use std::sync::Arc;
let encoders = Codecs::from_list(&[AV1_DESCR]);
let mut ctx = Context::by_name(&encoders, "av1").unwrap();
let w = 200;
let h = 200;
ctx.set_option("w", u64::from(w)).unwrap();
ctx.set_option("h", u64::from(h)).unwrap();
ctx.set_option("timebase", (1, 1000)).unwrap();
ctx.set_option("qmin", 0u64).unwrap();
ctx.set_option("qmax", 0u64).unwrap();
let t = TimeInfo {
pts: Some(0), | identifier_body |
|
encoder.rs | .expect("Cannot set CPUUSED");
Ok(enc)
}
_ => Err(ret),
}
}
/// Update the encoder parameters after-creation
///
/// It calls `aom_codec_control_`
pub fn control(
&mut self,
id: aome_enc_control_id::Type,
val: i32,
) -> Result<(), aom_codec_err_t::Type> {
let ret = unsafe { aom_codec_control(&mut self.ctx, id as i32, val) };
match ret {
aom_codec_err_t::AOM_CODEC_OK => Ok(()),
_ => Err(ret),
}
}
// TODO: Cache the image information
//
/// Send an uncompressed frame to the encoder
///
/// Call [`get_packet`] to receive the compressed data.
///
/// It calls `aom_codec_encode`.
///
/// [`get_packet`]: #method.get_packet
pub fn encode(&mut self, frame: &Frame) -> Result<(), aom_codec_err_t::Type> {
let img = img_from_frame(frame);
let ret = unsafe { aom_codec_encode(&mut self.ctx, &img, frame.t.pts.unwrap(), 1, 0) };
self.iter = ptr::null();
match ret {
aom_codec_err_t::AOM_CODEC_OK => Ok(()),
_ => Err(ret),
}
}
/// Notify the encoder that no more data will be sent
///
/// Call [`get_packet`] to receive the compressed data.
///
/// It calls `aom_codec_encode` with NULL arguments.
///
/// [`get_packet`]: #method.get_packet
pub fn flush(&mut self) -> Result<(), aom_codec_err_t::Type> {
let ret = unsafe { aom_codec_encode(&mut self.ctx, ptr::null_mut(), 0, 1, 0) };
self.iter = ptr::null();
match ret {
aom_codec_err_t::AOM_CODEC_OK => Ok(()),
_ => Err(ret),
}
}
/// Retrieve the compressed data
///
/// To be called until it returns `None`.
///
/// It calls `aom_codec_get_cx_data`.
pub fn get_packet(&mut self) -> Option<AOMPacket> {
let pkt = unsafe { aom_codec_get_cx_data(&mut self.ctx, &mut self.iter) };
if pkt.is_null() {
None
} else {
Some(AOMPacket::new(unsafe { *pkt }))
}
}
}
impl Drop for AV1Encoder {
fn drop(&mut self) {
unsafe { aom_codec_destroy(&mut self.ctx) };
}
}
impl AOMCodec for AV1Encoder {
fn get_context(&mut self) -> &mut aom_codec_ctx {
&mut self.ctx
}
}
#[cfg(feature = "codec-trait")]
mod encoder_trait {
use super::*;
use av_codec::encoder::*;
use av_codec::error::*;
use av_data::frame::ArcFrame;
use av_data::params::{CodecParams, MediaKind, VideoInfo};
use av_data::value::Value;
pub struct Des {
descr: Descr,
}
pub struct Enc {
cfg: AV1EncoderConfig,
enc: Option<AV1Encoder>,
}
impl Descriptor for Des {
type OutputEncoder = Enc;
fn create(&self) -> Self::OutputEncoder {
Enc {
cfg: AV1EncoderConfig::new().unwrap(),
enc: None,
}
}
fn describe(&self) -> &Descr {
&self.descr
}
}
impl Encoder for Enc {
fn configure(&mut self) -> Result<()> {
if self.enc.is_none() {
self.cfg
.get_encoder()
.map(|enc| {
self.enc = Some(enc);
})
.map_err(|_err| Error::ConfigurationIncomplete)
} else {
unimplemented!()
}
}
// TODO: have it as default impl?
fn get_extradata(&self) -> Option<Vec<u8>> {
None
}
fn send_frame(&mut self, frame: &ArcFrame) -> Result<()> {
let enc = self.enc.as_mut().unwrap();
enc.encode(frame).map_err(|_| unimplemented!())
}
fn receive_packet(&mut self) -> Result<Packet> {
let enc = self.enc.as_mut().unwrap();
if let Some(p) = enc.get_packet() {
match p {
AOMPacket::Packet(pkt) => Ok(pkt),
_ => unimplemented!(),
}
} else {
Err(Error::MoreDataNeeded)
}
}
fn flush(&mut self) -> Result<()> {
let enc = self.enc.as_mut().unwrap();
enc.flush().map_err(|_| unimplemented!())
}
fn set_option<'a>(&mut self, key: &str, val: Value<'a>) -> Result<()> {
match (key, val) {
("w", Value::U64(v)) => self.cfg.g_w = v as u32,
("h", Value::U64(v)) => self.cfg.g_h = v as u32,
("qmin", Value::U64(v)) => self.cfg.rc_min_quantizer = v as u32,
("qmax", Value::U64(v)) => self.cfg.rc_max_quantizer = v as u32,
("timebase", Value::Pair(num, den)) => {
self.cfg.g_timebase.num = num as i32;
self.cfg.g_timebase.den = den as i32;
}
_ => unimplemented!(),
}
Ok(())
}
fn get_params(&self) -> Result<CodecParams> {
use std::sync::Arc;
Ok(CodecParams {
kind: Some(MediaKind::Video(VideoInfo {
height: self.cfg.g_h as usize,
width: self.cfg.g_w as usize,
format: Some(Arc::new(*YUV420)), // TODO: support more formats
})),
codec_id: Some("av1".to_owned()),
extradata: None,
bit_rate: 0, // TODO: expose the information
convergence_window: 0,
delay: 0,
})
}
fn set_params(&mut self, params: &CodecParams) -> Result<()> {
if let Some(MediaKind::Video(ref info)) = params.kind {
self.cfg.g_w = info.width as u32;
self.cfg.g_h = info.height as u32;
}
Ok(())
}
}
/// AV1 Encoder
///
/// To be used with [av-codec](https://docs.rs/av-codec) `Encoder Context`.
pub const AV1_DESCR: &Des = &Des {
descr: Descr {
codec: "av1",
name: "aom",
desc: "libaom AV1 encoder",
mime: "video/AV1",
},
};
}
#[cfg(feature = "codec-trait")]
pub use self::encoder_trait::AV1_DESCR;
#[cfg(test)]
pub(crate) mod tests {
use super::*;
#[test]
fn init() {
let mut c = AV1EncoderConfig::new().unwrap();
let mut e = c.get_encoder().unwrap();
println!("{}", e.error_to_str());
}
use av_data::rational::*;
use av_data::timeinfo::TimeInfo;
pub fn setup(w: u32, h: u32, t: &TimeInfo) -> AV1Encoder {
if (w % 2) != 0 || (h % 2) != 0 {
panic!("Invalid frame size: w: {} h: {}", w, h);
}
let mut cfg = AV1EncoderConfig::new()
.unwrap()
.width(w)
.height(h)
.timebase(t.timebase.unwrap())
.rc_min_quantizer(0)
.rc_min_quantizer(0)
.threads(4)
.pass(aom_enc_pass::AOM_RC_ONE_PASS)
.rc_end_usage(aom_rc_mode::AOM_CQ);
let mut enc = cfg.get_encoder().unwrap();
enc.control(aome_enc_control_id::AOME_SET_CQ_LEVEL, 4)
.unwrap();
enc.control(aome_enc_control_id::AOME_SET_CPUUSED, 2)
.unwrap();
enc
}
pub fn setup_frame(w: u32, h: u32, t: &TimeInfo) -> Frame {
use av_data::frame::*;
use av_data::pixel::formats;
use std::sync::Arc;
let v = VideoInfo::new(
w as usize,
h as usize,
false,
FrameType::OTHER,
Arc::new(*formats::YUV420),
);
Frame::new_default_frame(v, Some(t.clone()))
}
#[test]
fn encode() {
let w = 200;
let h = 200;
let t = TimeInfo {
pts: Some(0),
dts: Some(0),
duration: Some(1),
timebase: Some(Rational64::new(1, 1000)),
user_private: None,
}; | random_line_split |
||
example_scenes.py | _graph_label(sin_graph, "\\sin(x)")
relu_label = axes.get_graph_label(relu_graph, Text("ReLU"))
step_label = axes.get_graph_label(step_graph, Text("Step"), x=4)
self.play(
ShowCreation(sin_graph),
FadeIn(sin_label, RIGHT),
)
self.wait(2)
self.play(
ReplacementTransform(sin_graph, relu_graph),
FadeTransform(sin_label, relu_label),
)
self.wait()
self.play(
ReplacementTransform(relu_graph, step_graph),
FadeTransform(relu_label, step_label),
)
self.wait()
parabola = axes.get_graph(lambda x: 0.25 * x**2)
parabola.set_stroke(BLUE)
self.play(
FadeOut(step_graph),
FadeOut(step_label),
ShowCreation(parabola)
)
self.wait()
# You can use axes.input_to_graph_point, abbreviated
# to axes.i2gp, to find a particular point on a graph
dot = Dot(color=RED)
dot.move_to(axes.i2gp(2, parabola))
self.play(FadeIn(dot, scale=0.5))
# A value tracker lets us animate a parameter, usually
# with the intent of having other mobjects update based
# on the parameter
x_tracker = ValueTracker(2)
f_always(
dot.move_to,
lambda: axes.i2gp(x_tracker.get_value(), parabola)
)
self.play(x_tracker.animate.set_value(4), run_time=3)
self.play(x_tracker.animate.set_value(-2), run_time=3)
self.wait()
class TexAndNumbersExample(Scene):
def construct(self):
axes = Axes((-3, 3), (-3, 3), unit_size=1)
axes.to_edge(DOWN)
axes.add_coordinate_labels(font_size=16)
circle = Circle(radius=2)
circle.set_stroke(YELLOW, 3)
circle.move_to(axes.get_origin())
self.add(axes, circle)
# When numbers show up in tex, they can be readily
# replaced with DecimalMobjects so that methods like
# get_value and set_value can be called on them, and
# animations like ChangeDecimalToValue can be called
# on them.
tex = Tex("x^2 + y^2 = 4.00")
tex.next_to(axes, UP, buff=0.5)
value = tex.make_number_changable("4.00")
# This will tie the right hand side of our equation to
# the square of the radius of the circle
value.add_updater(lambda v: v.set_value(circle.get_radius()**2))
self.add(tex)
text = Text("""
You can manipulate numbers
in Tex mobjects
""", font_size=30)
text.next_to(tex, RIGHT, buff=1.5)
arrow = Arrow(text, tex)
self.add(text, arrow)
self.play(
circle.animate.set_height(2.0),
run_time=4,
rate_func=there_and_back,
)
# By default, tex.make_number_changable replaces the first occurance
# of the number,but by passing replace_all=True it replaces all and
# returns a group of the results
exponents = tex.make_number_changable("2", replace_all=True)
self.play(
LaggedStartMap(
FlashAround, exponents,
lag_ratio=0.2, buff=0.1, color=RED
),
exponents.animate.set_color(RED)
)
def func(x, y):
# Switch from manim coords to axes coords
xa, ya = axes.point_to_coords(np.array([x, y, 0]))
return xa**4 + ya**4 - 4
new_curve = ImplicitFunction(func)
new_curve.match_style(circle)
circle.rotate(angle_of_vector(new_curve.get_start())) # Align
value.clear_updaters()
self.play(
*(ChangeDecimalToValue(exp, 4) for exp in exponents),
ReplacementTransform(circle.copy(), new_curve),
circle.animate.set_stroke(width=1, opacity=0.5),
)
class SurfaceExample(ThreeDScene):
def construct(self):
surface_text = Text("For 3d scenes, try using surfaces")
surface_text.fix_in_frame()
surface_text.to_edge(UP)
self.add(surface_text)
self.wait(0.1)
torus1 = Torus(r1=1, r2=1)
torus2 = Torus(r1=3, r2=1)
sphere = Sphere(radius=3, resolution=torus1.resolution)
# You can texture a surface with up to two images, which will
# be interpreted as the side towards the light, and away from
# the light. These can be either urls, or paths to a local file
# in whatever you've set as the image directory in
# the custom_config.yml file
# day_texture = "EarthTextureMap"
# night_texture = "NightEarthTextureMap"
day_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Whole_world_-_land_and_oceans.jpg/1280px-Whole_world_-_land_and_oceans.jpg"
night_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/The_earth_at_night.jpg/1280px-The_earth_at_night.jpg"
surfaces = [
TexturedSurface(surface, day_texture, night_texture)
for surface in [sphere, torus1, torus2]
]
for mob in surfaces:
mob.shift(IN)
mob.mesh = SurfaceMesh(mob)
mob.mesh.set_stroke(BLUE, 1, opacity=0.5)
surface = surfaces[0]
self.play(
FadeIn(surface),
ShowCreation(surface.mesh, lag_ratio=0.01, run_time=3),
)
for mob in surfaces:
mob.add(mob.mesh)
surface.save_state()
self.play(Rotate(surface, PI / 2), run_time=2)
for mob in surfaces[1:]:
mob.rotate(PI / 2)
self.play(
Transform(surface, surfaces[1]),
run_time=3
)
self.play(
Transform(surface, surfaces[2]),
# Move camera frame during the transition
self.frame.animate.increment_phi(-10 * DEGREES),
self.frame.animate.increment_theta(-20 * DEGREES),
run_time=3
)
# Add ambient rotation
self.frame.add_updater(lambda m, dt: m.increment_theta(-0.1 * dt))
# Play around with where the light is
light_text = Text("You can move around the light source")
light_text.move_to(surface_text)
light_text.fix_in_frame()
self.play(FadeTransform(surface_text, light_text))
light = self.camera.light_source
self.add(light)
light.save_state()
self.play(light.animate.move_to(3 * IN), run_time=5)
self.play(light.animate.shift(10 * OUT), run_time=5)
drag_text = Text("Try moving the mouse while pressing d or f")
drag_text.move_to(light_text)
drag_text.fix_in_frame()
self.play(FadeTransform(light_text, drag_text))
self.wait()
class InteractiveDevelopment(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
square = Square()
self.play(ShowCreation(square))
self.wait()
# This opens an iPython terminal where you can keep writing
# lines as if they were part of this construct method.
# In particular, 'square', 'circle' and 'self' will all be
# part of the local namespace in that terminal.
self.embed()
# Try copying and pasting some of the lines below into
# the interactive shell
self.play(ReplacementTransform(square, circle))
self.wait()
self.play(circle.animate.stretch(4, 0))
self.play(Rotate(circle, 90 * DEGREES))
self.play(circle.animate.shift(2 * RIGHT).scale(0.25))
text = Text("""
In general, using the interactive shell
is very helpful when developing new scenes
""")
self.play(Write(text))
# In the interactive shell, you can just type
# play, add, remove, clear, wait, save_state and restore,
# instead of self.play, self.add, self.remove, etc.
# To interact with the window, type touch(). You can then
# scroll in the window, or zoom by holding down 'z' while scrolling,
# and change camera perspective by holding down 'd' while moving
# the mouse. Press 'r' to reset to the standard camera position.
# Press 'q' to stop interacting with the window and go back to
# typing new commands into the shell.
# In principle you can customize a scene to be responsive to
# mouse and keyboard interactions
always(circle.move_to, self.mouse_point)
class ControlsExample(Scene):
drag_to_pan = False
| def setup(self): | random_line_split |
|
example_scenes.py | )
fonts.set_width(FRAME_WIDTH - 1)
slant = Text(
"And the same as slant and weight",
font="Consolas",
t2s={"slant": ITALIC},
t2w={"weight": BOLD},
t2c={"slant": ORANGE, "weight": RED}
)
VGroup(fonts, slant).arrange(DOWN, buff=0.8)
self.play(FadeOut(text), FadeOut(difference, shift=DOWN))
self.play(Write(fonts))
self.wait()
self.play(Write(slant))
self.wait()
class TexTransformExample(Scene):
def construct(self):
# Tex to color map
t2c = {
"A": BLUE,
"B": TEAL,
"C": GREEN,
}
# Configuration to pass along to each Tex mobject
kw = dict(font_size=72, t2c=t2c)
lines = VGroup(
Tex("A^2 + B^2 = C^2", **kw),
Tex("A^2 = C^2 - B^2", **kw),
Tex("A^2 = (C + B)(C - B)", **kw),
Tex(R"A = \sqrt{(C + B)(C - B)}", **kw),
)
lines.arrange(DOWN, buff=LARGE_BUFF)
self.add(lines[0])
# The animation TransformMatchingStrings will line up parts
# of the source and target which have matching substring strings.
# Here, giving it a little path_arc makes each part rotate into
# their final positions, which feels appropriate for the idea of
# rearranging an equation
self.play(
TransformMatchingStrings(
lines[0].copy(), lines[1],
# matched_keys specifies which substring should
# line up. If it's not specified, the animation
# will align the longest matching substrings.
# In this case, the substring "^2 = C^2" would
# trip it up
matched_keys=["A^2", "B^2", "C^2"],
# When you want a substring from the source
# to go to a non-equal substring from the target,
# use the key map.
key_map={"+": "-"},
path_arc=90 * DEGREES,
),
)
self.wait()
self.play(TransformMatchingStrings(
lines[1].copy(), lines[2],
matched_keys=["A^2"]
))
self.wait()
self.play(
TransformMatchingStrings(
lines[2].copy(), lines[3],
key_map={"2": R"\sqrt"},
path_arc=-30 * DEGREES,
),
)
self.wait(2)
self.play(LaggedStartMap(FadeOut, lines, shift=2 * RIGHT))
# TransformMatchingShapes will try to line up all pieces of a
# source mobject with those of a target, regardless of the
# what Mobject type they are.
source = Text("the morse code", height=1)
target = Text("here come dots", height=1)
saved_source = source.copy()
self.play(Write(source))
self.wait()
kw = dict(run_time=3, path_arc=PI / 2)
self.play(TransformMatchingShapes(source, target, **kw))
self.wait()
self.play(TransformMatchingShapes(target, saved_source, **kw))
self.wait()
class TexIndexing(Scene):
def construct(self):
# You can index into Tex mobject (or other StringMobjects) by substrings
equation = Tex(R"e^{\pi i} = -1", font_size=144)
self.add(equation)
self.play(FlashAround(equation["e"]))
self.wait()
self.play(Indicate(equation[R"\pi"]))
self.wait()
self.play(TransformFromCopy(
equation[R"e^{\pi i}"].copy().set_opacity(0.5),
equation["-1"],
path_arc=-PI / 2,
run_time=3
))
self.play(FadeOut(equation))
# Or regular expressions
equation = Tex("A^2 + B^2 = C^2", font_size=144)
self.play(Write(equation))
for part in equation[re.compile(r"\w\^2")]:
self.play(FlashAround(part))
self.wait()
self.play(FadeOut(equation))
# Indexing by substrings like this may not work when
# the order in which Latex draws symbols does not match
# the order in which they show up in the string.
# For example, here the infinity is drawn before the sigma
# so we don't get the desired behavior.
equation = Tex(R"\sum_{n = 1}^\infty \frac{1}{n^2} = \frac{\pi^2}{6}", font_size=72)
self.play(FadeIn(equation))
self.play(equation[R"\infty"].animate.set_color(RED)) # Doesn't hit the infinity
self.wait()
self.play(FadeOut(equation))
# However you can always fix this by explicitly passing in
# a string you might want to isolate later. Also, using
# \over instead of \frac helps to avoid the issue for fractions
equation = Tex(
R"\sum_{n = 1}^\infty {1 \over n^2} = {\pi^2 \over 6}",
# Explicitly mark "\infty" as a substring you might want to access
isolate=[R"\infty"],
font_size=72
)
self.play(FadeIn(equation))
self.play(equation[R"\infty"].animate.set_color(RED)) # Got it!
self.wait()
self.play(FadeOut(equation))
class UpdatersExample(Scene):
def construct(self):
square = Square()
square.set_fill(BLUE_E, 1)
# On all frames, the constructor Brace(square, UP) will
# be called, and the mobject brace will set its data to match
# that of the newly constructed object
brace = always_redraw(Brace, square, UP)
label = TexText("Width = 0.00")
number = label.make_number_changable("0.00")
# This ensures that the method deicmal.next_to(square)
# is called on every frame
always(label.next_to, brace, UP)
# You could also write the following equivalent line
# label.add_updater(lambda m: m.next_to(brace, UP))
# If the argument itself might change, you can use f_always,
# for which the arguments following the initial Mobject method
# should be functions returning arguments to that method.
# The following line ensures thst decimal.set_value(square.get_y())
# is called every frame
f_always(number.set_value, square.get_width)
# You could also write the following equivalent line
# number.add_updater(lambda m: m.set_value(square.get_width()))
self.add(square, brace, label)
# Notice that the brace and label track with the square
self.play(
square.animate.scale(2),
rate_func=there_and_back,
run_time=2,
)
self.wait()
self.play(
square.animate.set_width(5, stretch=True),
run_time=3,
)
self.wait()
self.play(
square.animate.set_width(2),
run_time=3
)
self.wait()
# In general, you can alway call Mobject.add_updater, and pass in
# a function that you want to be called on every frame. The function
# should take in either one argument, the mobject, or two arguments,
# the mobject and the amount of time since the last frame.
now = self.time
w0 = square.get_width()
square.add_updater(
lambda m: m.set_width(w0 * math.sin(self.time - now) + w0)
)
self.wait(4 * PI)
class CoordinateSystemExample(Scene):
def construct(self):
axes = Axes(
# x-axis ranges from -1 to | text = Text("Here is a text", font="Consolas", font_size=90)
difference = Text(
"""
The most important difference between Text and TexText is that\n
you can change the font more easily, but can't use the LaTeX grammar
""",
font="Arial", font_size=24,
# t2c is a dict that you can choose color for different text
t2c={"Text": BLUE, "TexText": BLUE, "LaTeX": ORANGE}
)
VGroup(text, difference).arrange(DOWN, buff=1)
self.play(Write(text))
self.play(FadeIn(difference, UP))
self.wait(3)
fonts = Text(
"And you can also set the font according to different words",
font="Arial",
t2f={"font": "Consolas", "words": "Consolas"},
t2c={"font": BLUE, "words": GREEN} | identifier_body |
|
example_scenes.py | _point, abbreviated
# to axes.i2gp, to find a particular point on a graph
dot = Dot(color=RED)
dot.move_to(axes.i2gp(2, parabola))
self.play(FadeIn(dot, scale=0.5))
# A value tracker lets us animate a parameter, usually
# with the intent of having other mobjects update based
# on the parameter
x_tracker = ValueTracker(2)
f_always(
dot.move_to,
lambda: axes.i2gp(x_tracker.get_value(), parabola)
)
self.play(x_tracker.animate.set_value(4), run_time=3)
self.play(x_tracker.animate.set_value(-2), run_time=3)
self.wait()
class TexAndNumbersExample(Scene):
def construct(self):
axes = Axes((-3, 3), (-3, 3), unit_size=1)
axes.to_edge(DOWN)
axes.add_coordinate_labels(font_size=16)
circle = Circle(radius=2)
circle.set_stroke(YELLOW, 3)
circle.move_to(axes.get_origin())
self.add(axes, circle)
# When numbers show up in tex, they can be readily
# replaced with DecimalMobjects so that methods like
# get_value and set_value can be called on them, and
# animations like ChangeDecimalToValue can be called
# on them.
tex = Tex("x^2 + y^2 = 4.00")
tex.next_to(axes, UP, buff=0.5)
value = tex.make_number_changable("4.00")
# This will tie the right hand side of our equation to
# the square of the radius of the circle
value.add_updater(lambda v: v.set_value(circle.get_radius()**2))
self.add(tex)
text = Text("""
You can manipulate numbers
in Tex mobjects
""", font_size=30)
text.next_to(tex, RIGHT, buff=1.5)
arrow = Arrow(text, tex)
self.add(text, arrow)
self.play(
circle.animate.set_height(2.0),
run_time=4,
rate_func=there_and_back,
)
# By default, tex.make_number_changable replaces the first occurance
# of the number,but by passing replace_all=True it replaces all and
# returns a group of the results
exponents = tex.make_number_changable("2", replace_all=True)
self.play(
LaggedStartMap(
FlashAround, exponents,
lag_ratio=0.2, buff=0.1, color=RED
),
exponents.animate.set_color(RED)
)
def func(x, y):
# Switch from manim coords to axes coords
xa, ya = axes.point_to_coords(np.array([x, y, 0]))
return xa**4 + ya**4 - 4
new_curve = ImplicitFunction(func)
new_curve.match_style(circle)
circle.rotate(angle_of_vector(new_curve.get_start())) # Align
value.clear_updaters()
self.play(
*(ChangeDecimalToValue(exp, 4) for exp in exponents),
ReplacementTransform(circle.copy(), new_curve),
circle.animate.set_stroke(width=1, opacity=0.5),
)
class SurfaceExample(ThreeDScene):
def construct(self):
surface_text = Text("For 3d scenes, try using surfaces")
surface_text.fix_in_frame()
surface_text.to_edge(UP)
self.add(surface_text)
self.wait(0.1)
torus1 = Torus(r1=1, r2=1)
torus2 = Torus(r1=3, r2=1)
sphere = Sphere(radius=3, resolution=torus1.resolution)
# You can texture a surface with up to two images, which will
# be interpreted as the side towards the light, and away from
# the light. These can be either urls, or paths to a local file
# in whatever you've set as the image directory in
# the custom_config.yml file
# day_texture = "EarthTextureMap"
# night_texture = "NightEarthTextureMap"
day_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Whole_world_-_land_and_oceans.jpg/1280px-Whole_world_-_land_and_oceans.jpg"
night_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/The_earth_at_night.jpg/1280px-The_earth_at_night.jpg"
surfaces = [
TexturedSurface(surface, day_texture, night_texture)
for surface in [sphere, torus1, torus2]
]
for mob in surfaces:
mob.shift(IN)
mob.mesh = SurfaceMesh(mob)
mob.mesh.set_stroke(BLUE, 1, opacity=0.5)
surface = surfaces[0]
self.play(
FadeIn(surface),
ShowCreation(surface.mesh, lag_ratio=0.01, run_time=3),
)
for mob in surfaces:
mob.add(mob.mesh)
surface.save_state()
self.play(Rotate(surface, PI / 2), run_time=2)
for mob in surfaces[1:]:
mob.rotate(PI / 2)
self.play(
Transform(surface, surfaces[1]),
run_time=3
)
self.play(
Transform(surface, surfaces[2]),
# Move camera frame during the transition
self.frame.animate.increment_phi(-10 * DEGREES),
self.frame.animate.increment_theta(-20 * DEGREES),
run_time=3
)
# Add ambient rotation
self.frame.add_updater(lambda m, dt: m.increment_theta(-0.1 * dt))
# Play around with where the light is
light_text = Text("You can move around the light source")
light_text.move_to(surface_text)
light_text.fix_in_frame()
self.play(FadeTransform(surface_text, light_text))
light = self.camera.light_source
self.add(light)
light.save_state()
self.play(light.animate.move_to(3 * IN), run_time=5)
self.play(light.animate.shift(10 * OUT), run_time=5)
drag_text = Text("Try moving the mouse while pressing d or f")
drag_text.move_to(light_text)
drag_text.fix_in_frame()
self.play(FadeTransform(light_text, drag_text))
self.wait()
class InteractiveDevelopment(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
square = Square()
self.play(ShowCreation(square))
self.wait()
# This opens an iPython terminal where you can keep writing
# lines as if they were part of this construct method.
# In particular, 'square', 'circle' and 'self' will all be
# part of the local namespace in that terminal.
self.embed()
# Try copying and pasting some of the lines below into
# the interactive shell
self.play(ReplacementTransform(square, circle))
self.wait()
self.play(circle.animate.stretch(4, 0))
self.play(Rotate(circle, 90 * DEGREES))
self.play(circle.animate.shift(2 * RIGHT).scale(0.25))
text = Text("""
In general, using the interactive shell
is very helpful when developing new scenes
""")
self.play(Write(text))
# In the interactive shell, you can just type
# play, add, remove, clear, wait, save_state and restore,
# instead of self.play, self.add, self.remove, etc.
# To interact with the window, type touch(). You can then
# scroll in the window, or zoom by holding down 'z' while scrolling,
# and change camera perspective by holding down 'd' while moving
# the mouse. Press 'r' to reset to the standard camera position.
# Press 'q' to stop interacting with the window and go back to
# typing new commands into the shell.
# In principle you can customize a scene to be responsive to
# mouse and keyboard interactions
always(circle.move_to, self.mouse_point)
class ControlsExample(Scene):
drag_to_pan = False
def setup(self):
self.textbox = Textbox()
self.checkbox = Checkbox()
self.color_picker = ColorSliders()
self.panel = ControlPanel(
Text("Text", font_size=24), self.textbox, Line(),
Text("Show/Hide Text", font_size=24), self.checkbox, Line(),
Text("Color of Text", font_size=24), self.color_picker
)
self.add(self.panel)
def construct(self):
text = Text("text", font_size=96)
def text_updater(old_text):
assert(isinstance(old_text, Text))
new_text = Text(self.textbox.get_value(), font_size=old_text.font_size)
# new_text.align_data_and_family(old_text)
new_text.move_to(old_text)
if self.checkbox.get_value():
| new_text.set_fill(
color=self.color_picker.get_picked_color(),
opacity=self.color_picker.get_picked_opacity()
) | conditional_block |
|
example_scenes.py | , label)
# Notice that the brace and label track with the square
self.play(
square.animate.scale(2),
rate_func=there_and_back,
run_time=2,
)
self.wait()
self.play(
square.animate.set_width(5, stretch=True),
run_time=3,
)
self.wait()
self.play(
square.animate.set_width(2),
run_time=3
)
self.wait()
# In general, you can alway call Mobject.add_updater, and pass in
# a function that you want to be called on every frame. The function
# should take in either one argument, the mobject, or two arguments,
# the mobject and the amount of time since the last frame.
now = self.time
w0 = square.get_width()
square.add_updater(
lambda m: m.set_width(w0 * math.sin(self.time - now) + w0)
)
self.wait(4 * PI)
class CoordinateSystemExample(Scene):
def construct(self):
axes = Axes(
# x-axis ranges from -1 to 10, with a default step size of 1
x_range=(-1, 10),
# y-axis ranges from -2 to 2 with a step size of 0.5
y_range=(-2, 2, 0.5),
# The axes will be stretched so as to match the specified
# height and width
height=6,
width=10,
# Axes is made of two NumberLine mobjects. You can specify
# their configuration with axis_config
axis_config=dict(
stroke_color=GREY_A,
stroke_width=2,
numbers_to_exclude=[0],
),
# Alternatively, you can specify configuration for just one
# of them, like this.
y_axis_config=dict(
numbers_with_elongated_ticks=[-2, 2],
)
)
# Keyword arguments of add_coordinate_labels can be used to
# configure the DecimalNumber mobjects which it creates and
# adds to the axes
axes.add_coordinate_labels(
font_size=20,
num_decimal_places=1,
)
self.add(axes)
# Axes descends from the CoordinateSystem class, meaning
# you can call call axes.coords_to_point, abbreviated to
# axes.c2p, to associate a set of coordinates with a point,
# like so:
dot = Dot(color=RED)
dot.move_to(axes.c2p(0, 0))
self.play(FadeIn(dot, scale=0.5))
self.play(dot.animate.move_to(axes.c2p(3, 2)))
self.wait()
self.play(dot.animate.move_to(axes.c2p(5, 0.5)))
self.wait()
# Similarly, you can call axes.point_to_coords, or axes.p2c
# print(axes.p2c(dot.get_center()))
# We can draw lines from the axes to better mark the coordinates
# of a given point.
# Here, the always_redraw command means that on each new frame
# the lines will be redrawn
h_line = always_redraw(lambda: axes.get_h_line(dot.get_left()))
v_line = always_redraw(lambda: axes.get_v_line(dot.get_bottom()))
self.play(
ShowCreation(h_line),
ShowCreation(v_line),
)
self.play(dot.animate.move_to(axes.c2p(3, -2)))
self.wait()
self.play(dot.animate.move_to(axes.c2p(1, 1)))
self.wait()
# If we tie the dot to a particular set of coordinates, notice
# that as we move the axes around it respects the coordinate
# system defined by them.
f_always(dot.move_to, lambda: axes.c2p(1, 1))
self.play(
axes.animate.scale(0.75).to_corner(UL),
run_time=2,
)
self.wait()
self.play(FadeOut(VGroup(axes, dot, h_line, v_line)))
# Other coordinate systems you can play around with include
# ThreeDAxes, NumberPlane, and ComplexPlane.
class GraphExample(Scene):
def construct(self):
axes = Axes((-3, 10), (-1, 8), height=6)
axes.add_coordinate_labels()
self.play(Write(axes, lag_ratio=0.01, run_time=1))
# Axes.get_graph will return the graph of a function
sin_graph = axes.get_graph(
lambda x: 2 * math.sin(x),
color=BLUE,
)
# By default, it draws it so as to somewhat smoothly interpolate
# between sampled points (x, f(x)). If the graph is meant to have
# a corner, though, you can set use_smoothing to False
relu_graph = axes.get_graph(
lambda x: max(x, 0),
use_smoothing=False,
color=YELLOW,
)
# For discontinuous functions, you can specify the point of
# discontinuity so that it does not try to draw over the gap.
step_graph = axes.get_graph(
lambda x: 2.0 if x > 3 else 1.0,
discontinuities=[3],
color=GREEN,
)
# Axes.get_graph_label takes in either a string or a mobject.
# If it's a string, it treats it as a LaTeX expression. By default
# it places the label next to the graph near the right side, and
# has it match the color of the graph
sin_label = axes.get_graph_label(sin_graph, "\\sin(x)")
relu_label = axes.get_graph_label(relu_graph, Text("ReLU"))
step_label = axes.get_graph_label(step_graph, Text("Step"), x=4)
self.play(
ShowCreation(sin_graph),
FadeIn(sin_label, RIGHT),
)
self.wait(2)
self.play(
ReplacementTransform(sin_graph, relu_graph),
FadeTransform(sin_label, relu_label),
)
self.wait()
self.play(
ReplacementTransform(relu_graph, step_graph),
FadeTransform(relu_label, step_label),
)
self.wait()
parabola = axes.get_graph(lambda x: 0.25 * x**2)
parabola.set_stroke(BLUE)
self.play(
FadeOut(step_graph),
FadeOut(step_label),
ShowCreation(parabola)
)
self.wait()
# You can use axes.input_to_graph_point, abbreviated
# to axes.i2gp, to find a particular point on a graph
dot = Dot(color=RED)
dot.move_to(axes.i2gp(2, parabola))
self.play(FadeIn(dot, scale=0.5))
# A value tracker lets us animate a parameter, usually
# with the intent of having other mobjects update based
# on the parameter
x_tracker = ValueTracker(2)
f_always(
dot.move_to,
lambda: axes.i2gp(x_tracker.get_value(), parabola)
)
self.play(x_tracker.animate.set_value(4), run_time=3)
self.play(x_tracker.animate.set_value(-2), run_time=3)
self.wait()
class TexAndNumbersExample(Scene):
def construct(self):
axes = Axes((-3, 3), (-3, 3), unit_size=1)
axes.to_edge(DOWN)
axes.add_coordinate_labels(font_size=16)
circle = Circle(radius=2)
circle.set_stroke(YELLOW, 3)
circle.move_to(axes.get_origin())
self.add(axes, circle)
# When numbers show up in tex, they can be readily
# replaced with DecimalMobjects so that methods like
# get_value and set_value can be called on them, and
# animations like ChangeDecimalToValue can be called
# on them.
tex = Tex("x^2 + y^2 = 4.00")
tex.next_to(axes, UP, buff=0.5)
value = tex.make_number_changable("4.00")
# This will tie the right hand side of our equation to
# the square of the radius of the circle
value.add_updater(lambda v: v.set_value(circle.get_radius()**2))
self.add(tex)
text = Text("""
You can manipulate numbers
in Tex mobjects
""", font_size=30)
text.next_to(tex, RIGHT, buff=1.5)
arrow = Arrow(text, tex)
self.add(text, arrow)
self.play(
circle.animate.set_height(2.0),
run_time=4,
rate_func=there_and_back,
)
# By default, tex.make_number_changable replaces the first occurance
# of the number,but by passing replace_all=True it replaces all and
# returns a group of the results
exponents = tex.make_number_changable("2", replace_all=True)
self.play(
LaggedStartMap(
FlashAround, exponents,
lag_ratio=0.2, buff=0.1, color=RED
),
exponents.animate.set_color(RED)
)
def | func | identifier_name |
|
Skycam.py | (tuple of floats) coordinates of node0, node1, node2
'''
# Project lengths into xy plane
a_eff = ((zC-zB)**2 + c**2)**.5
b_eff = (zC**2 + b**2)**.5
c_eff = (zB**2 + c**2)**.5
# Law of cosines
numer = b_eff**2 + c_eff**2 - a_eff**2
denom = 2*b_eff*c_eff
Arad = acos(numer/denom)
# Law of sines
Brad = asin(b*sin(Arad)/a)
Crad = asin(c*sin(Arad)/a)
theta = .5*pi-Arad
return (0,0, 0), (0, c, zB), (b*cos(theta), b*sin(theta), zC)
def load_path(self, points):
''' Create a new path based on predetermined points.
Inputs:
points: (list of tuples of floats) specific camera positions for
any given time.
Returns:
Initializes new Path in Skycam's path attribute
'''
self.path = Path.new_path(points, self.node0, self.node1, self.node2)
def create_path(self, waypoints, steps):
''' Generate a new list of points based on waypoints.
Inputs:
waypoints: (list of tuples of floats): points the path should
bring the camera to
steps: (int) number of steps in which to complete the path
Returns:
Calls load_path method on list of generated spline points
'''
xpoints = [point[0] for point in waypoints]
ypoints = [point[1] for point in waypoints]
zpoints = [point[2] for point in waypoints]
# spline parameters
s = 2.0 # smoothness
k = 1 # spline order
nest = -1 # estimate of knots needed
# create spline and calculate length
s, us = splprep([xpoints, ypoints, zpoints], s=s, k=k, nest=nest)
totl = self.splineLen(s)
dl = totl/steps
if dl > 1:
print "dl greater than 1!"
i = 0
u = 0
upath = [u]
# Divide path into equidistant lengths
while i < steps-1:
u = self.binary_search(u, s, dl) # optionally pass tolerance
upath.append(u)
print i
i += 1
path = [splev(u, s) for u in upath]
path_lens = []
for i in xrange(len(path) - 1):
path_lens.append(distance(path[i], path[i+1]))
error = [ele - dl for ele in path_lens]
print 'Error is: ', sum(error)/len(error)
self.load_path(path)
# self.path = Path.new_path(path, self.node0, self.node1, self.node2)
def go_path(self, start):
'''Send appropriate movement commands for loaded path.
Input:
start: (int) index of path at which to begin sending commands
'''
#TODO: Implement save point
while (not self.direct and not self.pause):
for i in xrange(len(self.path.diffs0) - start):
self.send_command(self.path.diffs0[i + start], self.path.diffs1[i + start], self.path.diffs2[i + start])
# raw_input('')
self.save_point = i
break
# def pause_path(self):
# ''' Pause path traversal.'''
# self.pause = True
# def switch_mode(self):
# ''' Switch from path control to joystick control '''
# self.direct = not self.direct
# def go_input(self):
# ''' Translate a direct-control input into a directional vector and send appropriate commands '''
# pass
def connect(self, baud=57600):
''' Connect to proper serial ports for Bluetooth communication.
Inputs:
baud: (int) baud rate at which to connect
Returns:
Print confirmation of connection
'''
# Connect to proper serial ports
self.serA = serial.Serial('/dev/rfcomm0', baud, timeout=50)
self.serB = serial.Serial('/dev/rfcomm1', baud, timeout=50)
self.serC = serial.Serial('/dev/rfcomm2', baud, timeout=50)
print 'Hacking the mainframe...'
sleep(8)
print 'Mainframe hacked'
def send_command(self, diff0, diff1, diff2):
'''Send proper commands to all three serial ports.
Inputs:
diff0: (float) node length difference for node 0
diff1: (float) node length difference for node 1
diff2: (float) node length difference for node 2
'''
print diff0, diff1, diff2
self.serA.write(str(diff0) + 'g')
self.serB.write(str(diff1) + 'g')
self.serC.write(str(diff2) + 'g')
#TODO: Always mess around with this value
sleep(.35)
pass
# def dldp(self, nodePos, theta, phi):
# ''' use a directional vector and current position to calculate change in node length '''
# cam = self.cam
# deltaX = cam[0] - nodePos[0]
# deltaY = cam[1] - nodePos[1]
# deltaZ = cam[2] - nodePos[2]
# numer = deltaX*cos(theta)*cos(phi) + deltaY*sin(theta)*cos(phi) + deltaZ*sin(phi)
# denom = (deltaX**2 + deltaY**2 + deltaZ**2)**.5
# return numer/denom
def | (self, ustart, s, dl, tol=.01):
''' Perform a binary search to find parametrized location of point.
Inputs:
ustart: (float)
s: (spline object)
dl: (float)
tol: (float)
Returns:
Reassigns middle and endpoints of search
um: (float) midpoint of search
'''
point = splev(ustart, s)
ui = ustart
uf = 1
um = (ui + uf)/2
xm, ym, zm = splev(um, s)
xf, yf, zf = splev(uf, s)
while True:
tpoint = splev(um, s)
if distance(point, tpoint)>(dl*(1+tol)):
uf, um = um, (um+ui)/2
elif distance(point, tpoint)<(dl*(1-tol)):
ui, um = um, (um+uf)/2
else:
return um
def splineLen(self, s):
''' Calculate length of a spline.
Inputs:
s: (spline object) represents path that joins waypoints
Returns:
(float) length of spline
'''
ts = np.linspace(0, 1, 1000)
xs, ys, zs = splev(ts, s)
spline = zip(xs, ys, zs)
ipoint = spline[0]
totl = 0
for point in spline:
totl += distance(point, ipoint)
ipoint = point
return totl
def tighten(self):
''' Calibrate node lengths to current position of camera.
Enter ' ' to tighten
Enter 's' to accept node length
'''
while True:
input = raw_input('Tightening Node A')
if input == ' ':
self.serA.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node B')
if input == ' ':
self.serB.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node C')
if input == ' ':
self.serC.write('-100g')
elif input == 's':
return
class Path:
''' Path object stores a path's points, node lengths, and length differences
to enable in path traversal.
'''
def __init__(self, points, node0, node1, node2):
''' Init method for Path class.
Input:
points: (list of tuples of floats)
node0, 1, 2: (tuple of floats)
Returns:
Initializes Path attributes
'''
self.points = points
self.lens0 = [distance(node0, point) for point in points]
self.lens1 = [distance(node1, point) for point in points]
self.lens2 = [distance(node2, point) for point in points]
self.diffs0 = self.diff_calc(self.lens0)
self.diffs1 = self.diff_calc(self.lens1)
self.diffs2 = self.diff_calc(self.lens2)
@staticmethod
def new_path(points, node0, node1, | binary_search | identifier_name |
Skycam.py | (tuple of floats) coordinates of node0, node1, node2
'''
# Project lengths into xy plane
a_eff = ((zC-zB)**2 + c**2)**.5
b_eff = (zC**2 + b**2)**.5
c_eff = (zB**2 + c**2)**.5
# Law of cosines
numer = b_eff**2 + c_eff**2 - a_eff**2
denom = 2*b_eff*c_eff
Arad = acos(numer/denom)
# Law of sines
Brad = asin(b*sin(Arad)/a)
Crad = asin(c*sin(Arad)/a)
theta = .5*pi-Arad
return (0,0, 0), (0, c, zB), (b*cos(theta), b*sin(theta), zC)
def load_path(self, points):
''' Create a new path based on predetermined points.
Inputs:
points: (list of tuples of floats) specific camera positions for
any given time.
Returns:
Initializes new Path in Skycam's path attribute
'''
self.path = Path.new_path(points, self.node0, self.node1, self.node2)
def create_path(self, waypoints, steps):
| # create spline and calculate length
s, us = splprep([xpoints, ypoints, zpoints], s=s, k=k, nest=nest)
totl = self.splineLen(s)
dl = totl/steps
if dl > 1:
print "dl greater than 1!"
i = 0
u = 0
upath = [u]
# Divide path into equidistant lengths
while i < steps-1:
u = self.binary_search(u, s, dl) # optionally pass tolerance
upath.append(u)
print i
i += 1
path = [splev(u, s) for u in upath]
path_lens = []
for i in xrange(len(path) - 1):
path_lens.append(distance(path[i], path[i+1]))
error = [ele - dl for ele in path_lens]
print 'Error is: ', sum(error)/len(error)
self.load_path(path)
# self.path = Path.new_path(path, self.node0, self.node1, self.node2)
def go_path(self, start):
'''Send appropriate movement commands for loaded path.
Input:
start: (int) index of path at which to begin sending commands
'''
#TODO: Implement save point
while (not self.direct and not self.pause):
for i in xrange(len(self.path.diffs0) - start):
self.send_command(self.path.diffs0[i + start], self.path.diffs1[i + start], self.path.diffs2[i + start])
# raw_input('')
self.save_point = i
break
# def pause_path(self):
# ''' Pause path traversal.'''
# self.pause = True
# def switch_mode(self):
# ''' Switch from path control to joystick control '''
# self.direct = not self.direct
# def go_input(self):
# ''' Translate a direct-control input into a directional vector and send appropriate commands '''
# pass
def connect(self, baud=57600):
''' Connect to proper serial ports for Bluetooth communication.
Inputs:
baud: (int) baud rate at which to connect
Returns:
Print confirmation of connection
'''
# Connect to proper serial ports
self.serA = serial.Serial('/dev/rfcomm0', baud, timeout=50)
self.serB = serial.Serial('/dev/rfcomm1', baud, timeout=50)
self.serC = serial.Serial('/dev/rfcomm2', baud, timeout=50)
print 'Hacking the mainframe...'
sleep(8)
print 'Mainframe hacked'
def send_command(self, diff0, diff1, diff2):
'''Send proper commands to all three serial ports.
Inputs:
diff0: (float) node length difference for node 0
diff1: (float) node length difference for node 1
diff2: (float) node length difference for node 2
'''
print diff0, diff1, diff2
self.serA.write(str(diff0) + 'g')
self.serB.write(str(diff1) + 'g')
self.serC.write(str(diff2) + 'g')
#TODO: Always mess around with this value
sleep(.35)
pass
# def dldp(self, nodePos, theta, phi):
# ''' use a directional vector and current position to calculate change in node length '''
# cam = self.cam
# deltaX = cam[0] - nodePos[0]
# deltaY = cam[1] - nodePos[1]
# deltaZ = cam[2] - nodePos[2]
# numer = deltaX*cos(theta)*cos(phi) + deltaY*sin(theta)*cos(phi) + deltaZ*sin(phi)
# denom = (deltaX**2 + deltaY**2 + deltaZ**2)**.5
# return numer/denom
def binary_search(self, ustart, s, dl, tol=.01):
''' Perform a binary search to find parametrized location of point.
Inputs:
ustart: (float)
s: (spline object)
dl: (float)
tol: (float)
Returns:
Reassigns middle and endpoints of search
um: (float) midpoint of search
'''
point = splev(ustart, s)
ui = ustart
uf = 1
um = (ui + uf)/2
xm, ym, zm = splev(um, s)
xf, yf, zf = splev(uf, s)
while True:
tpoint = splev(um, s)
if distance(point, tpoint)>(dl*(1+tol)):
uf, um = um, (um+ui)/2
elif distance(point, tpoint)<(dl*(1-tol)):
ui, um = um, (um+uf)/2
else:
return um
def splineLen(self, s):
''' Calculate length of a spline.
Inputs:
s: (spline object) represents path that joins waypoints
Returns:
(float) length of spline
'''
ts = np.linspace(0, 1, 1000)
xs, ys, zs = splev(ts, s)
spline = zip(xs, ys, zs)
ipoint = spline[0]
totl = 0
for point in spline:
totl += distance(point, ipoint)
ipoint = point
return totl
def tighten(self):
''' Calibrate node lengths to current position of camera.
Enter ' ' to tighten
Enter 's' to accept node length
'''
while True:
input = raw_input('Tightening Node A')
if input == ' ':
self.serA.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node B')
if input == ' ':
self.serB.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node C')
if input == ' ':
self.serC.write('-100g')
elif input == 's':
return
class Path:
''' Path object stores a path's points, node lengths, and length differences
to enable in path traversal.
'''
def __init__(self, points, node0, node1, node2):
''' Init method for Path class.
Input:
points: (list of tuples of floats)
node0, 1, 2: (tuple of floats)
Returns:
Initializes Path attributes
'''
self.points = points
self.lens0 = [distance(node0, point) for point in points]
self.lens1 = [distance(node1, point) for point in points]
self.lens2 = [distance(node2, point) for point in points]
self.diffs0 = self.diff_calc(self.lens0)
self.diffs1 = self.diff_calc(self.lens1)
self.diffs2 = self.diff_calc(self.lens2)
@staticmethod
def new_path(points, node0, node1, node | ''' Generate a new list of points based on waypoints.
Inputs:
waypoints: (list of tuples of floats): points the path should
bring the camera to
steps: (int) number of steps in which to complete the path
Returns:
Calls load_path method on list of generated spline points
'''
xpoints = [point[0] for point in waypoints]
ypoints = [point[1] for point in waypoints]
zpoints = [point[2] for point in waypoints]
# spline parameters
s = 2.0 # smoothness
k = 1 # spline order
nest = -1 # estimate of knots needed
| identifier_body |
Skycam.py | (tuple of floats) coordinates of node0, node1, node2
'''
# Project lengths into xy plane
a_eff = ((zC-zB)**2 + c**2)**.5
b_eff = (zC**2 + b**2)**.5
c_eff = (zB**2 + c**2)**.5
# Law of cosines
numer = b_eff**2 + c_eff**2 - a_eff**2
denom = 2*b_eff*c_eff
Arad = acos(numer/denom)
# Law of sines
Brad = asin(b*sin(Arad)/a)
Crad = asin(c*sin(Arad)/a)
theta = .5*pi-Arad
return (0,0, 0), (0, c, zB), (b*cos(theta), b*sin(theta), zC)
def load_path(self, points):
''' Create a new path based on predetermined points.
Inputs:
points: (list of tuples of floats) specific camera positions for
any given time.
Returns:
Initializes new Path in Skycam's path attribute
'''
self.path = Path.new_path(points, self.node0, self.node1, self.node2)
def create_path(self, waypoints, steps):
''' Generate a new list of points based on waypoints.
Inputs:
waypoints: (list of tuples of floats): points the path should
bring the camera to
steps: (int) number of steps in which to complete the path
Returns:
Calls load_path method on list of generated spline points
'''
xpoints = [point[0] for point in waypoints]
ypoints = [point[1] for point in waypoints]
zpoints = [point[2] for point in waypoints]
# spline parameters
s = 2.0 # smoothness
k = 1 # spline order
nest = -1 # estimate of knots needed
# create spline and calculate length
s, us = splprep([xpoints, ypoints, zpoints], s=s, k=k, nest=nest)
totl = self.splineLen(s)
dl = totl/steps
if dl > 1:
print "dl greater than 1!"
i = 0
u = 0
upath = [u]
# Divide path into equidistant lengths
while i < steps-1:
u = self.binary_search(u, s, dl) # optionally pass tolerance
upath.append(u)
print i
i += 1
path = [splev(u, s) for u in upath]
path_lens = []
for i in xrange(len(path) - 1):
path_lens.append(distance(path[i], path[i+1]))
error = [ele - dl for ele in path_lens]
print 'Error is: ', sum(error)/len(error)
self.load_path(path)
# self.path = Path.new_path(path, self.node0, self.node1, self.node2)
def go_path(self, start):
'''Send appropriate movement commands for loaded path.
Input:
start: (int) index of path at which to begin sending commands
'''
#TODO: Implement save point
while (not self.direct and not self.pause):
for i in xrange(len(self.path.diffs0) - start):
self.send_command(self.path.diffs0[i + start], self.path.diffs1[i + start], self.path.diffs2[i + start])
# raw_input('')
self.save_point = i
break
# def pause_path(self):
# ''' Pause path traversal.'''
# self.pause = True
# def switch_mode(self):
# ''' Switch from path control to joystick control '''
# self.direct = not self.direct
# def go_input(self):
# ''' Translate a direct-control input into a directional vector and send appropriate commands '''
# pass
def connect(self, baud=57600):
''' Connect to proper serial ports for Bluetooth communication.
Inputs:
baud: (int) baud rate at which to connect
Returns:
Print confirmation of connection
'''
# Connect to proper serial ports
self.serA = serial.Serial('/dev/rfcomm0', baud, timeout=50)
self.serB = serial.Serial('/dev/rfcomm1', baud, timeout=50)
self.serC = serial.Serial('/dev/rfcomm2', baud, timeout=50)
print 'Hacking the mainframe...'
sleep(8)
print 'Mainframe hacked'
def send_command(self, diff0, diff1, diff2):
'''Send proper commands to all three serial ports.
Inputs:
diff0: (float) node length difference for node 0
diff1: (float) node length difference for node 1
diff2: (float) node length difference for node 2
'''
print diff0, diff1, diff2
self.serA.write(str(diff0) + 'g')
self.serB.write(str(diff1) + 'g')
self.serC.write(str(diff2) + 'g')
#TODO: Always mess around with this value
sleep(.35)
pass
# def dldp(self, nodePos, theta, phi):
# ''' use a directional vector and current position to calculate change in node length '''
# cam = self.cam
# deltaX = cam[0] - nodePos[0]
# deltaY = cam[1] - nodePos[1]
# deltaZ = cam[2] - nodePos[2]
# numer = deltaX*cos(theta)*cos(phi) + deltaY*sin(theta)*cos(phi) + deltaZ*sin(phi)
# denom = (deltaX**2 + deltaY**2 + deltaZ**2)**.5
# return numer/denom
def binary_search(self, ustart, s, dl, tol=.01):
''' Perform a binary search to find parametrized location of point.
Inputs:
ustart: (float)
s: (spline object)
dl: (float)
tol: (float)
Returns:
Reassigns middle and endpoints of search
um: (float) midpoint of search
'''
point = splev(ustart, s)
ui = ustart
uf = 1
um = (ui + uf)/2
xm, ym, zm = splev(um, s)
xf, yf, zf = splev(uf, s)
while True:
tpoint = splev(um, s)
if distance(point, tpoint)>(dl*(1+tol)):
uf, um = um, (um+ui)/2
elif distance(point, tpoint)<(dl*(1-tol)):
ui, um = um, (um+uf)/2
else:
return um
def splineLen(self, s):
''' Calculate length of a spline.
Inputs:
s: (spline object) represents path that joins waypoints
Returns:
(float) length of spline
'''
ts = np.linspace(0, 1, 1000)
xs, ys, zs = splev(ts, s)
spline = zip(xs, ys, zs)
ipoint = spline[0]
totl = 0
for point in spline:
|
return totl
def tighten(self):
''' Calibrate node lengths to current position of camera.
Enter ' ' to tighten
Enter 's' to accept node length
'''
while True:
input = raw_input('Tightening Node A')
if input == ' ':
self.serA.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node B')
if input == ' ':
self.serB.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node C')
if input == ' ':
self.serC.write('-100g')
elif input == 's':
return
class Path:
''' Path object stores a path's points, node lengths, and length differences
to enable in path traversal.
'''
def __init__(self, points, node0, node1, node2):
''' Init method for Path class.
Input:
points: (list of tuples of floats)
node0, 1, 2: (tuple of floats)
Returns:
Initializes Path attributes
'''
self.points = points
self.lens0 = [distance(node0, point) for point in points]
self.lens1 = [distance(node1, point) for point in points]
self.lens2 = [distance(node2, point) for point in points]
self.diffs0 = self.diff_calc(self.lens0)
self.diffs1 = self.diff_calc(self.lens1)
self.diffs2 = self.diff_calc(self.lens2)
@staticmethod
def new_path(points, node0, node1, node | totl += distance(point, ipoint)
ipoint = point | conditional_block |
Skycam.py | (tuple of floats) coordinates of node0, node1, node2
'''
# Project lengths into xy plane
a_eff = ((zC-zB)**2 + c**2)**.5
b_eff = (zC**2 + b**2)**.5
c_eff = (zB**2 + c**2)**.5
# Law of cosines
numer = b_eff**2 + c_eff**2 - a_eff**2
denom = 2*b_eff*c_eff
Arad = acos(numer/denom)
# Law of sines
Brad = asin(b*sin(Arad)/a)
Crad = asin(c*sin(Arad)/a)
theta = .5*pi-Arad
return (0,0, 0), (0, c, zB), (b*cos(theta), b*sin(theta), zC)
def load_path(self, points):
''' Create a new path based on predetermined points.
Inputs:
points: (list of tuples of floats) specific camera positions for
any given time.
Returns:
Initializes new Path in Skycam's path attribute
'''
self.path = Path.new_path(points, self.node0, self.node1, self.node2)
def create_path(self, waypoints, steps):
''' Generate a new list of points based on waypoints.
Inputs:
waypoints: (list of tuples of floats): points the path should
bring the camera to | Calls load_path method on list of generated spline points
'''
xpoints = [point[0] for point in waypoints]
ypoints = [point[1] for point in waypoints]
zpoints = [point[2] for point in waypoints]
# spline parameters
s = 2.0 # smoothness
k = 1 # spline order
nest = -1 # estimate of knots needed
# create spline and calculate length
s, us = splprep([xpoints, ypoints, zpoints], s=s, k=k, nest=nest)
totl = self.splineLen(s)
dl = totl/steps
if dl > 1:
print "dl greater than 1!"
i = 0
u = 0
upath = [u]
# Divide path into equidistant lengths
while i < steps-1:
u = self.binary_search(u, s, dl) # optionally pass tolerance
upath.append(u)
print i
i += 1
path = [splev(u, s) for u in upath]
path_lens = []
for i in xrange(len(path) - 1):
path_lens.append(distance(path[i], path[i+1]))
error = [ele - dl for ele in path_lens]
print 'Error is: ', sum(error)/len(error)
self.load_path(path)
# self.path = Path.new_path(path, self.node0, self.node1, self.node2)
def go_path(self, start):
'''Send appropriate movement commands for loaded path.
Input:
start: (int) index of path at which to begin sending commands
'''
#TODO: Implement save point
while (not self.direct and not self.pause):
for i in xrange(len(self.path.diffs0) - start):
self.send_command(self.path.diffs0[i + start], self.path.diffs1[i + start], self.path.diffs2[i + start])
# raw_input('')
self.save_point = i
break
# def pause_path(self):
# ''' Pause path traversal.'''
# self.pause = True
# def switch_mode(self):
# ''' Switch from path control to joystick control '''
# self.direct = not self.direct
# def go_input(self):
# ''' Translate a direct-control input into a directional vector and send appropriate commands '''
# pass
def connect(self, baud=57600):
''' Connect to proper serial ports for Bluetooth communication.
Inputs:
baud: (int) baud rate at which to connect
Returns:
Print confirmation of connection
'''
# Connect to proper serial ports
self.serA = serial.Serial('/dev/rfcomm0', baud, timeout=50)
self.serB = serial.Serial('/dev/rfcomm1', baud, timeout=50)
self.serC = serial.Serial('/dev/rfcomm2', baud, timeout=50)
print 'Hacking the mainframe...'
sleep(8)
print 'Mainframe hacked'
def send_command(self, diff0, diff1, diff2):
'''Send proper commands to all three serial ports.
Inputs:
diff0: (float) node length difference for node 0
diff1: (float) node length difference for node 1
diff2: (float) node length difference for node 2
'''
print diff0, diff1, diff2
self.serA.write(str(diff0) + 'g')
self.serB.write(str(diff1) + 'g')
self.serC.write(str(diff2) + 'g')
#TODO: Always mess around with this value
sleep(.35)
pass
# def dldp(self, nodePos, theta, phi):
# ''' use a directional vector and current position to calculate change in node length '''
# cam = self.cam
# deltaX = cam[0] - nodePos[0]
# deltaY = cam[1] - nodePos[1]
# deltaZ = cam[2] - nodePos[2]
# numer = deltaX*cos(theta)*cos(phi) + deltaY*sin(theta)*cos(phi) + deltaZ*sin(phi)
# denom = (deltaX**2 + deltaY**2 + deltaZ**2)**.5
# return numer/denom
def binary_search(self, ustart, s, dl, tol=.01):
''' Perform a binary search to find parametrized location of point.
Inputs:
ustart: (float)
s: (spline object)
dl: (float)
tol: (float)
Returns:
Reassigns middle and endpoints of search
um: (float) midpoint of search
'''
point = splev(ustart, s)
ui = ustart
uf = 1
um = (ui + uf)/2
xm, ym, zm = splev(um, s)
xf, yf, zf = splev(uf, s)
while True:
tpoint = splev(um, s)
if distance(point, tpoint)>(dl*(1+tol)):
uf, um = um, (um+ui)/2
elif distance(point, tpoint)<(dl*(1-tol)):
ui, um = um, (um+uf)/2
else:
return um
def splineLen(self, s):
''' Calculate length of a spline.
Inputs:
s: (spline object) represents path that joins waypoints
Returns:
(float) length of spline
'''
ts = np.linspace(0, 1, 1000)
xs, ys, zs = splev(ts, s)
spline = zip(xs, ys, zs)
ipoint = spline[0]
totl = 0
for point in spline:
totl += distance(point, ipoint)
ipoint = point
return totl
def tighten(self):
''' Calibrate node lengths to current position of camera.
Enter ' ' to tighten
Enter 's' to accept node length
'''
while True:
input = raw_input('Tightening Node A')
if input == ' ':
self.serA.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node B')
if input == ' ':
self.serB.write('-100g')
elif input == 's':
break
while True:
input = raw_input('Tightening Node C')
if input == ' ':
self.serC.write('-100g')
elif input == 's':
return
class Path:
''' Path object stores a path's points, node lengths, and length differences
to enable in path traversal.
'''
def __init__(self, points, node0, node1, node2):
''' Init method for Path class.
Input:
points: (list of tuples of floats)
node0, 1, 2: (tuple of floats)
Returns:
Initializes Path attributes
'''
self.points = points
self.lens0 = [distance(node0, point) for point in points]
self.lens1 = [distance(node1, point) for point in points]
self.lens2 = [distance(node2, point) for point in points]
self.diffs0 = self.diff_calc(self.lens0)
self.diffs1 = self.diff_calc(self.lens1)
self.diffs2 = self.diff_calc(self.lens2)
@staticmethod
def new_path(points, node0, node1, node2 | steps: (int) number of steps in which to complete the path
Returns: | random_line_split |
kafka.go | if publishBuilderEntry.encoded == nil && publishBuilderEntry.err == nil {
if publishBuilderEntry.traceId == "" {
publishBuilderEntry.traceId = generateID()
}
if publishBuilderEntry.messageId == "" {
publishBuilderEntry.messageId = generateID()
}
publishBuilderEntry.encoded, publishBuilderEntry.err = json.Marshal(Message{
Message: publishBuilderEntry.message,
MessageType: publishBuilderEntry.messageType,
Service: publishBuilderEntry.service,
TraceId: publishBuilderEntry.traceId,
MessageId: publishBuilderEntry.messageId,
})
}
}
// Encode PublishBuilder into array of bytes
func (publishBuilderEntry *PublishBuilderEntry) Encode() ([]byte, error) {
publishBuilderEntry.ensureEncoded()
return publishBuilderEntry.encoded, publishBuilderEntry.err
}
// Length returns size of encoded value
func (publishBuilderEntry *PublishBuilderEntry) Length() int {
publishBuilderEntry.ensureEncoded()
return len(publishBuilderEntry.encoded)
}
// NewKafkaClient create a new instance of KafkaClient
func NewKafkaClient(brokerList []string, realm string) (*KafkaClient, error) {
return initKafkaClient(brokerList, realm, nil)
}
// NewKafkaClientWithAuthentication create a new instance of KafkaClient with Authentication
func NewKafkaClientWithAuthentication(brokerList []string, realm string, securityConfig *SecurityConfig) (*KafkaClient, error) {
return initKafkaClient(brokerList, realm, securityConfig)
}
func initKafkaClient(brokerList []string, realm string, securityConfig *SecurityConfig) (*KafkaClient, error) {
config := sarama.NewConfig()
config.Version = sarama.V2_1_0_0
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(config, securityConfig)
}
// currently only support 1 message broker
broker := sarama.NewBroker(brokerList[0])
err := broker.Open(config)
if err != nil {
logrus.Error("unable to open kafka")
return nil, err
}
if connected, err := broker.Connected(); !connected {
logrus.Error("unable connect to kafka")
return nil, err
}
configAsync := sarama.NewConfig()
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configAsync, securityConfig)
}
asyncProducer, err := sarama.NewAsyncProducer(brokerList, configAsync)
if err != nil {
logrus.Error("unable to create async producer in kafka : ", err)
return nil, err
}
configSync := sarama.NewConfig()
configSync.Producer.Return.Successes = true
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configSync, securityConfig)
}
syncProducer, err := sarama.NewSyncProducer(brokerList, configSync)
if err != nil {
logrus.Error("unable to create sync producer in kafka : ", err)
return nil, err
}
consumer, err := sarama.NewConsumer(brokerList, config)
if err != nil {
logrus.Error("Unable to create consumer in kafka : ", err)
return nil, err
}
client := &KafkaClient{
asyncProducer,
syncProducer,
consumer,
broker,
realm,
}
subscribeMap = make(map[string]map[string]func(message *Message, err error))
go listenAsyncError(asyncProducer)
go cleanup(client)
return client, nil
}
func configureSASLScramAuthentication(config *sarama.Config, securityConfig *SecurityConfig) {
config.Net.SASL.Enable = true
config.Net.SASL.User = securityConfig.SASLUsername
config.Net.SASL.Password = securityConfig.SASLPassword
config.Net.SASL.Handshake = true
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &SCRAMClient{HashGeneratorFcn: sha512.New} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA512
config.Net.TLS.Enable = true
config.Net.TLS.Config = &tls.Config{}
}
func cleanup(client *KafkaClient) {
// define signal notify
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
func() {
for {
select {
case <-sig:
_ = client.asyncProducer.Close()
_ = client.syncProducer.Close()
_ = client.consumer.Close()
_ = client.broker.Close()
}
}
}()
}
func listenAsyncError(producer sarama.AsyncProducer) {
for err := range producer.Errors() {
logrus.Error("unable to publish message using async producer to kafka : ", err)
}
}
func constructTopic(realm, topic string) string {
return realm + separator + topic
}
// SetTimeout set listening timeout for publish with response
func (client *KafkaClient) SetTimeout(timeout int) {
publishResponseTimeout = time.Duration(timeout)
}
// PublishAsync push a message to message broker topic asynchronously
func (client *KafkaClient) PublishAsync(publishBuilder *PublishBuilder) {
// send message
client.asyncProducer.Input() <- &sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: constructTopic(client.realm, publishBuilder.topic),
}
}
// PublishSync push a message to message broker topic synchronously
func (client *KafkaClient) PublishSync(publishBuilder *PublishBuilder) error {
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: constructTopic(client.realm, publishBuilder.topic),
})
if err != nil {
logrus.Error("unable to publish message using sync producer to kafka : ", err)
}
return err
}
// PublishWithResponses push a message to message broker topic synchronously and waiting response consumer until timeout
// Intended for Point to Point Communication
func (client *KafkaClient) PublishWithResponses(publishBuilder *PublishBuilder) {
topic := constructTopic(client.realm, publishBuilder.topic)
// register callback into map with topic and message Type as a key
// need to create topic, if the keys doesn't exists
if registerCallback(topic, publishBuilder.messageType, publishBuilder.callback) | else {
defer func() {
err := deleteTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to delete topic in kafka : ", err)
return
}
}()
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for timeout := time.After(time.Duration(publishResponseTimeout) * time.Millisecond); ; {
select {
case consumerMessage := <-consumer.Messages():
if !processResponseMessage(consumerMessage, publishBuilder.messageId) {
continue
}
break
case err = <-consumer.Errors():
callback := publishBuilder.callback
callback(nil, err)
break
case <-timeout:
callback := publishBuilder.callback
callback(nil, rtoError)
break
}
}
}()
}
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: topic,
})
if err != nil {
logrus.Error("unable to publish message in publish with response to kafka : ", err)
return
}
}
// Register add subscriber for a topic and register callback function
func (client *KafkaClient) Register(subscribeBuilder *SubscribeBuilder) {
topic := constructTopic(client.realm, subscribeBuilder.topic)
if registerCallback(topic, subscribeBuilder.messageType, subscribeBuilder.callback) {
logrus.Error("topic and message type already registered")
return
}
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
// each topic would have his own goroutine
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for {
select {
case consumerMessage := <-consumer.Messages():
processMessage(consumerMessage)
break
case err = <-consumer.Errors():
callback := subscribeBuilder.callback
callback(nil, err)
break | {
logrus.Warn("topic and message type already registered")
} | conditional_block |
kafka.go | if publishBuilderEntry.encoded == nil && publishBuilderEntry.err == nil {
if publishBuilderEntry.traceId == "" {
publishBuilderEntry.traceId = generateID()
}
if publishBuilderEntry.messageId == "" {
publishBuilderEntry.messageId = generateID()
}
publishBuilderEntry.encoded, publishBuilderEntry.err = json.Marshal(Message{
Message: publishBuilderEntry.message,
MessageType: publishBuilderEntry.messageType,
Service: publishBuilderEntry.service,
TraceId: publishBuilderEntry.traceId,
MessageId: publishBuilderEntry.messageId,
})
}
}
// Encode PublishBuilder into array of bytes
func (publishBuilderEntry *PublishBuilderEntry) Encode() ([]byte, error) {
publishBuilderEntry.ensureEncoded()
return publishBuilderEntry.encoded, publishBuilderEntry.err
}
// Length returns size of encoded value
func (publishBuilderEntry *PublishBuilderEntry) Length() int {
publishBuilderEntry.ensureEncoded()
return len(publishBuilderEntry.encoded)
}
// NewKafkaClient create a new instance of KafkaClient
func NewKafkaClient(brokerList []string, realm string) (*KafkaClient, error) {
return initKafkaClient(brokerList, realm, nil)
}
// NewKafkaClientWithAuthentication create a new instance of KafkaClient with Authentication
func NewKafkaClientWithAuthentication(brokerList []string, realm string, securityConfig *SecurityConfig) (*KafkaClient, error) {
return initKafkaClient(brokerList, realm, securityConfig)
}
func initKafkaClient(brokerList []string, realm string, securityConfig *SecurityConfig) (*KafkaClient, error) {
config := sarama.NewConfig()
config.Version = sarama.V2_1_0_0
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(config, securityConfig)
}
// currently only support 1 message broker
broker := sarama.NewBroker(brokerList[0])
err := broker.Open(config)
if err != nil {
logrus.Error("unable to open kafka")
return nil, err
}
if connected, err := broker.Connected(); !connected {
logrus.Error("unable connect to kafka")
return nil, err
}
configAsync := sarama.NewConfig()
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configAsync, securityConfig)
}
asyncProducer, err := sarama.NewAsyncProducer(brokerList, configAsync)
if err != nil {
logrus.Error("unable to create async producer in kafka : ", err)
return nil, err
}
configSync := sarama.NewConfig()
configSync.Producer.Return.Successes = true
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configSync, securityConfig)
}
syncProducer, err := sarama.NewSyncProducer(brokerList, configSync)
if err != nil {
logrus.Error("unable to create sync producer in kafka : ", err)
return nil, err
}
consumer, err := sarama.NewConsumer(brokerList, config)
if err != nil {
logrus.Error("Unable to create consumer in kafka : ", err)
return nil, err
}
client := &KafkaClient{
asyncProducer,
syncProducer,
consumer,
broker,
realm,
}
subscribeMap = make(map[string]map[string]func(message *Message, err error))
go listenAsyncError(asyncProducer)
go cleanup(client)
return client, nil
}
func configureSASLScramAuthentication(config *sarama.Config, securityConfig *SecurityConfig) {
config.Net.SASL.Enable = true
config.Net.SASL.User = securityConfig.SASLUsername
config.Net.SASL.Password = securityConfig.SASLPassword
config.Net.SASL.Handshake = true
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &SCRAMClient{HashGeneratorFcn: sha512.New} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA512
config.Net.TLS.Enable = true
config.Net.TLS.Config = &tls.Config{}
}
func cleanup(client *KafkaClient) {
// define signal notify
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
func() {
for {
select {
case <-sig:
_ = client.asyncProducer.Close()
_ = client.syncProducer.Close()
_ = client.consumer.Close()
_ = client.broker.Close()
}
}
}()
}
func listenAsyncError(producer sarama.AsyncProducer) {
for err := range producer.Errors() {
logrus.Error("unable to publish message using async producer to kafka : ", err)
}
}
func constructTopic(realm, topic string) string {
return realm + separator + topic
}
// SetTimeout set listening timeout for publish with response
func (client *KafkaClient) SetTimeout(timeout int) {
publishResponseTimeout = time.Duration(timeout)
}
// PublishAsync push a message to message broker topic asynchronously
func (client *KafkaClient) PublishAsync(publishBuilder *PublishBuilder) {
// send message
client.asyncProducer.Input() <- &sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
}, |
// PublishSync push a message to message broker topic synchronously
func (client *KafkaClient) PublishSync(publishBuilder *PublishBuilder) error {
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: constructTopic(client.realm, publishBuilder.topic),
})
if err != nil {
logrus.Error("unable to publish message using sync producer to kafka : ", err)
}
return err
}
// PublishWithResponses push a message to message broker topic synchronously and waiting response consumer until timeout
// Intended for Point to Point Communication
func (client *KafkaClient) PublishWithResponses(publishBuilder *PublishBuilder) {
topic := constructTopic(client.realm, publishBuilder.topic)
// register callback into map with topic and message Type as a key
// need to create topic, if the keys doesn't exists
if registerCallback(topic, publishBuilder.messageType, publishBuilder.callback) {
logrus.Warn("topic and message type already registered")
} else {
defer func() {
err := deleteTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to delete topic in kafka : ", err)
return
}
}()
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for timeout := time.After(time.Duration(publishResponseTimeout) * time.Millisecond); ; {
select {
case consumerMessage := <-consumer.Messages():
if !processResponseMessage(consumerMessage, publishBuilder.messageId) {
continue
}
break
case err = <-consumer.Errors():
callback := publishBuilder.callback
callback(nil, err)
break
case <-timeout:
callback := publishBuilder.callback
callback(nil, rtoError)
break
}
}
}()
}
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: topic,
})
if err != nil {
logrus.Error("unable to publish message in publish with response to kafka : ", err)
return
}
}
// Register add subscriber for a topic and register callback function
func (client *KafkaClient) Register(subscribeBuilder *SubscribeBuilder) {
topic := constructTopic(client.realm, subscribeBuilder.topic)
if registerCallback(topic, subscribeBuilder.messageType, subscribeBuilder.callback) {
logrus.Error("topic and message type already registered")
return
}
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
// each topic would have his own goroutine
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for {
select {
case consumerMessage := <-consumer.Messages():
processMessage(consumerMessage)
break
case err = <-consumer.Errors():
callback := subscribeBuilder.callback
callback(nil, err)
break | Topic: constructTopic(client.realm, publishBuilder.topic),
}
} | random_line_split |
kafka.go | publishBuilderEntry.ensureEncoded()
return publishBuilderEntry.encoded, publishBuilderEntry.err
}
// Length returns size of encoded value
func (publishBuilderEntry *PublishBuilderEntry) Length() int {
publishBuilderEntry.ensureEncoded()
return len(publishBuilderEntry.encoded)
}
// NewKafkaClient create a new instance of KafkaClient
func NewKafkaClient(brokerList []string, realm string) (*KafkaClient, error) {
return initKafkaClient(brokerList, realm, nil)
}
// NewKafkaClientWithAuthentication create a new instance of KafkaClient with Authentication
func NewKafkaClientWithAuthentication(brokerList []string, realm string, securityConfig *SecurityConfig) (*KafkaClient, error) {
return initKafkaClient(brokerList, realm, securityConfig)
}
func initKafkaClient(brokerList []string, realm string, securityConfig *SecurityConfig) (*KafkaClient, error) {
config := sarama.NewConfig()
config.Version = sarama.V2_1_0_0
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(config, securityConfig)
}
// currently only support 1 message broker
broker := sarama.NewBroker(brokerList[0])
err := broker.Open(config)
if err != nil {
logrus.Error("unable to open kafka")
return nil, err
}
if connected, err := broker.Connected(); !connected {
logrus.Error("unable connect to kafka")
return nil, err
}
configAsync := sarama.NewConfig()
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configAsync, securityConfig)
}
asyncProducer, err := sarama.NewAsyncProducer(brokerList, configAsync)
if err != nil {
logrus.Error("unable to create async producer in kafka : ", err)
return nil, err
}
configSync := sarama.NewConfig()
configSync.Producer.Return.Successes = true
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configSync, securityConfig)
}
syncProducer, err := sarama.NewSyncProducer(brokerList, configSync)
if err != nil {
logrus.Error("unable to create sync producer in kafka : ", err)
return nil, err
}
consumer, err := sarama.NewConsumer(brokerList, config)
if err != nil {
logrus.Error("Unable to create consumer in kafka : ", err)
return nil, err
}
client := &KafkaClient{
asyncProducer,
syncProducer,
consumer,
broker,
realm,
}
subscribeMap = make(map[string]map[string]func(message *Message, err error))
go listenAsyncError(asyncProducer)
go cleanup(client)
return client, nil
}
func configureSASLScramAuthentication(config *sarama.Config, securityConfig *SecurityConfig) {
config.Net.SASL.Enable = true
config.Net.SASL.User = securityConfig.SASLUsername
config.Net.SASL.Password = securityConfig.SASLPassword
config.Net.SASL.Handshake = true
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &SCRAMClient{HashGeneratorFcn: sha512.New} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA512
config.Net.TLS.Enable = true
config.Net.TLS.Config = &tls.Config{}
}
func cleanup(client *KafkaClient) {
// define signal notify
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
func() {
for {
select {
case <-sig:
_ = client.asyncProducer.Close()
_ = client.syncProducer.Close()
_ = client.consumer.Close()
_ = client.broker.Close()
}
}
}()
}
func listenAsyncError(producer sarama.AsyncProducer) {
for err := range producer.Errors() {
logrus.Error("unable to publish message using async producer to kafka : ", err)
}
}
func constructTopic(realm, topic string) string {
return realm + separator + topic
}
// SetTimeout set listening timeout for publish with response
func (client *KafkaClient) SetTimeout(timeout int) {
publishResponseTimeout = time.Duration(timeout)
}
// PublishAsync push a message to message broker topic asynchronously
func (client *KafkaClient) PublishAsync(publishBuilder *PublishBuilder) {
// send message
client.asyncProducer.Input() <- &sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: constructTopic(client.realm, publishBuilder.topic),
}
}
// PublishSync push a message to message broker topic synchronously
func (client *KafkaClient) PublishSync(publishBuilder *PublishBuilder) error {
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: constructTopic(client.realm, publishBuilder.topic),
})
if err != nil {
logrus.Error("unable to publish message using sync producer to kafka : ", err)
}
return err
}
// PublishWithResponses push a message to message broker topic synchronously and waiting response consumer until timeout
// Intended for Point to Point Communication
func (client *KafkaClient) PublishWithResponses(publishBuilder *PublishBuilder) {
topic := constructTopic(client.realm, publishBuilder.topic)
// register callback into map with topic and message Type as a key
// need to create topic, if the keys doesn't exists
if registerCallback(topic, publishBuilder.messageType, publishBuilder.callback) {
logrus.Warn("topic and message type already registered")
} else {
defer func() {
err := deleteTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to delete topic in kafka : ", err)
return
}
}()
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for timeout := time.After(time.Duration(publishResponseTimeout) * time.Millisecond); ; {
select {
case consumerMessage := <-consumer.Messages():
if !processResponseMessage(consumerMessage, publishBuilder.messageId) {
continue
}
break
case err = <-consumer.Errors():
callback := publishBuilder.callback
callback(nil, err)
break
case <-timeout:
callback := publishBuilder.callback
callback(nil, rtoError)
break
}
}
}()
}
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: topic,
})
if err != nil {
logrus.Error("unable to publish message in publish with response to kafka : ", err)
return
}
}
// Register add subscriber for a topic and register callback function
func (client *KafkaClient) Register(subscribeBuilder *SubscribeBuilder) {
topic := constructTopic(client.realm, subscribeBuilder.topic)
if registerCallback(topic, subscribeBuilder.messageType, subscribeBuilder.callback) {
logrus.Error("topic and message type already registered")
return
}
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
// each topic would have his own goroutine
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for {
select {
case consumerMessage := <-consumer.Messages():
processMessage(consumerMessage)
break
case err = <-consumer.Errors():
callback := subscribeBuilder.callback
callback(nil, err)
break
}
}
}()
}
// createTopic create kafka topic
func createTopic(broker *sarama.Broker, topicName string) error {
topicDetail := &sarama.TopicDetail{}
topicDetail.NumPartitions = int32(1)
topicDetail.ReplicationFactor = int16(1)
topicDetail.ConfigEntries = make(map[string]*string)
topicDetails := make(map[string]*sarama.TopicDetail)
topicDetails[topicName] = topicDetail
request := sarama.CreateTopicsRequest{
Timeout: time.Second * 15,
TopicDetails: topicDetails,
}
_, err := broker.CreateTopics(&request)
return err
}
// deleteTopic delete kafka topic
func | deleteTopic | identifier_name |
|
kafka.go | logrus.Error("unable to open kafka")
return nil, err
}
if connected, err := broker.Connected(); !connected {
logrus.Error("unable connect to kafka")
return nil, err
}
configAsync := sarama.NewConfig()
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configAsync, securityConfig)
}
asyncProducer, err := sarama.NewAsyncProducer(brokerList, configAsync)
if err != nil {
logrus.Error("unable to create async producer in kafka : ", err)
return nil, err
}
configSync := sarama.NewConfig()
configSync.Producer.Return.Successes = true
if securityConfig != nil && securityConfig.AuthenticationType == saslScramAuth {
configureSASLScramAuthentication(configSync, securityConfig)
}
syncProducer, err := sarama.NewSyncProducer(brokerList, configSync)
if err != nil {
logrus.Error("unable to create sync producer in kafka : ", err)
return nil, err
}
consumer, err := sarama.NewConsumer(brokerList, config)
if err != nil {
logrus.Error("Unable to create consumer in kafka : ", err)
return nil, err
}
client := &KafkaClient{
asyncProducer,
syncProducer,
consumer,
broker,
realm,
}
subscribeMap = make(map[string]map[string]func(message *Message, err error))
go listenAsyncError(asyncProducer)
go cleanup(client)
return client, nil
}
func configureSASLScramAuthentication(config *sarama.Config, securityConfig *SecurityConfig) {
config.Net.SASL.Enable = true
config.Net.SASL.User = securityConfig.SASLUsername
config.Net.SASL.Password = securityConfig.SASLPassword
config.Net.SASL.Handshake = true
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &SCRAMClient{HashGeneratorFcn: sha512.New} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA512
config.Net.TLS.Enable = true
config.Net.TLS.Config = &tls.Config{}
}
func cleanup(client *KafkaClient) {
// define signal notify
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
func() {
for {
select {
case <-sig:
_ = client.asyncProducer.Close()
_ = client.syncProducer.Close()
_ = client.consumer.Close()
_ = client.broker.Close()
}
}
}()
}
func listenAsyncError(producer sarama.AsyncProducer) {
for err := range producer.Errors() {
logrus.Error("unable to publish message using async producer to kafka : ", err)
}
}
func constructTopic(realm, topic string) string {
return realm + separator + topic
}
// SetTimeout set listening timeout for publish with response
func (client *KafkaClient) SetTimeout(timeout int) {
publishResponseTimeout = time.Duration(timeout)
}
// PublishAsync push a message to message broker topic asynchronously
func (client *KafkaClient) PublishAsync(publishBuilder *PublishBuilder) {
// send message
client.asyncProducer.Input() <- &sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: constructTopic(client.realm, publishBuilder.topic),
}
}
// PublishSync push a message to message broker topic synchronously
func (client *KafkaClient) PublishSync(publishBuilder *PublishBuilder) error {
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: constructTopic(client.realm, publishBuilder.topic),
})
if err != nil {
logrus.Error("unable to publish message using sync producer to kafka : ", err)
}
return err
}
// PublishWithResponses push a message to message broker topic synchronously and waiting response consumer until timeout
// Intended for Point to Point Communication
func (client *KafkaClient) PublishWithResponses(publishBuilder *PublishBuilder) {
topic := constructTopic(client.realm, publishBuilder.topic)
// register callback into map with topic and message Type as a key
// need to create topic, if the keys doesn't exists
if registerCallback(topic, publishBuilder.messageType, publishBuilder.callback) {
logrus.Warn("topic and message type already registered")
} else {
defer func() {
err := deleteTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to delete topic in kafka : ", err)
return
}
}()
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for timeout := time.After(time.Duration(publishResponseTimeout) * time.Millisecond); ; {
select {
case consumerMessage := <-consumer.Messages():
if !processResponseMessage(consumerMessage, publishBuilder.messageId) {
continue
}
break
case err = <-consumer.Errors():
callback := publishBuilder.callback
callback(nil, err)
break
case <-timeout:
callback := publishBuilder.callback
callback(nil, rtoError)
break
}
}
}()
}
// send message
_, _, err := client.syncProducer.SendMessage(&sarama.ProducerMessage{
Timestamp: time.Now().UTC(),
Value: &PublishBuilderEntry{
PublishBuilder: *publishBuilder,
},
Topic: topic,
})
if err != nil {
logrus.Error("unable to publish message in publish with response to kafka : ", err)
return
}
}
// Register add subscriber for a topic and register callback function
func (client *KafkaClient) Register(subscribeBuilder *SubscribeBuilder) {
topic := constructTopic(client.realm, subscribeBuilder.topic)
if registerCallback(topic, subscribeBuilder.messageType, subscribeBuilder.callback) {
logrus.Error("topic and message type already registered")
return
}
err := createTopic(client.broker, topic)
if err != nil {
logrus.Error("unable to create topic in kafka : ", err)
return
}
// listening a topic
// each topic would have his own goroutine
go func() {
consumer, err := client.consumer.ConsumePartition(topic, 0, sarama.OffsetNewest)
if err != nil {
logrus.Error("unable to consume topic from kafka : ", err)
return
}
for {
select {
case consumerMessage := <-consumer.Messages():
processMessage(consumerMessage)
break
case err = <-consumer.Errors():
callback := subscribeBuilder.callback
callback(nil, err)
break
}
}
}()
}
// createTopic create kafka topic
func createTopic(broker *sarama.Broker, topicName string) error {
topicDetail := &sarama.TopicDetail{}
topicDetail.NumPartitions = int32(1)
topicDetail.ReplicationFactor = int16(1)
topicDetail.ConfigEntries = make(map[string]*string)
topicDetails := make(map[string]*sarama.TopicDetail)
topicDetails[topicName] = topicDetail
request := sarama.CreateTopicsRequest{
Timeout: time.Second * 15,
TopicDetails: topicDetails,
}
_, err := broker.CreateTopics(&request)
return err
}
// deleteTopic delete kafka topic
func deleteTopic(broker *sarama.Broker, topicName string) error {
request := sarama.DeleteTopicsRequest{
Timeout: time.Second * topicTimeout,
Topics: []string{topicName},
}
_, err := broker.DeleteTopics(&request)
return err
}
// unmarshal unmarshal received message into message struct
func unmarshal(consumerMessage *sarama.ConsumerMessage) *Message {
var receivedMessage Message
err := json.Unmarshal(consumerMessage.Value, &receivedMessage)
if err != nil {
logrus.Error("unable to unmarshal message from consumer in kafka : ", err)
return &Message{}
}
return &receivedMessage
}
// registerCallback add callback to map with topic and message Type as a key
func registerCallback(topic, messageType string, callback func(message *Message, err error)) (isRegistered bool) | {
if subscribeMap == nil {
subscribeMap = make(map[string]map[string]func(message *Message, err error))
}
if callbackMap, isTopic := subscribeMap[topic]; isTopic {
if _, isMsgType := callbackMap[messageType]; isMsgType {
return true
}
}
newCallbackMap := make(map[string]func(message *Message, err error))
newCallbackMap[messageType] = callback
subscribeMap[topic] = newCallbackMap
return false
} | identifier_body |
|
pathfinding.py | range(0, layer.GetFeatureCount()):
feat = layer.GetFeature(i)
geom = feat.geometry()
if geom is None:
continue
line = []
if geom.GetGeometryCount() > 0:
for j in range(0, geom.GetGeometryCount()):
g = feat.geometry().GetGeometryRef(j)
for p in range(0, g.GetPointCount()):
pt = g.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
else:
for p in range(0, geom.GetPointCount()):
pt = geom.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
line_list.append(line)
return line_list
def point_generator(gridMap, type):
X, Y = gridMap.shape
while True:
p_x = random.randint(0, X)
p_y = random.randint(0, Y)
if gridMap[p_x][p_y] == type:
return p_x, p_y
def se_generator(gridMap):
s_x, s_y = point_generator(gridMap, 1)
e_x, e_y = point_generator(gridMap, 1)
return s_x, s_y, e_x, e_y
def run(_ver, _return_dict, start, end, neigh_range, gridMap, background, openset_size, length_part, degree_delta,
roads=None):
# time1 = time.time()
# gridMap = np.load('../res/sampled_sketch.npy')
# gridMap = np.load('map.npy')
# time2 = time.time()
# print("图片加载完毕，耗时{}".format(time2 - time1))
# maze = cv2.inRange(gridMap, 2.9, 3.1)
# start = (0, 0)
# end = (2500, 1000)
# neigh_range = (200, 250)
# sample_n = 20
# road1 = [(776, 523), (1425, 393), (2930, 122)]
# road2 = [(1285, 166), (1425, 393), (1880, 1075), (2020, 1973), (2086, 3737)]
# com_line = [(3125, 718), (900, 1700), (1000, 2265), (1166, 3337), (3060, 3142)]
# forbidden =
# finder = pathfinder(maze, neigh_range, sample_n, [road1, road2], [com_line], gridMap)
# print("maze shape:{},{}".format(gridMap.shape[0], gridMap.shape[1]))
# print("类型：起点:{},终点:{}".format(gridMap[start[1]][start[0]], gridMap[end[1]][end[0]]))
time3 = time.time()
plt.figure()
finder = pathfinder(_ver, gridMap, neigh_range, openset_size=openset_size, length_part=length_part,
degree_delta=degree_delta, roads=roads)
path, close_list = finder.astar(start, end)
if path is None:
# print("查找失败，无解")
for p in close_list:
cv2.circle(background, p, 5, (255, 0, 0), 2)
plt.imshow(background)
plt.savefig("output/{}/fail_fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:], _ver))
_return_dict[_ver] = 0
return False
time4 = time.time()
print("寻路完毕,耗时{}".format(time4 - time3))
p1 = path[0]
for p in close_list:
cv2.circle(background, p, 10, (0, 0, 255), 5)
for index, p in enumerate(path):
if index == 0:
continue
p2 = p
cv2.line(background, p1, p2, (255, 0, 0), 40)
p1 = p
for p in path:
cv2.circle(background, p, 10, (0, 0, 0), 40)
# for p in finder.close_set:
# cv2.circle(background, p, 3, (0, 255, 0))
plt.imshow(background)
plt.savefig(
"output/{}/fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:],
_ver))
np.save("output/{}/path__{}_ver{}.npy".format(unique_tag, str(round(time.time()))[-5:], _ver), np.array(path))
_return_dict[_ver] = 1
return 1
if __name__ == "__main__":
if not os.path.exists("output/"):
os.makedirs("output/")
if not os.path.exists("output/{}/".format(unique_tag)):
os.makedirs("output/{}/".format(unique_tag))
parser = argparse.ArgumentParser(description='电力寻路程序')
parser.add_argument("--gridMap", help="地图的路径", type=str)
parser.add_argument("--start", nargs="+", help="起点", type=int)
parser.add_argument("--end", nargs="+", help="终点", type=int)
parser.add_argument("-v", "--voltage", help="电压等级", type=int)
parser.add_argument("-b", "--buffer", help="搜索集大小", type=int)
parser.add_argument("-p", "--precision", help="搜索精确等级", type=int)
parser.add_argument("-r", "--road", help="道路SHP文件的路径", type=str)
args = parser.parse_args()
try:
start = (args.start[0], args.start[1])
except:
print("没有输入起点！")
try:
end = (args.end[0], args.end[1])
except:
print("没有输入终点！")
voltage_level = args.voltage
neigh_range = (500, 600)
if voltage_level == 35:
neigh_range = (100, 150)
elif voltage_level == 110:
neigh_range = (150, 250)
elif voltage_level == 220:
neigh_range = (250, 450)
elif voltage_level == 330:
neigh_range = (300, 400)
elif voltage_level == 500:
neigh_range = (350, 450)
elif voltage_level == 750:
neigh_range = (450, 500)
elif voltage_level == 1000:
neigh_range = (500, 600)
else:
raise Exception("电压等级输入错误！")
try:
openset_size = args.buffer
except:
print("请输入合适的搜索集大小！")
try:
precision = args.precision
except:
print("请输入搜索精确度！")
if precision == 1:
length_part = 5
degree_delta = 90 # 20
elif precision == 2:
length_part = 10
degree_delta = 90 # 40
elif precision == 3:
length_part = 10
degree_delta = 90 # 40
elif precision == 4:
length_part = 5
degree_delta = 45 # 40
elif precision == 5:
length_part = 10
degree_delta = 45 # 80
elif precision == 6:
length_part = 20
degree_delta = 45 # 160
elif precision == 7 | = 30 # 240
else:
length_part = 5
degree_delta = 90 # 20
print("读取TIFF文件中...")
try:
tif = TIFF.open(args.gridMap, mode='r') # 打開tiff文件進行讀取
except:
print("输入的路径有误！")
im = tif.read_image()
print("正在分析各类地块...")
class4 = cv2.inRange(im, 3.9, 4.1)
class1 | :
length_part = 20
degree_delta | conditional_block |
pathfinding.py | range(0, layer.GetFeatureCount()):
feat = layer.GetFeature(i)
geom = feat.geometry()
if geom is None:
continue
line = []
if geom.GetGeometryCount() > 0:
for j in range(0, geom.GetGeometryCount()):
g = feat.geometry().GetGeometryRef(j)
for p in range(0, g.GetPointCount()):
pt = g.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
else:
for p in range(0, geom.GetPointCount()):
pt = geom.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
line_list.append(line)
return line_list
def point_generator(gridMap, type):
X, Y = gridMap.shape
while True:
p_x = random.randint(0, X)
p_y = random.randint(0, Y)
if gridMap[p_x][p_y] == type:
return p_x, p_y
def se_generator(gridMap):
s_x, s_y = point_generator(gridMap, 1)
e_x, e_y = point_generator(gridMap, 1)
return s_x, s_y, e_x, e_y
def run(_ver, _return_dict, start, end, | , gridMap, background, openset_size, length_part, degree_delta,
roads=None):
# time1 = time.time()
# gridMap = np.load('../res/sampled_sketch.npy')
# gridMap = np.load('map.npy')
# time2 = time.time()
# print("图片加载完毕，耗时{}".format(time2 - time1))
# maze = cv2.inRange(gridMap, 2.9, 3.1)
# start = (0, 0)
# end = (2500, 1000)
# neigh_range = (200, 250)
# sample_n = 20
# road1 = [(776, 523), (1425, 393), (2930, 122)]
# road2 = [(1285, 166), (1425, 393), (1880, 1075), (2020, 1973), (2086, 3737)]
# com_line = [(3125, 718), (900, 1700), (1000, 2265), (1166, 3337), (3060, 3142)]
# forbidden =
# finder = pathfinder(maze, neigh_range, sample_n, [road1, road2], [com_line], gridMap)
# print("maze shape:{},{}".format(gridMap.shape[0], gridMap.shape[1]))
# print("类型：起点:{},终点:{}".format(gridMap[start[1]][start[0]], gridMap[end[1]][end[0]]))
time3 = time.time()
plt.figure()
finder = pathfinder(_ver, gridMap, neigh_range, openset_size=openset_size, length_part=length_part,
degree_delta=degree_delta, roads=roads)
path, close_list = finder.astar(start, end)
if path is None:
# print("查找失败，无解")
for p in close_list:
cv2.circle(background, p, 5, (255, 0, 0), 2)
plt.imshow(background)
plt.savefig("output/{}/fail_fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:], _ver))
_return_dict[_ver] = 0
return False
time4 = time.time()
print("寻路完毕,耗时{}".format(time4 - time3))
p1 = path[0]
for p in close_list:
cv2.circle(background, p, 10, (0, 0, 255), 5)
for index, p in enumerate(path):
if index == 0:
continue
p2 = p
cv2.line(background, p1, p2, (255, 0, 0), 40)
p1 = p
for p in path:
cv2.circle(background, p, 10, (0, 0, 0), 40)
# for p in finder.close_set:
# cv2.circle(background, p, 3, (0, 255, 0))
plt.imshow(background)
plt.savefig(
"output/{}/fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:],
_ver))
np.save("output/{}/path__{}_ver{}.npy".format(unique_tag, str(round(time.time()))[-5:], _ver), np.array(path))
_return_dict[_ver] = 1
return 1
if __name__ == "__main__":
if not os.path.exists("output/"):
os.makedirs("output/")
if not os.path.exists("output/{}/".format(unique_tag)):
os.makedirs("output/{}/".format(unique_tag))
parser = argparse.ArgumentParser(description='电力寻路程序')
parser.add_argument("--gridMap", help="地图的路径", type=str)
parser.add_argument("--start", nargs="+", help="起点", type=int)
parser.add_argument("--end", nargs="+", help="终点", type=int)
parser.add_argument("-v", "--voltage", help="电压等级", type=int)
parser.add_argument("-b", "--buffer", help="搜索集大小", type=int)
parser.add_argument("-p", "--precision", help="搜索精确等级", type=int)
parser.add_argument("-r", "--road", help="道路SHP文件的路径", type=str)
args = parser.parse_args()
try:
start = (args.start[0], args.start[1])
except:
print("没有输入起点！")
try:
end = (args.end[0], args.end[1])
except:
print("没有输入终点！")
voltage_level = args.voltage
neigh_range = (500, 600)
if voltage_level == 35:
neigh_range = (100, 150)
elif voltage_level == 110:
neigh_range = (150, 250)
elif voltage_level == 220:
neigh_range = (250, 450)
elif voltage_level == 330:
neigh_range = (300, 400)
elif voltage_level == 500:
neigh_range = (350, 450)
elif voltage_level == 750:
neigh_range = (450, 500)
elif voltage_level == 1000:
neigh_range = (500, 600)
else:
raise Exception("电压等级输入错误！")
try:
openset_size = args.buffer
except:
print("请输入合适的搜索集大小！")
try:
precision = args.precision
except:
print("请输入搜索精确度！")
if precision == 1:
length_part = 5
degree_delta = 90 # 20
elif precision == 2:
length_part = 10
degree_delta = 90 # 40
elif precision == 3:
length_part = 10
degree_delta = 90 # 40
elif precision == 4:
length_part = 5
degree_delta = 45 # 40
elif precision == 5:
length_part = 10
degree_delta = 45 # 80
elif precision == 6:
length_part = 20
degree_delta = 45 # 160
elif precision == 7:
length_part = 20
degree_delta = 30 # 240
else:
length_part = 5
degree_delta = 90 # 20
print("读取TIFF文件中...")
try:
tif = TIFF.open(args.gridMap, mode='r') # 打開tiff文件進行讀取
except:
print("输入的路径有误！")
im = tif.read_image()
print("正在分析各类地块...")
class4 = cv2.inRange(im, 3.9, 4.1)
class1 = | neigh_range | identifier_name |
pathfinding.py | range(0, layer.GetFeatureCount()):
feat = layer.GetFeature(i)
geom = feat.geometry()
if geom is None:
continue
line = []
if geom.GetGeometryCount() > 0:
for j in range(0, geom.GetGeometryCount()):
g = feat.geometry().GetGeometryRef(j)
for p in range(0, g.GetPointCount()):
pt = g.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
else:
for p in range(0, geom.GetPointCount()):
pt = geom.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
line_list.append(line)
return line_list
def point_generator(gridMap, type):
X, Y = gridMap.shape
while True:
p_x = random.randint(0, X)
p_y = random.randint(0, Y)
if gridMap[p_x][p_y] == type:
return p_x, p_y
def s | t, end, neigh_range, gridMap, background, openset_size, length_part, degree_delta,
roads=None):
# time1 = time.time()
# gridMap = np.load('../res/sampled_sketch.npy')
# gridMap = np.load('map.npy')
# time2 = time.time()
# print("图片加载完毕，耗时{}".format(time2 - time1))
# maze = cv2.inRange(gridMap, 2.9, 3.1)
# start = (0, 0)
# end = (2500, 1000)
# neigh_range = (200, 250)
# sample_n = 20
# road1 = [(776, 523), (1425, 393), (2930, 122)]
# road2 = [(1285, 166), (1425, 393), (1880, 1075), (2020, 1973), (2086, 3737)]
# com_line = [(3125, 718), (900, 1700), (1000, 2265), (1166, 3337), (3060, 3142)]
# forbidden =
# finder = pathfinder(maze, neigh_range, sample_n, [road1, road2], [com_line], gridMap)
# print("maze shape:{},{}".format(gridMap.shape[0], gridMap.shape[1]))
# print("类型：起点:{},终点:{}".format(gridMap[start[1]][start[0]], gridMap[end[1]][end[0]]))
time3 = time.time()
plt.figure()
finder = pathfinder(_ver, gridMap, neigh_range, openset_size=openset_size, length_part=length_part,
degree_delta=degree_delta, roads=roads)
path, close_list = finder.astar(start, end)
if path is None:
# print("查找失败，无解")
for p in close_list:
cv2.circle(background, p, 5, (255, 0, 0), 2)
plt.imshow(background)
plt.savefig("output/{}/fail_fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:], _ver))
_return_dict[_ver] = 0
return False
time4 = time.time()
print("寻路完毕,耗时{}".format(time4 - time3))
p1 = path[0]
for p in close_list:
cv2.circle(background, p, 10, (0, 0, 255), 5)
for index, p in enumerate(path):
if index == 0:
continue
p2 = p
cv2.line(background, p1, p2, (255, 0, 0), 40)
p1 = p
for p in path:
cv2.circle(background, p, 10, (0, 0, 0), 40)
# for p in finder.close_set:
# cv2.circle(background, p, 3, (0, 255, 0))
plt.imshow(background)
plt.savefig(
"output/{}/fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:],
_ver))
np.save("output/{}/path__{}_ver{}.npy".format(unique_tag, str(round(time.time()))[-5:], _ver), np.array(path))
_return_dict[_ver] = 1
return 1
if __name__ == "__main__":
if not os.path.exists("output/"):
os.makedirs("output/")
if not os.path.exists("output/{}/".format(unique_tag)):
os.makedirs("output/{}/".format(unique_tag))
parser = argparse.ArgumentParser(description='电力寻路程序')
parser.add_argument("--gridMap", help="地图的路径", type=str)
parser.add_argument("--start", nargs="+", help="起点", type=int)
parser.add_argument("--end", nargs="+", help="终点", type=int)
parser.add_argument("-v", "--voltage", help="电压等级", type=int)
parser.add_argument("-b", "--buffer", help="搜索集大小", type=int)
parser.add_argument("-p", "--precision", help="搜索精确等级", type=int)
parser.add_argument("-r", "--road", help="道路SHP文件的路径", type=str)
args = parser.parse_args()
try:
start = (args.start[0], args.start[1])
except:
print("没有输入起点！")
try:
end = (args.end[0], args.end[1])
except:
print("没有输入终点！")
voltage_level = args.voltage
neigh_range = (500, 600)
if voltage_level == 35:
neigh_range = (100, 150)
elif voltage_level == 110:
neigh_range = (150, 250)
elif voltage_level == 220:
neigh_range = (250, 450)
elif voltage_level == 330:
neigh_range = (300, 400)
elif voltage_level == 500:
neigh_range = (350, 450)
elif voltage_level == 750:
neigh_range = (450, 500)
elif voltage_level == 1000:
neigh_range = (500, 600)
else:
raise Exception("电压等级输入错误！")
try:
openset_size = args.buffer
except:
print("请输入合适的搜索集大小！")
try:
precision = args.precision
except:
print("请输入搜索精确度！")
if precision == 1:
length_part = 5
degree_delta = 90 # 20
elif precision == 2:
length_part = 10
degree_delta = 90 # 40
elif precision == 3:
length_part = 10
degree_delta = 90 # 40
elif precision == 4:
length_part = 5
degree_delta = 45 # 40
elif precision == 5:
length_part = 10
degree_delta = 45 # 80
elif precision == 6:
length_part = 20
degree_delta = 45 # 160
elif precision == 7:
length_part = 20
degree_delta = 30 # 240
else:
length_part = 5
degree_delta = 90 # 20
print("读取TIFF文件中...")
try:
tif = TIFF.open(args.gridMap, mode='r') # 打開tiff文件進行讀取
except:
print("输入的路径有误！")
im = tif.read_image()
print("正在分析各类地块...")
class4 = cv2.inRange(im, 3.9, 4.1)
class | e_generator(gridMap):
s_x, s_y = point_generator(gridMap, 1)
e_x, e_y = point_generator(gridMap, 1)
return s_x, s_y, e_x, e_y
def run(_ver, _return_dict, star | identifier_body |
pathfinding.py | range(0, layer.GetFeatureCount()):
feat = layer.GetFeature(i)
geom = feat.geometry()
if geom is None:
continue
line = []
if geom.GetGeometryCount() > 0:
for j in range(0, geom.GetGeometryCount()):
g = feat.geometry().GetGeometryRef(j)
for p in range(0, g.GetPointCount()):
pt = g.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
else:
for p in range(0, geom.GetPointCount()):
pt = geom.GetPoint(p)
# new_x,new_y=coordinate_transfer(pt[0],pt[1],layer_shape, sketch_shape)
# line.append((new_x,new_y))
line.append((int(pt[0]), int(layer_shape[3] - int(pt[1]))))
line_list.append(line)
return line_list
def point_generator(gridMap, type):
X, Y = gridMap.shape
while True:
p_x = random.randint(0, X)
p_y = random.randint(0, Y)
if gridMap[p_x][p_y] == type:
return p_x, p_y
def se_generator(gridMap):
s_x, s_y = point_generator(gridMap, 1)
e_x, e_y = point_generator(gridMap, 1)
return s_x, s_y, e_x, e_y
def run(_ver, _return_dict, start, end, neigh_range, gridMap, background, openset_size, length_part, degree_delta,
roads=None):
# time1 = time.time()
# gridMap = np.load('../res/sampled_sketch.npy')
# gridMap = np.load('map.npy')
# time2 = time.time()
# print("图片加载完毕，耗时{}".format(time2 - time1))
# maze = cv2.inRange(gridMap, 2.9, 3.1)
# start = (0, 0)
# end = (2500, 1000)
# neigh_range = (200, 250)
# sample_n = 20
# road1 = [(776, 523), (1425, 393), (2930, 122)]
# road2 = [(1285, 166), (1425, 393), (1880, 1075), (2020, 1973), (2086, 3737)]
# com_line = [(3125, 718), (900, 1700), (1000, 2265), (1166, 3337), (3060, 3142)]
# forbidden =
# finder = pathfinder(maze, neigh_range, sample_n, [road1, road2], [com_line], gridMap)
# print("maze shape:{},{}".format(gridMap.shape[0], gridMap.shape[1]))
# print("类型：起点:{},终点:{}".format(gridMap[start[1]][start[0]], gridMap[end[1]][end[0]]))
time3 = time.time()
plt.figure()
finder = pathfinder(_ver, gridMap, neigh_range, openset_size=openset_size, length_part=length_part,
degree_delta=degree_delta, roads=roads)
path, close_list = finder.astar(start, end)
if path is None:
# print("查找失败，无解")
for p in close_list:
cv2.circle(background, p, 5, (255, 0, 0), 2)
plt.imshow(background)
plt.savefig("output/{}/fail_fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:], _ver))
_return_dict[_ver] = 0
return False
time4 = time.time()
print("寻路完毕,耗时{}".format(time4 - time3))
p1 = path[0]
for p in close_list: | cv2.circle(background, p, 10, (0, 0, 255), 5)
for index, p in enumerate(path):
if index == 0:
continue
p2 = p
cv2.line(background, p1, p2, (255, 0, 0), 40)
p1 = p
for p in path:
cv2.circle(background, p, 10, (0, 0, 0), 40)
# for p in finder.close_set:
# cv2.circle(background, p, 3, (0, 255, 0))
plt.imshow(background)
plt.savefig(
"output/{}/fig_{}_{}_{}_ver{}.png".format(unique_tag, neigh_range[0], neigh_range[1],
str(round(time.time()))[-5:],
_ver))
np.save("output/{}/path__{}_ver{}.npy".format(unique_tag, str(round(time.time()))[-5:], _ver), np.array(path))
_return_dict[_ver] = 1
return 1
if __name__ == "__main__":
if not os.path.exists("output/"):
os.makedirs("output/")
if not os.path.exists("output/{}/".format(unique_tag)):
os.makedirs("output/{}/".format(unique_tag))
parser = argparse.ArgumentParser(description='电力寻路程序')
parser.add_argument("--gridMap", help="地图的路径", type=str)
parser.add_argument("--start", nargs="+", help="起点", type=int)
parser.add_argument("--end", nargs="+", help="终点", type=int)
parser.add_argument("-v", "--voltage", help="电压等级", type=int)
parser.add_argument("-b", "--buffer", help="搜索集大小", type=int)
parser.add_argument("-p", "--precision", help="搜索精确等级", type=int)
parser.add_argument("-r", "--road", help="道路SHP文件的路径", type=str)
args = parser.parse_args()
try:
start = (args.start[0], args.start[1])
except:
print("没有输入起点！")
try:
end = (args.end[0], args.end[1])
except:
print("没有输入终点！")
voltage_level = args.voltage
neigh_range = (500, 600)
if voltage_level == 35:
neigh_range = (100, 150)
elif voltage_level == 110:
neigh_range = (150, 250)
elif voltage_level == 220:
neigh_range = (250, 450)
elif voltage_level == 330:
neigh_range = (300, 400)
elif voltage_level == 500:
neigh_range = (350, 450)
elif voltage_level == 750:
neigh_range = (450, 500)
elif voltage_level == 1000:
neigh_range = (500, 600)
else:
raise Exception("电压等级输入错误！")
try:
openset_size = args.buffer
except:
print("请输入合适的搜索集大小！")
try:
precision = args.precision
except:
print("请输入搜索精确度！")
if precision == 1:
length_part = 5
degree_delta = 90 # 20
elif precision == 2:
length_part = 10
degree_delta = 90 # 40
elif precision == 3:
length_part = 10
degree_delta = 90 # 40
elif precision == 4:
length_part = 5
degree_delta = 45 # 40
elif precision == 5:
length_part = 10
degree_delta = 45 # 80
elif precision == 6:
length_part = 20
degree_delta = 45 # 160
elif precision == 7:
length_part = 20
degree_delta = 30 # 240
else:
length_part = 5
degree_delta = 90 # 20
print("读取TIFF文件中...")
try:
tif = TIFF.open(args.gridMap, mode='r') # 打開tiff文件進行讀取
except:
print("输入的路径有误！")
im = tif.read_image()
print("正在分析各类地块...")
class4 = cv2.inRange(im, 3.9, 4.1)
class1 = | random_line_split |
|
get_tips_nonlocal.py | or y for the padding:
[0... pad | pad ... width + pad | width + pad ... width + 2 * pad]
return -9999 if X is within rejection_distance of the edge,
return X if X is in [pad ... width + pad], which is if X is in the unpadded frame, which has width = width
else return X reflected onto the unpadded frame'''
P = rejection_distance
X -= pad
if X < -pad+P:
X = -9999 # throw out X later
elif X < 0:
X += width
if X > width+pad-P:
X = -9999 # throw out X later
elif X >= width:
X -= width
return X
# @njit
def textures_to_padded_textures(txt,dtexture_dt, pad):
'''large pad allows knots to be recorded right.
consider pad = int(512/2), edge_tolerance = int(512/4)'''
width, height = txt.shape[:2]
# padded_width = 512 + pad #pixels
padded_txt = np.pad(array = txt[...,0], pad_width = pad, mode = 'wrap')
dpadded_txt_dt = np.pad(array = dtexture_dt[...,0], pad_width = pad, mode = 'wrap')
return padded_txt, dpadded_txt_dt
def matrices_to_padded_matrices(txt,dtexture_dt, pad):
'''txt and dtexture_dt are rank two tensors. i.e. the channel_no is 1.
large pad allows knots to be recorded right.
'''
# width, height = txt.shape[:2]
# padded_width = 512 + pad #pixels
padded_txt = np.pad(array = txt, pad_width = pad, mode = 'wrap')
dpadded_txt_dt = np.pad(array = dtexture_dt, pad_width = pad, mode = 'wrap')
return padded_txt, dpadded_txt_dt
# #informal test for ^that
# padded_txt = np.pad(array = txt, pad_width = pad, mode = 'wrap')
# print(txt[0,0])
# print(padded_txt[...,2:5][pad,pad])
# @njit
def | (mat, pad, channel_no=3):
''''''
return np.pad(array = mat, pad_width = pad, mode = 'wrap')[...,pad:pad+channel_no]
# width, height = mat.shape[:2]
# padded_width = 512 + pad #pixels
# padded_mat = np.pad(array = mat, pad_width = pad, mode = 'wrap')
# return padded_mat[...,2:5]
# @njit
def pad_texture(txt, pad):
'''large pad allows knots to be recorded right.
consider pad = int(512/2), edge_tolerance = int(512/4)'''
width, height = txt.shape[:2]
# padded_width = 512 + pad #pixels
padded_txta = np.pad(array = txt[...,0], pad_width = pad, mode = 'wrap')
padded_txtb = np.pad(array = txt[...,1], pad_width = pad, mode = 'wrap')
padded_txtc = np.pad(array = txt[...,2], pad_width = pad, mode = 'wrap')
# dpadded_txt_dt = np.pad(array = dtexture_dt[...,0], pad_width = pad, mode = 'wrap')
return np.array([padded_txta,padded_txtb,padded_txtc]).T
def map_pbc_tips_back(tips, pad, width, height, edge_tolerance, atol = 1e-11):
'''width and height are from the shape of the unpadded buffer.
TODO: get intersection to be njit compiled, then njit map_pbc_tips_back,
for which I'll need to return to using numba.typed.List() instead of [].'''
atol_squared = atol**2
min_dist_squared_init = width**2
s_tips, x_tips, y_tips = tips
s1_mapped_lst = []; s2_mapped_lst = [];
x_mapped_lst = []; y_mapped_lst = [];
# s1_mapped_lst = List(); s2_mapped_lst = List();
# x_mapped_lst = List(); y_mapped_lst = List();
for n, x in enumerate(x_tips):
y = y_tips[n]; s = s_tips[n]
S1, S2 = s_tips[n]
y = y_tips[n]
for X, Y in zip(x, y):
X = unpad(X=X, pad=pad, width=width , rejection_distance=edge_tolerance)
if not (X == -9999):
Y = unpad(X=Y, pad=pad, width=height, rejection_distance=edge_tolerance)
if not (Y == -9999):
# find the index and distance to the nearest tip already on the mapped_lsts
min_dist_squared = min_dist_squared_init; min_index = -1
for j0, (x0,y0) in enumerate(zip(x_mapped_lst,y_mapped_lst)):
# compute the distance between x0,y0 and X,Y
dist_squared = (X-x0)**2+(Y-y0)**2
# if ^that distance is the smallest, update min_dist with it
if dist_squared < min_dist_squared:
min_dist_squared = dist_squared
min_index = j0
#if this new tip is sufficiently far from all other recorded tips,
if min_dist_squared >= atol:
# then append the entry to all four lists
x_mapped_lst.append(X)
y_mapped_lst.append(Y)
lst_S1 = []#List()
lst_S1.append(S1)
lst_S2 = []#List()
lst_S2.append(S2)
s1_mapped_lst.append(lst_S1)
s2_mapped_lst.append(lst_S2)
else:
#just append to the previous entry in the s1 and s2 lists if the contour isn't already there
s1_mapped_lst[min_index].append(S1)
s2_mapped_lst[min_index].append(S2)
return s1_mapped_lst, s2_mapped_lst, x_mapped_lst, y_mapped_lst
#########################################################################
# Interpolating Electrophysiological state values to spiral tip locations
#########################################################################
def get_state_nearest(x, y, txt):
'''nearest local texture values, ignore any index errors and/or periodic boundary conditions'''
xint = np.round(x).astype(dtype=int)
yint = np.round(y).astype(dtype=int)
try:
state_nearest = list(txt[xint,yint])
except IndexError:
state_nearest = nanstate
return state_nearest
#for get_state_interpolated
import sys
if not sys.warnoptions:
import warnings
warnings.simplefilter("ignore", category=RuntimeWarning, lineno=0, append=False)
#TODO: restrict ^this warning filter to onlyt get_state_interpolated
def get_state_interpolated(x, y, txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = 3, rad = 0.5, kind='linear'):
'''linear interpolation of local texture values to subpixel precision
using 2D linear interpolation with scipy.interpolate.interp2d.
channel_no must be len(nanstate).
for channel_no = 3, use nanstate = [np.nan,np.nan,np.nan].
rad = the pixel radius considered in interpolation.
kind can be "linear" or "cubic".
if kind="cubic", then set rad = 3.5.'''
state_interpolated = nanstate #.copy() if you change nanstate to a numpy array
try:
xlo = np.round(x-rad).astype(dtype=int)
ylo = np.round(y-rad).astype(dtype=int)
xhi = np.round(x+rad).astype(dtype=int)
yhi = np.round(y+rad).astype(dtype=int)
yloc = ycoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
xloc = xcoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
local_values = txt[ylo:yhi+1,xlo:xhi+1]
interp_foo = lambda x,y,zloc: interp2d(yloc,xloc,zloc,kind=kind)(y,x)
for c in range(channel_no):
zloc = local_values[...,c].flatten().copy()
state_interpolated[c] = float(interp_foo(x,y,zloc))
except IndexError:
pass
except RuntimeWarning:
pass
return state_interpolated
# ###############
# # Example Usage
# ###############
# #Caution! : check whether spiral tips are recorded as 'x': x coordinate or 'x': y coordinate
# #precompute the following the __padded__ coordinates
# xcoord_mesh, ycoord_mesh = np.meshgrid(np.arange(0,200),np.arange(0,200))
# x = 169.75099760896785
# y = 68.05364536542943
# nanstate = [np | pad_matrix | identifier_name |
get_tips_nonlocal.py | _tips[n]
y = y_tips[n]
for X, Y in zip(x, y):
X = unpad(X=X, pad=pad, width=width , rejection_distance=edge_tolerance)
if not (X == -9999):
Y = unpad(X=Y, pad=pad, width=height, rejection_distance=edge_tolerance)
if not (Y == -9999):
# find the index and distance to the nearest tip already on the mapped_lsts
min_dist_squared = min_dist_squared_init; min_index = -1
for j0, (x0,y0) in enumerate(zip(x_mapped_lst,y_mapped_lst)):
# compute the distance between x0,y0 and X,Y
dist_squared = (X-x0)**2+(Y-y0)**2
# if ^that distance is the smallest, update min_dist with it
if dist_squared < min_dist_squared:
min_dist_squared = dist_squared
min_index = j0
#if this new tip is sufficiently far from all other recorded tips,
if min_dist_squared >= atol:
# then append the entry to all four lists
x_mapped_lst.append(X)
y_mapped_lst.append(Y)
lst_S1 = []#List()
lst_S1.append(S1)
lst_S2 = []#List()
lst_S2.append(S2)
s1_mapped_lst.append(lst_S1)
s2_mapped_lst.append(lst_S2)
else:
#just append to the previous entry in the s1 and s2 lists if the contour isn't already there
s1_mapped_lst[min_index].append(S1)
s2_mapped_lst[min_index].append(S2)
return s1_mapped_lst, s2_mapped_lst, x_mapped_lst, y_mapped_lst
#########################################################################
# Interpolating Electrophysiological state values to spiral tip locations
#########################################################################
def get_state_nearest(x, y, txt):
'''nearest local texture values, ignore any index errors and/or periodic boundary conditions'''
xint = np.round(x).astype(dtype=int)
yint = np.round(y).astype(dtype=int)
try:
state_nearest = list(txt[xint,yint])
except IndexError:
state_nearest = nanstate
return state_nearest
#for get_state_interpolated
import sys
if not sys.warnoptions:
import warnings
warnings.simplefilter("ignore", category=RuntimeWarning, lineno=0, append=False)
#TODO: restrict ^this warning filter to onlyt get_state_interpolated
def get_state_interpolated(x, y, txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = 3, rad = 0.5, kind='linear'):
'''linear interpolation of local texture values to subpixel precision
using 2D linear interpolation with scipy.interpolate.interp2d.
channel_no must be len(nanstate).
for channel_no = 3, use nanstate = [np.nan,np.nan,np.nan].
rad = the pixel radius considered in interpolation.
kind can be "linear" or "cubic".
if kind="cubic", then set rad = 3.5.'''
state_interpolated = nanstate #.copy() if you change nanstate to a numpy array
try:
xlo = np.round(x-rad).astype(dtype=int)
ylo = np.round(y-rad).astype(dtype=int)
xhi = np.round(x+rad).astype(dtype=int)
yhi = np.round(y+rad).astype(dtype=int)
yloc = ycoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
xloc = xcoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
local_values = txt[ylo:yhi+1,xlo:xhi+1]
interp_foo = lambda x,y,zloc: interp2d(yloc,xloc,zloc,kind=kind)(y,x)
for c in range(channel_no):
zloc = local_values[...,c].flatten().copy()
state_interpolated[c] = float(interp_foo(x,y,zloc))
except IndexError:
pass
except RuntimeWarning:
pass
return state_interpolated
# ###############
# # Example Usage
# ###############
# #Caution! : check whether spiral tips are recorded as 'x': x coordinate or 'x': y coordinate
# #precompute the following the __padded__ coordinates
# xcoord_mesh, ycoord_mesh = np.meshgrid(np.arange(0,200),np.arange(0,200))
# x = 169.75099760896785
# y = 68.05364536542943
# nanstate = [np.nan,np.nan,np.nan]
# txt = np.stack([texture,texture,texture]).T
# print(
# get_state_nearest(x,y,txt)
# )
# print (
# get_state_interpolated(x, y, txt.astype('float32'), nanstate, xcoord_mesh, ycoord_mesh,
# channel_no = 3, rad = 3.5, kind='cubic')
# )
# print (
# get_state_interpolated(x, y, txt.astype('float32'), nanstate, xcoord_mesh, ycoord_mesh,
# channel_no = 3, rad = 0.5, kind='linear')
# )
##############################################
## Get Electrophysiological (EP) State Data #
##############################################
def get_states(x_values, y_values, txt, pad,
nanstate, xcoord_mesh, ycoord_mesh, channel_no = 3):
'''iterates through x_locations and y_locations contained in tips_mapped and returns the electrophysiological states'''
# tips_mapped gives tip locations using the correct image pixel coordinates, here.
# padded_txt = txt
padded_txt = pad_matrix(txt, pad)
n_lst, x_lst, y_lst = tips_mapped
y_locations = np.array(flatten(x_lst))+pad#np.array(tips_mapped[2])
x_locations = np.array(flatten(y_lst))+pad#np.array(tips_mapped[3])
states_nearest = []; states_interpolated_linear = []; states_interpolated_cubic = [];
for x,y in zip(x_locations,y_locations):
state_nearest = get_state_nearest(x,y,txt=padded_txt)
state_interpolated_linear = get_state_interpolated(x, y, padded_txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = channel_no, rad = 0.5, kind='linear')
state_interpolated_cubic = get_state_interpolated(x, y, padded_txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = channel_no, rad = 3.5, kind='cubic')
states_nearest.append(state_nearest)
states_interpolated_linear.append(state_interpolated_linear)
states_interpolated_cubic.append(state_interpolated_cubic)
return states_nearest, states_interpolated_linear, states_interpolated_cubic
def add_states(tips_mapped, states_EP):
tips_mapped = list(tips_mapped)
tips_mapped.extend(states_EP)
return tuple(tips_mapped)
def unwrap_EP(df,
EP_col_name = 'states_interpolated_linear',
drop_original_column=False):
'''If this function is slow, it may be a result of df[EP_col_name] containing strings.'''
EP_col_exists = EP_col_name in df.columns.values
if not EP_col_exists:
print(f"Caution! EP_col_name '{EP_col_exists}' does not exist. Returning input df.")
return df
else:
V_lst = []
f_lst = []
s_lst = []
for index, row in df.iterrows():
try:
V,f,s = row[EP_col_name]
except Exception as e:
V,f,s = eval(row[EP_col_name])
V_lst.append(V)
f_lst.append(f)
s_lst.append(s)
df['V'] = V_lst
df['f'] = f_lst
df['s'] = s_lst
df.drop(columns=[EP_col_name], inplace=True)
return df
@njit
def get_grad_direction(texture):
| '''get the gradient direction field, N
out_Nx, out_Ny = get_grad_direction(texture)
'''
height, width = texture.shape
out_Nx = np.zeros_like(texture, dtype=np.float64)
out_Ny = np.zeros_like(texture, dtype=np.float64)
DX = 1/0.025; DY = 1/0.025;
for y in range(height):
for x in range(width):
up = _pbc(texture,y+1,x,height,width)
down = _pbc(texture,y-1,x,height,width)
left = _pbc(texture,y,x-1,height,width)
right = _pbc(texture,y,x+1,height,width)
Nx = (right-left)/DX
Ny = (up-down)/DY
norm = np.sqrt( Nx**2 + Ny**2 )
if norm == 0:
out_Nx[y,x] = -10.
out_Ny[y,x] = -10.
else: | identifier_body |
|
get_tips_nonlocal.py | x or y for the padding:
[0... pad | pad ... width + pad | width + pad ... width + 2 * pad]
return -9999 if X is within rejection_distance of the edge,
return X if X is in [pad ... width + pad], which is if X is in the unpadded frame, which has width = width
else return X reflected onto the unpadded frame'''
P = rejection_distance
X -= pad
if X < -pad+P:
X = -9999 # throw out X later
elif X < 0:
X += width
if X > width+pad-P:
X = -9999 # throw out X later
elif X >= width:
X -= width
return X
# @njit
def textures_to_padded_textures(txt,dtexture_dt, pad):
'''large pad allows knots to be recorded right.
consider pad = int(512/2), edge_tolerance = int(512/4)'''
width, height = txt.shape[:2]
# padded_width = 512 + pad #pixels
padded_txt = np.pad(array = txt[...,0], pad_width = pad, mode = 'wrap')
dpadded_txt_dt = np.pad(array = dtexture_dt[...,0], pad_width = pad, mode = 'wrap')
return padded_txt, dpadded_txt_dt
def matrices_to_padded_matrices(txt,dtexture_dt, pad):
'''txt and dtexture_dt are rank two tensors. i.e. the channel_no is 1.
large pad allows knots to be recorded right.
'''
# width, height = txt.shape[:2]
# padded_width = 512 + pad #pixels
padded_txt = np.pad(array = txt, pad_width = pad, mode = 'wrap')
dpadded_txt_dt = np.pad(array = dtexture_dt, pad_width = pad, mode = 'wrap')
return padded_txt, dpadded_txt_dt
# #informal test for ^that
# padded_txt = np.pad(array = txt, pad_width = pad, mode = 'wrap')
# print(txt[0,0])
# print(padded_txt[...,2:5][pad,pad])
# @njit
def pad_matrix(mat, pad, channel_no=3):
''''''
return np.pad(array = mat, pad_width = pad, mode = 'wrap')[...,pad:pad+channel_no]
# width, height = mat.shape[:2]
# padded_width = 512 + pad #pixels
# padded_mat = np.pad(array = mat, pad_width = pad, mode = 'wrap')
# return padded_mat[...,2:5]
# @njit
def pad_texture(txt, pad):
'''large pad allows knots to be recorded right.
consider pad = int(512/2), edge_tolerance = int(512/4)'''
width, height = txt.shape[:2]
# padded_width = 512 + pad #pixels
padded_txta = np.pad(array = txt[...,0], pad_width = pad, mode = 'wrap')
padded_txtb = np.pad(array = txt[...,1], pad_width = pad, mode = 'wrap')
padded_txtc = np.pad(array = txt[...,2], pad_width = pad, mode = 'wrap')
# dpadded_txt_dt = np.pad(array = dtexture_dt[...,0], pad_width = pad, mode = 'wrap')
return np.array([padded_txta,padded_txtb,padded_txtc]).T
def map_pbc_tips_back(tips, pad, width, height, edge_tolerance, atol = 1e-11):
'''width and height are from the shape of the unpadded buffer.
TODO: get intersection to be njit compiled, then njit map_pbc_tips_back,
for which I'll need to return to using numba.typed.List() instead of [].'''
atol_squared = atol**2
min_dist_squared_init = width**2
s_tips, x_tips, y_tips = tips
s1_mapped_lst = []; s2_mapped_lst = [];
x_mapped_lst = []; y_mapped_lst = [];
# s1_mapped_lst = List(); s2_mapped_lst = List();
# x_mapped_lst = List(); y_mapped_lst = List();
for n, x in enumerate(x_tips):
y = y_tips[n]; s = s_tips[n]
S1, S2 = s_tips[n]
y = y_tips[n]
for X, Y in zip(x, y):
X = unpad(X=X, pad=pad, width=width , rejection_distance=edge_tolerance)
if not (X == -9999):
Y = unpad(X=Y, pad=pad, width=height, rejection_distance=edge_tolerance)
if not (Y == -9999):
# find the index and distance to the nearest tip already on the mapped_lsts
min_dist_squared = min_dist_squared_init; min_index = -1
for j0, (x0,y0) in enumerate(zip(x_mapped_lst,y_mapped_lst)):
# compute the distance between x0,y0 and X,Y
dist_squared = (X-x0)**2+(Y-y0)**2
# if ^that distance is the smallest, update min_dist with it
if dist_squared < min_dist_squared:
min_dist_squared = dist_squared
min_index = j0
#if this new tip is sufficiently far from all other recorded tips,
if min_dist_squared >= atol:
# then append the entry to all four lists
x_mapped_lst.append(X)
y_mapped_lst.append(Y) | s1_mapped_lst.append(lst_S1)
s2_mapped_lst.append(lst_S2)
else:
#just append to the previous entry in the s1 and s2 lists if the contour isn't already there
s1_mapped_lst[min_index].append(S1)
s2_mapped_lst[min_index].append(S2)
return s1_mapped_lst, s2_mapped_lst, x_mapped_lst, y_mapped_lst
#########################################################################
# Interpolating Electrophysiological state values to spiral tip locations
#########################################################################
def get_state_nearest(x, y, txt):
'''nearest local texture values, ignore any index errors and/or periodic boundary conditions'''
xint = np.round(x).astype(dtype=int)
yint = np.round(y).astype(dtype=int)
try:
state_nearest = list(txt[xint,yint])
except IndexError:
state_nearest = nanstate
return state_nearest
#for get_state_interpolated
import sys
if not sys.warnoptions:
import warnings
warnings.simplefilter("ignore", category=RuntimeWarning, lineno=0, append=False)
#TODO: restrict ^this warning filter to onlyt get_state_interpolated
def get_state_interpolated(x, y, txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = 3, rad = 0.5, kind='linear'):
'''linear interpolation of local texture values to subpixel precision
using 2D linear interpolation with scipy.interpolate.interp2d.
channel_no must be len(nanstate).
for channel_no = 3, use nanstate = [np.nan,np.nan,np.nan].
rad = the pixel radius considered in interpolation.
kind can be "linear" or "cubic".
if kind="cubic", then set rad = 3.5.'''
state_interpolated = nanstate #.copy() if you change nanstate to a numpy array
try:
xlo = np.round(x-rad).astype(dtype=int)
ylo = np.round(y-rad).astype(dtype=int)
xhi = np.round(x+rad).astype(dtype=int)
yhi = np.round(y+rad).astype(dtype=int)
yloc = ycoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
xloc = xcoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
local_values = txt[ylo:yhi+1,xlo:xhi+1]
interp_foo = lambda x,y,zloc: interp2d(yloc,xloc,zloc,kind=kind)(y,x)
for c in range(channel_no):
zloc = local_values[...,c].flatten().copy()
state_interpolated[c] = float(interp_foo(x,y,zloc))
except IndexError:
pass
except RuntimeWarning:
pass
return state_interpolated
# ###############
# # Example Usage
# ###############
# #Caution! : check whether spiral tips are recorded as 'x': x coordinate or 'x': y coordinate
# #precompute the following the __padded__ coordinates
# xcoord_mesh, ycoord_mesh = np.meshgrid(np.arange(0,200),np.arange(0,200))
# x = 169.75099760896785
# y = 68.05364536542943
# nanstate = [np | lst_S1 = []#List()
lst_S1.append(S1)
lst_S2 = []#List()
lst_S2.append(S2) | random_line_split |
get_tips_nonlocal.py | X = unpad(X=X, pad=pad, width=width , rejection_distance=edge_tolerance)
if not (X == -9999):
Y = unpad(X=Y, pad=pad, width=height, rejection_distance=edge_tolerance)
if not (Y == -9999):
# find the index and distance to the nearest tip already on the mapped_lsts
min_dist_squared = min_dist_squared_init; min_index = -1
for j0, (x0,y0) in enumerate(zip(x_mapped_lst,y_mapped_lst)):
# compute the distance between x0,y0 and X,Y
dist_squared = (X-x0)**2+(Y-y0)**2
# if ^that distance is the smallest, update min_dist with it
if dist_squared < min_dist_squared:
min_dist_squared = dist_squared
min_index = j0
#if this new tip is sufficiently far from all other recorded tips,
if min_dist_squared >= atol:
# then append the entry to all four lists
x_mapped_lst.append(X)
y_mapped_lst.append(Y)
lst_S1 = []#List()
lst_S1.append(S1)
lst_S2 = []#List()
lst_S2.append(S2)
s1_mapped_lst.append(lst_S1)
s2_mapped_lst.append(lst_S2)
else:
#just append to the previous entry in the s1 and s2 lists if the contour isn't already there
s1_mapped_lst[min_index].append(S1)
s2_mapped_lst[min_index].append(S2)
return s1_mapped_lst, s2_mapped_lst, x_mapped_lst, y_mapped_lst
#########################################################################
# Interpolating Electrophysiological state values to spiral tip locations
#########################################################################
def get_state_nearest(x, y, txt):
'''nearest local texture values, ignore any index errors and/or periodic boundary conditions'''
xint = np.round(x).astype(dtype=int)
yint = np.round(y).astype(dtype=int)
try:
state_nearest = list(txt[xint,yint])
except IndexError:
state_nearest = nanstate
return state_nearest
#for get_state_interpolated
import sys
if not sys.warnoptions:
import warnings
warnings.simplefilter("ignore", category=RuntimeWarning, lineno=0, append=False)
#TODO: restrict ^this warning filter to onlyt get_state_interpolated
def get_state_interpolated(x, y, txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = 3, rad = 0.5, kind='linear'):
'''linear interpolation of local texture values to subpixel precision
using 2D linear interpolation with scipy.interpolate.interp2d.
channel_no must be len(nanstate).
for channel_no = 3, use nanstate = [np.nan,np.nan,np.nan].
rad = the pixel radius considered in interpolation.
kind can be "linear" or "cubic".
if kind="cubic", then set rad = 3.5.'''
state_interpolated = nanstate #.copy() if you change nanstate to a numpy array
try:
xlo = np.round(x-rad).astype(dtype=int)
ylo = np.round(y-rad).astype(dtype=int)
xhi = np.round(x+rad).astype(dtype=int)
yhi = np.round(y+rad).astype(dtype=int)
yloc = ycoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
xloc = xcoord_mesh[ylo:yhi+1,xlo:xhi+1].flatten().copy()
local_values = txt[ylo:yhi+1,xlo:xhi+1]
interp_foo = lambda x,y,zloc: interp2d(yloc,xloc,zloc,kind=kind)(y,x)
for c in range(channel_no):
zloc = local_values[...,c].flatten().copy()
state_interpolated[c] = float(interp_foo(x,y,zloc))
except IndexError:
pass
except RuntimeWarning:
pass
return state_interpolated
# ###############
# # Example Usage
# ###############
# #Caution! : check whether spiral tips are recorded as 'x': x coordinate or 'x': y coordinate
# #precompute the following the __padded__ coordinates
# xcoord_mesh, ycoord_mesh = np.meshgrid(np.arange(0,200),np.arange(0,200))
# x = 169.75099760896785
# y = 68.05364536542943
# nanstate = [np.nan,np.nan,np.nan]
# txt = np.stack([texture,texture,texture]).T
# print(
# get_state_nearest(x,y,txt)
# )
# print (
# get_state_interpolated(x, y, txt.astype('float32'), nanstate, xcoord_mesh, ycoord_mesh,
# channel_no = 3, rad = 3.5, kind='cubic')
# )
# print (
# get_state_interpolated(x, y, txt.astype('float32'), nanstate, xcoord_mesh, ycoord_mesh,
# channel_no = 3, rad = 0.5, kind='linear')
# )
##############################################
## Get Electrophysiological (EP) State Data #
##############################################
def get_states(x_values, y_values, txt, pad,
nanstate, xcoord_mesh, ycoord_mesh, channel_no = 3):
'''iterates through x_locations and y_locations contained in tips_mapped and returns the electrophysiological states'''
# tips_mapped gives tip locations using the correct image pixel coordinates, here.
# padded_txt = txt
padded_txt = pad_matrix(txt, pad)
n_lst, x_lst, y_lst = tips_mapped
y_locations = np.array(flatten(x_lst))+pad#np.array(tips_mapped[2])
x_locations = np.array(flatten(y_lst))+pad#np.array(tips_mapped[3])
states_nearest = []; states_interpolated_linear = []; states_interpolated_cubic = [];
for x,y in zip(x_locations,y_locations):
state_nearest = get_state_nearest(x,y,txt=padded_txt)
state_interpolated_linear = get_state_interpolated(x, y, padded_txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = channel_no, rad = 0.5, kind='linear')
state_interpolated_cubic = get_state_interpolated(x, y, padded_txt, nanstate, xcoord_mesh, ycoord_mesh,
channel_no = channel_no, rad = 3.5, kind='cubic')
states_nearest.append(state_nearest)
states_interpolated_linear.append(state_interpolated_linear)
states_interpolated_cubic.append(state_interpolated_cubic)
return states_nearest, states_interpolated_linear, states_interpolated_cubic
def add_states(tips_mapped, states_EP):
tips_mapped = list(tips_mapped)
tips_mapped.extend(states_EP)
return tuple(tips_mapped)
def unwrap_EP(df,
EP_col_name = 'states_interpolated_linear',
drop_original_column=False):
'''If this function is slow, it may be a result of df[EP_col_name] containing strings.'''
EP_col_exists = EP_col_name in df.columns.values
if not EP_col_exists:
print(f"Caution! EP_col_name '{EP_col_exists}' does not exist. Returning input df.")
return df
else:
V_lst = []
f_lst = []
s_lst = []
for index, row in df.iterrows():
try:
V,f,s = row[EP_col_name]
except Exception as e:
V,f,s = eval(row[EP_col_name])
V_lst.append(V)
f_lst.append(f)
s_lst.append(s)
df['V'] = V_lst
df['f'] = f_lst
df['s'] = s_lst
df.drop(columns=[EP_col_name], inplace=True)
return df
@njit
def get_grad_direction(texture):
'''get the gradient direction field, N
out_Nx, out_Ny = get_grad_direction(texture)
'''
height, width = texture.shape
out_Nx = np.zeros_like(texture, dtype=np.float64)
out_Ny = np.zeros_like(texture, dtype=np.float64)
DX = 1/0.025; DY = 1/0.025;
for y in range(height):
for x in range(width):
up = _pbc(texture,y+1,x,height,width)
down = _pbc(texture,y-1,x,height,width)
left = _pbc(texture,y,x-1,height,width)
right = _pbc(texture,y,x+1,height,width)
Nx = (right-left)/DX
Ny = (up-down)/DY
norm = np.sqrt( Nx**2 + Ny**2 )
if norm == 0:
out_Nx[y,x] = -10.
out_Ny[y,x] = -10.
else:
| out_Nx[y,x] = Nx/norm
out_Ny[y,x] = Ny/norm | conditional_block |
|
details.js | if(iLeft<0) {
// iLeft = 0;
// } else if(iLeft>iWidht) {
// iLeft = iWidht;
// }
//
// if(iTop<0) {
// iTop = 0;
// } else if(iTop>iHeight) {
// iTop = iHeight;
// }
// $(".zoomShow-pud").css({"left":iLeft,"top":iTop})
// $(".bigShow").find("img").css({"left":-iLeft/4*15,"top":-iTop/4*15})
// //不想写了就用死值了
// console.log(iTop)
// })
})
$(function(){
//json加载图片与页面
var goodid
$.get("../data/details/imgs.json",function(data){
var con=data
for(var i in con){
$(".bx-bo-left-con").append('<ul><li><a href="details.html"><img src='+con[i].src+'/></a></li><li class="left-conli-txt"><a href="##" >'+con[i].userName+'</a></li><li class="left-conli-val">'+con[i].price+'</li></ul>')
}
})
// 热门商品组
// for(var i=1;i<=4;i++){
// $(".right-bom-dtu p").append("<img src='../img/details/right-bom"+i+".jpg'/>")
// }
//下方商品详情图片
$.get("../data/details/comlist.json",function(data){
if(parseInt($.cookie("comid"))%2==0){
var cl=data.comList2
}else{
var cl=data.comList1
}
$("#listName").html(cl.comname)
$("#bx-tit>P").html(cl.comname)
$(".pval-ms").find("em").html(cl.price)
$(".pval-ms").find("del").html(cl.yPrice)
$(".data-attr2").eq(0).find("span").html(cl.color)
$(".data-attr2").eq(1).find("span").html(cl.size)
for(var i=1;i<=5;i++){
$(".jqzoomDiv>ul").find("li").eq(i-1).find("img").attr("src",cl.imgSrc+"detalis-zoomdiv"+i+".JPG")
}
for(var i=1;i<=4;i++){
$(".right-bom-dtu p").append("<img src='"+cl.imgSrc+"right-bom"+i+".jpg'/>")
}
//放大镜
$(".zoomShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-zhong1.JPG")
$(".bigShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-big1.JPG")
$(".jqzoomDiv ul li").each(function(){
$(this).mouseover(function(){
$(".zoomShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-zhong"+($(this).index()+1)+".JPG")
$(".bigShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-big"+($(this).index()+1)+".JPG")
})
})
$(".bx-data-lt-2").mouseover(function(){
$(".zoomShow-pud").css({"display":"block"})
$(".bigShow").css({"display":"block"})
})
$(".bx-data-lt-2").mouseout(function(){
$(".zoomShow-pud").css({"display":"none"})
$(".bigShow").css({"display":"none"})
})
$(".zoomShow").mousemove(function(e){
// var iLeft=e.pageX-$(window).scrollLeft()-30-$(".bx-data-lt-1").offset().left-($(".zoomShow-pud").width()/2)
// var iTop=e.clientY-$(window).scrollTop()+$(".bx-data-lt-2").offset().top-($(".zoomShow-pud").height()/2)
var iLeft=e.clientX-$(window).scrollLeft()-$(".bx-data-lt-2").offset().left-($(".zoomShow-pud").width()/2)
var iTop=e.clientY+$(window).scrollTop()-$(".bx-data-lt-2").offset().top-($(".zoomShow-pud").height()/2)
var iWidht=$(".bx-data-lt-2").width()-$(".zoomShow-pud").width()
var iHeight=$(".bx-data-lt-2").height()-$(".zoomShow-pud").height()
if(iLeft<0) {
iLeft = 0;
} else if(iLeft>iWidht) {
iLeft = iWidht;
}
if(iTop<0) {
iTop = 0;
} else if(iTop>iHeight) {
iTop = iHeight;
}
$(".zoomShow-pud").css({"left":iLeft,"top":iTop})
$(".bigShow").find("img").css({"left":-iLeft/4*15,"top":-iTop/4*15})
//不想写了就用死值了
//console.log(iTop)
})
//点击按钮事件
downBtn(cl)
})
})
function downBtn(cl){
//从cookie中 取出数据的正确方式
//console.log(JSON.parse($.cookie("carList")).ID1.iNum)
goodid=cl.id
| imgSrc:cl.imgSrc+"detalis-zoomdiv-zhong1.JPG",
id:cl.id,
color:cl.color,
size:cl.size,
price:cl.price,
//iNum:num
}
// var value=0
// if($.cookie("carList")){
// for(var i in JSON.parse($.cookie("carList"))){
// value +=parseInt(JSON.parse($.cookie("carList"))[i].iNum)
// }
// //value=parseInt(JSON.parse($.cookie("carList")).ID1.iNum)+parseInt(JSON.parse($.cookie("carList")).ID2.iNum)
// }
$(".addCart").mousedown(function(){
//console.log($("#buyNum").val())
if(parseInt($("#buyNum").val())){
//判断添加数量的值是否为0
if(cl.id=="1"){
num1+=parseInt($("#buyNum").val())
com1.iNum=num1
}else{
num2+=parseInt($("#buyNum").val())
com1.iNum=num2
}
//计算购物车处的值
$.cookie("carList"+cl.id,JSON.stringify(com1),{expires:7,path:"/"})
//console.log($.cookie("carList1"))
//console.log($.cookie("carList2"))
var value=0
value=num1+num2
// if($.cookie("carList")){
// value+=parseInt($("#buyNum").val())
// }else{
// value=0
// }
$("#carNum").html("("+value+")")
}
})
}
//上方导航栏nav中购物车应显示的值
//活动倒计时
$(function(){
var timer=$(".time-end span")
var time=24*3600*1000 //活动倒计时
setInterval(function(){
time-=1000
var hour=parseInt(time/3600000)%24
var
min=parseInt(time/3600000*60)%60
var sec=parseInt(time/3600000*24*60)%60
timer.find("em").eq(0).html(hour)
timer.find("em").eq(1).html(min)
timer.find("em").eq(2).html(sec)
// console.log(time)
},500)
})
//添加商品按钮
$(function(){
var oAdd=$(".buyAdd")
var oRed=$(".buyReduce")
var oValue=$("#buyNum")
oAdd.css("cursor","pointer")
oRed.css("cursor","pointer")
var val=oValue.val()
oAdd.mousedown(function | $(".addCart").css("cursor","pointer")
var num1=0;num2=0;
if($.cookie("carList1")){
num1=parseInt(JSON.parse($.cookie("carList1")).iNum)
}
if($.cookie("carList2")){
num2=parseInt(JSON.parse($.cookie("carList2")).iNum)
}
//判断是否存在cookie
// if($.cookie("carList")){
// for(var m in JSON.parse($.cookie("carList"))){
// num+=parseInt(JSON.parse($.cookie("carList"))[m].iNum)
// //这里有bug每次累加是2个加起来的和
// }
// }else{
// num=0
// }
var com1= $.cookie("carList")?JSON.parse($.cookie("carList")):{}
com1={
userName:cl.comname, | identifier_body |
details.js | if(iLeft<0) {
// iLeft = 0;
// } else if(iLeft>iWidht) {
// iLeft = iWidht;
// }
//
// if(iTop<0) {
// iTop = 0;
// } else if(iTop>iHeight) {
// iTop = iHeight;
// }
// $(".zoomShow-pud").css({"left":iLeft,"top":iTop})
// $(".bigShow").find("img").css({"left":-iLeft/4*15,"top":-iTop/4*15})
// //不想写了就用死值了
// console.log(iTop)
// })
})
$(function(){
//json加载图片与页面
var goodid
$.get("../data/details/imgs.json",function(data){
var con=data
for(var i in con){
$(".bx-bo-left-con").append('<ul><li><a href="details.html"><img src='+con[i].src+'/></a></li><li class="left-conli-txt"><a href="##" >'+con[i].userName+'</a></li><li class="left-conli-val">'+con[i].price+'</li></ul>')
}
})
// 热门商品组
// for(var i=1;i<=4;i++){
// $(".right-bom-dtu p").append("<img src='../img/details/right-bom"+i+".jpg'/>")
// }
//下方商品详情图片
$.get("../data/details/comlist.json",function(data){
if(parseInt($.cookie("comid"))%2==0){
var cl=data.comList2
}else{
var cl=data.comList1
}
$("#listName").html(cl.comname)
$("#bx-tit>P").html(cl.comname)
$(".pval-ms").find("em").html(cl.price)
$(".pval-ms").find("del").html(cl.yPrice)
$(".data-attr2").eq(0).find("span").html(cl.color)
$(".data-attr2").eq(1).find("span").html(cl.size)
for(var i=1;i<=5;i++){
$(".jqzoomDiv>ul").find("li").eq(i-1).find("img").attr("src",cl.imgSrc+"detalis-zoomdiv"+i+".JPG")
}
for(var i=1;i<=4;i++){
$(".right-bom-dtu p").append("<img src='"+cl.imgSrc+"right-bom"+i+".jpg'/>")
}
//放大镜
$(".zoomShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-zhong1.JPG")
$(".bigShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-big1.JPG")
$(".jqzoomDiv ul li").each(function(){
$(this).mouseover(function(){
$(".zoomShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-zhong"+($(this).index()+1)+".JPG")
$(".bigShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-big"+($(this).index()+1)+".JPG")
})
})
$(".bx-data-lt-2").mouseover(function(){
$(".zoomShow-pud").css({"display":"block"})
$(".bigShow").css({"display":"block"})
})
$(".bx-data-lt-2").mouseout(function(){
$(".zoomShow-pud").css({"display":"none"})
$(".bigShow").css({"display":"none"})
})
$(".zoomShow").mousemove(function(e){
// var iLeft=e.pageX-$(window).scrollLeft()-30-$(".bx-data-lt-1").offset().left-($(".zoomShow-pud").width()/2)
// var iTop=e.clientY-$(window).scrollTop()+$(".bx-data-lt-2").offset().top-($(".zoomShow-pud").height()/2)
var iLeft=e.clientX-$(window).scrollLeft()-$(".bx-data-lt-2").offset().left-($(".zoomShow-pud").width()/2)
var iTop=e.clientY+$(window).scrollTop()-$(".bx-data-lt-2").offset().top-($(".zoomShow-pud").height()/2)
var iWidht=$(".bx-data-lt-2").width()-$(".zoomShow-pud").width()
var iHeight=$(".bx-data-lt-2").height()-$(".zoomShow-pud").height()
if(iLeft<0) {
iLeft = 0;
} else if(iLeft>iWidht) {
iLeft = iWidht;
}
if(iTop<0) {
iTop = 0;
} else if(iTop>iHeight) {
iTop = iHeight;
}
$(".zoomShow-pud").css({"left":iLeft,"top":iTop})
$(".bigShow").find("img").css({"left":-iLeft/4*15,"top":-iTop/4*15})
//不想写了就用死值了
//console.log(iTop)
})
//点击按钮事件
downBtn(cl)
})
})
function downBtn(cl){
//从cookie中 取出数据的正确方式
//console.log(JSON.parse($.cookie("carList")).ID1.iNum)
go | .id
$(".addCart").css("cursor","pointer")
var num1=0;num2=0;
if($.cookie("carList1")){
num1=parseInt(JSON.parse($.cookie("carList1")).iNum)
}
if($.cookie("carList2")){
num2=parseInt(JSON.parse($.cookie("carList2")).iNum)
}
//判断是否存在cookie
// if($.cookie("carList")){
// for(var m in JSON.parse($.cookie("carList"))){
// num+=parseInt(JSON.parse($.cookie("carList"))[m].iNum)
// //这里有bug每次累加是2个加起来的和
// }
// }else{
// num=0
// }
var com1= $.cookie("carList")?JSON.parse($.cookie("carList")):{}
com1={
userName:cl.comname,
imgSrc:cl.imgSrc+"detalis-zoomdiv-zhong1.JPG",
id:cl.id,
color:cl.color,
size:cl.size,
price:cl.price,
//iNum:num
}
// var value=0
// if($.cookie("carList")){
// for(var i in JSON.parse($.cookie("carList"))){
// value +=parseInt(JSON.parse($.cookie("carList"))[i].iNum)
// }
// //value=parseInt(JSON.parse($.cookie("carList")).ID1.iNum)+parseInt(JSON.parse($.cookie("carList")).ID2.iNum)
// }
$(".addCart").mousedown(function(){
//console.log($("#buyNum").val())
if(parseInt($("#buyNum").val())){
//判断添加数量的值是否为0
if(cl.id=="1"){
num1+=parseInt($("#buyNum").val())
com1.iNum=num1
}else{
num2+=parseInt($("#buyNum").val())
com1.iNum=num2
}
//计算购物车处的值
$.cookie("carList"+cl.id,JSON.stringify(com1),{expires:7,path:"/"})
//console.log($.cookie("carList1"))
//console.log($.cookie("carList2"))
var value=0
value=num1+num2
// if($.cookie("carList")){
// value+=parseInt($("#buyNum").val())
// }else{
// value=0
// }
$("#carNum").html("("+value+")")
}
})
}
//上方导航栏nav中购物车应显示的值
//活动倒计时
$(function(){
var timer=$(".time-end span")
var time=24*3600*1000 //活动倒计时
setInterval(function(){
time-=1000
var hour=parseInt(time/3600000)%24
var min=parseInt(time/3600000*60)%60
var sec=parseInt(time/3600000*24*60)%60
timer.find("em").eq(0).html(hour)
timer.find("em").eq(1).html(min)
timer.find("em").eq(2).html(sec)
// console.log(time)
},500)
})
//添加商品按钮
$(function(){
var oAdd=$(".buyAdd")
var oRed=$(".buyReduce")
var oValue=$("#buyNum")
oAdd.css("cursor","pointer")
oRed.css("cursor","pointer")
var val=oValue.val()
oAdd.mousedown(function(){
| odid=cl | identifier_name |
details.js | if(iLeft<0) {
// iLeft = 0;
// } else if(iLeft>iWidht) {
// iLeft = iWidht;
// }
//
// if(iTop<0) {
// iTop = 0;
// } else if(iTop>iHeight) {
// iTop = iHeight;
// }
// $(".zoomShow-pud").css({"left":iLeft,"top":iTop})
// $(".bigShow").find("img").css({"left":-iLeft/4*15,"top":-iTop/4*15})
// //不想写了就用死值了
// console.log(iTop)
// })
})
$(function(){
//json加载图片与页面
var goodid
$.get("../data/details/imgs.json",function(data){
var con=data
for(var i in con){
$(".bx-bo-left-con").append('<ul><li><a href="details.html"><img src='+con[i].src+'/></a></li><li class="left-conli-txt"><a href="##" >'+con[i].userName+'</a></li><li class="left-conli-val">'+con[i].price+'</li></ul>')
}
})
// 热门商品组
// for(var i=1;i<=4;i++){
// $(".right-bom-dtu p").append("<img src='../img/details/right-bom"+i+".jpg'/>")
// }
//下方商品详情图片
$.get("../data/details/comlist.json",function(data){
if(parseInt($.cookie("comid"))%2==0){
var cl=data.comList2
}else{
var cl=data.comList1
}
$("#listName").html(cl.comname)
$("#bx-tit>P").html(cl.comname)
$(".pval-ms").find("em").html(cl.price)
$(".pval-ms").find("del").html(cl.yPrice)
$(".data-attr2").eq(0).find("span").html(cl.color)
$(".data-attr2").eq(1).find("span").html(cl.size)
for(var i=1;i<=5;i++){
$(".jqzoomDiv>ul").find("li").eq(i-1).find("img").attr("src",cl.imgSrc+"detalis-zoomdiv"+i+".JPG")
}
for(var i=1;i<=4;i++){
$(".right-bom-dtu p").append("<img src='"+cl.imgSrc+"right-bom"+i+".jpg'/>")
}
//放大镜
$(".zoomShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-zhong1.JPG")
$(".bigShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-big1.JPG")
$(".jqzoomDiv ul li").each(function(){
$(this).mouseover(function(){
$(".zoomShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-zhong"+($(this).index()+1)+".JPG")
$(".bigShow").find("img").removeAttr("src").attr("src",cl.imgSrc+"detalis-zoomdiv-big"+($(this).index()+1)+".JPG")
})
})
$(".bx-data-lt-2").mouseover(function(){
$(".zoomShow-pud").css({"display":"block"})
$(".bigShow").css({"display":"block"})
})
$(".bx-data-lt-2").mouseout(function(){
$(".zoomShow-pud").css({"display":"none"})
$(".bigShow").css({"display":"none"})
})
$(".zoomShow").mousemove(function(e){
// var iLeft=e.pageX-$(window).scrollLeft()-30-$(".bx-data-lt-1").offset().left-($(".zoomShow-pud").width()/2)
// var iTop=e.clientY-$(window).scrollTop()+$(".bx-data-lt-2").offset().top-($(".zoomShow-pud").height()/2)
var iLeft=e.clientX-$(window).scrollLeft()-$(".bx-data-lt-2").offset().left-($(".zoomShow-pud").width()/2)
var iTop=e.clientY+$(window).scrollTop()-$(".bx-data-lt-2").offset().top-($(".zoomShow-pud").height()/2)
var iWidht=$(".bx-data-lt-2").width()-$(".zoomShow-pud").width()
var iHeight=$(".bx-data-lt-2").height()-$(".zoomShow-pud").height()
if(iLeft<0) {
iLeft = 0;
} else if(iLeft>iWidht) {
iLeft = iWidht;
}
if(iTop<0) {
iTop = 0;
} else if(iTop>iHeight) {
iTop = iHeight;
}
$(".zoomShow-pud").css({"left":iLeft,"top":iTop})
$(".bigShow").find("img").css({"left":-iLeft/4*15,"top":-iTop/4*15})
//不想写了就用死值了
//console.log(iTop)
})
//点击按钮事件
downBtn(cl)
})
})
function downBtn(cl){
//从cookie中 取出数据的正确方式
//console.log(JSON.parse($.cookie("carList")).ID1.iNum)
goodid=cl.id | num1=parseInt(JSON.parse($.cookie("carList1")).iNum)
}
if($.cookie("carList2")){
num2=parseInt(JSON.parse($.cookie("carList2")).iNum)
}
//判断是否存在cookie
// if($.cookie("carList")){
// for(var m in JSON.parse($.cookie("carList"))){
// num+=parseInt(JSON.parse($.cookie("carList"))[m].iNum)
// //这里有bug每次累加是2个加起来的和
// }
// }else{
// num=0
// }
var com1= $.cookie("carList")?JSON.parse($.cookie("carList")):{}
com1={
userName:cl.comname,
imgSrc:cl.imgSrc+"detalis-zoomdiv-zhong1.JPG",
id:cl.id,
color:cl.color,
size:cl.size,
price:cl.price,
//iNum:num
}
// var value=0
// if($.cookie("carList")){
// for(var i in JSON.parse($.cookie("carList"))){
// value +=parseInt(JSON.parse($.cookie("carList"))[i].iNum)
// }
// //value=parseInt(JSON.parse($.cookie("carList")).ID1.iNum)+parseInt(JSON.parse($.cookie("carList")).ID2.iNum)
// }
$(".addCart").mousedown(function(){
//console.log($("#buyNum").val())
if(parseInt($("#buyNum").val())){
//判断添加数量的值是否为0
if(cl.id=="1"){
num1+=parseInt($("#buyNum").val())
com1.iNum=num1
}else{
num2+=parseInt($("#buyNum").val())
com1.iNum=num2
}
//计算购物车处的值
$.cookie("carList"+cl.id,JSON.stringify(com1),{expires:7,path:"/"})
//console.log($.cookie("carList1"))
//console.log($.cookie("carList2"))
var value=0
value=num1+num2
// if($.cookie("carList")){
// value+=parseInt($("#buyNum").val())
// }else{
// value=0
// }
$("#carNum").html("("+value+")")
}
})
}
//上方导航栏nav中购物车应显示的值
//活动倒计时
$(function(){
var timer=$(".time-end span")
var time=24*3600*1000 //活动倒计时
setInterval(function(){
time-=1000
var hour=parseInt(time/3600000)%24
var min=parseInt(time/3600000*60)%60
var sec=parseInt(time/3600000*24*60)%60
timer.find("em").eq(0).html(hour)
timer.find("em").eq(1).html(min)
timer.find("em").eq(2).html(sec)
// console.log(time)
},500)
})
//添加商品按钮
$(function(){
var oAdd=$(".buyAdd")
var oRed=$(".buyReduce")
var oValue=$("#buyNum")
oAdd.css("cursor","pointer")
oRed.css("cursor","pointer")
var val=oValue.val()
oAdd.mousedown(function(){
| $(".addCart").css("cursor","pointer")
var num1=0;num2=0;
if($.cookie("carList1")){ | random_line_split |
reduc_spec.py | )
'''
if all([((type(arg) is tuple) or (arg is None)) for arg in args]):
ts, tf = args[0], args[1]
d=in_out.read_time_range(dt_0=ts,dt_f=tf, ext=kwargs.get('ext'))
elif any(('.h5' in arg for arg in args)):
d=in_out.read_to_arrays([arg for arg in args if '.h5' in arg])
else:
raise ValueError
# Modified Julian date
self.mjd=d['mjd'][:,0]
# Hours since beginning of read
self.t=(self.mjd-self.mjd[0])*24;
# Sample rate in MHz
if np.unique(d['samp_rate_mhz']).size > 1:
raise NameError('Sample rate changed during accumulation')
else:
self.samp_rate = d['samp_rate_mhz'][0]
# Accumulation length in s
if np.unique(d['acc_len_secs']).size > 1:
raise NameError('Accumulation length changed during accumulation')
else:
self.acc_len = d['acc_len_secs'][0]
# spectrum data
self.spec=d['spec'].astype(float)
# mask data
m=self.getmask()
self.applymask(m)
# Frequency axis
self.f = np.linspace(0,self.samp_rate/2,self.spec.shape[1])
# Add LO frequency
if d.has_key('LO_freq'):
self.lo=d['LO_freq']
else:
self.lo=9500
# Zenith angle in degrees.
self.za=d['angle_degs']-d['zenith_degs']
self.za=self.za[:,0]
# Airmass
self.am=self.za2am(self.za)
# az/el -> RA/Dec
az=120.0 # Hard coded to SE for now
self.ra,self.dec=azel2radec(az,90-self.za,self.mjd)
# Get stepping/cal indices
self._getscanind()
# Useful information
self.nf = self.f.size
##################
# Do the reduction
##################
#zarange=[20,50]
#self.reduc(zarange)
def splitbylo(self,lo):
"""Split out structure into a single LO, lo in GHz"""
ind=np.where(self.lo==lo)[0]
self.splitbyind(ind)
def splitbyscans(self,scans):
"""Split out structure, keeping scans in scans"""
ind=np.where(np.array([val in scans for dum,val in enumerate(self.scan)]))[0]
self.splitbyind(ind)
def splitbyind(self,ind):
"""Split out by time index"""
fields=['mjd','dec','ra','lo','scan','t','spec','za','am']
for k,val in enumerate(fields):
x=getattr(self,val)
setattr(self,val,x[ind])
self._getscanind()
def za2am(self,x):
"""Zenith angle in degrees to airmass"""
return 1/cosd(x)
def reduc(self,zarange=[20,50]):
"""Main reduction script. Elrange is two element list or tuple over
which to perform airmass regression (inclusive)"""
# First, take out a secular gain drift for each constant elevation
# stare. Fit P(t) to each channel in a contiguous elevation stare,
# normalize fit to mean=1, and normalize each chan to this.
#deg=10
#self.removedrift(deg)
# Convert P-> T RJ
#self.P2T()
# Now fit a line to P(am) in each scan and store the results.
self.fitam(zarange)
def | (self):
"""Scale by P->TRJ factor"""
# Convert to RJ temperature
#fac=planck.I2Ta(self.f*1e6,1).value
fac = planck(self.f*1e6, 1)
fac=fac/fac[0]
self.spec=self.spec*np.tile(fac,(self.spec.shape[0],1))
def _getscanind(self):
"""Identify start/stop indices of cal and scanning"""
zamin = self.za.min()
first = np.where(self.za==zamin)[0]
self.scan = np.zeros(self.spec.shape[0])
if zamin < 0:
cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]
ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1
ce = ss
se = np.roll((cs - 1) % self.za.size, -1) + 1
for k, val in enumerate(cs):
self.scan[val:se[k] + 1] = k
else:
moves = np.diff(self.za)
max_ind = np.where(moves==moves.max())[0]
turnover = self.za.size
diffs = np.diff(max_ind)
if np.unique(diffs).size > 1:
raise ValueError, 'Can\'t deal with non-uniform cal data yet.'
if max_ind.size > 1:
turnover = diffs[0]
cs = ce = np.array([])
ss = np.arange(self.za.size)[::turnover]
se = np.roll((ss - 1) % self.za.size, -1)
for k, val in enumerate(ss):
self.scan[val:se[k] + 1] = k
self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}
self.nscan = np.unique(self.scan).size
def getind(self,start,end,blk):
"""Return indices corresponding to start and end indices, strings as
defined in self.ind"""
if blk is None:
# Return all blocks
blk = np.arange(self.ind[start].size)
ind=np.array([])
for k,val in enumerate(blk):
ind=np.append(ind,np.arange(self.ind[start][val],self.ind[end][val]))
return ind.astype(int)
def getscanind(self,blk=None,zarange=[0,90]):
"""Return indices of periods of stepping. Scanblock goes from 0 to
Nscans-1, and will return the indices of the scan blocks requested.
Default is to return all scan blocks and all zenith angles."""
ind=self.getind('ss','se',arr(blk))
ind=ind[(self.za[ind]>=zarange[0]) & (self.za[ind]<=zarange[1])]
return ind
def getcalind(self,blk=None):
"""Return indices of periods of calibrator staring. If blk is defined,
return all indices of cal stares, including leading and trailing for
each block."""
if blk!=None:
blk=arr(blk)
cblk=np.array([]).astype(int) # Initialize cal stare indices
cs=self.ind['cs']
ce=self.ind['ce']
for k,val in enumerate(blk):
ss=self.ind['ss'][val] # Scan start
se=self.ind['se'][val] # Scan stop
# Find leading cal stare
ind=np.where(ce<=ss)[0]
if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[-1])
# Find trailing cal stare
ind=np.where(cs>=se)[0]
if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[0])
else:
cblk=None
return np.unique(self.getind('cs','ce',blk=cblk))
def calccalmean(self,blk):
"""Calculate mean of lead/trail cal stare for each scan block"""
calind=self.getcalind(blk)
x=self.spec[calind,:]
return np.nanmean(x,axis=0)
def getmask(self):
""" Get NtxNf mask"""
mask=np.ones(self.spec.shape)
# Right now just make out DC and clock freq
mask[:,1024]=0;
mask[:,0]=0;
return mask
def applymask(self,mask):
"""Set spec values to 0 where mask is zero"""
self.spec[mask==0]=np.nan
def removedrift(self,deg=10):
"""Fit and remove a polynomial from P(t) for each frequency channel for
a block of contiguous, constant elevation stares"""
# First remove a secular zeropoint drift over the entire scanset. Fit just the
# scans but remove from cal stares as well.
x=self.t
scanind=self.getscanind()
for k in range(self.nf):
y=self.spec[:,k]
if not np.any(np.isnan(y)):
p=np.polyfit(x[scanind],y[scanind],deg=deg)
# Don't remove mean
p[-1]=0
self.spec[:,k]=self.spec[:,k]-np.poly1d(p)(x)
return
for k in range(self.nscan):
# Each scan
ind=self.getscanind(k)
for j,val in | P2T | identifier_name |
reduc_spec.py | )
'''
if all([((type(arg) is tuple) or (arg is None)) for arg in args]):
ts, tf = args[0], args[1]
d=in_out.read_time_range(dt_0=ts,dt_f=tf, ext=kwargs.get('ext'))
elif any(('.h5' in arg for arg in args)):
d=in_out.read_to_arrays([arg for arg in args if '.h5' in arg])
else:
raise ValueError
# Modified Julian date
self.mjd=d['mjd'][:,0]
# Hours since beginning of read
self.t=(self.mjd-self.mjd[0])*24;
# Sample rate in MHz
if np.unique(d['samp_rate_mhz']).size > 1:
raise NameError('Sample rate changed during accumulation')
else:
self.samp_rate = d['samp_rate_mhz'][0]
# Accumulation length in s
if np.unique(d['acc_len_secs']).size > 1:
raise NameError('Accumulation length changed during accumulation')
else:
self.acc_len = d['acc_len_secs'][0]
# spectrum data
self.spec=d['spec'].astype(float)
# mask data
m=self.getmask()
self.applymask(m)
# Frequency axis
self.f = np.linspace(0,self.samp_rate/2,self.spec.shape[1])
# Add LO frequency
if d.has_key('LO_freq'):
self.lo=d['LO_freq']
else:
self.lo=9500
# Zenith angle in degrees.
self.za=d['angle_degs']-d['zenith_degs']
self.za=self.za[:,0]
# Airmass
self.am=self.za2am(self.za)
# az/el -> RA/Dec
az=120.0 # Hard coded to SE for now
self.ra,self.dec=azel2radec(az,90-self.za,self.mjd)
# Get stepping/cal indices
self._getscanind()
# Useful information
self.nf = self.f.size
##################
# Do the reduction
##################
#zarange=[20,50]
#self.reduc(zarange)
def splitbylo(self,lo):
"""Split out structure into a single LO, lo in GHz"""
ind=np.where(self.lo==lo)[0]
self.splitbyind(ind)
def splitbyscans(self,scans):
"""Split out structure, keeping scans in scans"""
ind=np.where(np.array([val in scans for dum,val in enumerate(self.scan)]))[0]
self.splitbyind(ind)
def splitbyind(self,ind):
"""Split out by time index"""
fields=['mjd','dec','ra','lo','scan','t','spec','za','am']
for k,val in enumerate(fields):
x=getattr(self,val)
setattr(self,val,x[ind])
self._getscanind()
def za2am(self,x):
"""Zenith angle in degrees to airmass"""
return 1/cosd(x)
def reduc(self,zarange=[20,50]):
"""Main reduction script. Elrange is two element list or tuple over
which to perform airmass regression (inclusive)"""
# First, take out a secular gain drift for each constant elevation
# stare. Fit P(t) to each channel in a contiguous elevation stare,
# normalize fit to mean=1, and normalize each chan to this.
#deg=10
#self.removedrift(deg)
# Convert P-> T RJ
#self.P2T()
# Now fit a line to P(am) in each scan and store the results.
self.fitam(zarange)
def P2T(self):
"""Scale by P->TRJ factor"""
# Convert to RJ temperature
#fac=planck.I2Ta(self.f*1e6,1).value
fac = planck(self.f*1e6, 1)
fac=fac/fac[0]
self.spec=self.spec*np.tile(fac,(self.spec.shape[0],1))
def _getscanind(self):
"""Identify start/stop indices of cal and scanning"""
zamin = self.za.min()
first = np.where(self.za==zamin)[0]
self.scan = np.zeros(self.spec.shape[0])
if zamin < 0:
cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]
ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1
ce = ss
se = np.roll((cs - 1) % self.za.size, -1) + 1
for k, val in enumerate(cs):
self.scan[val:se[k] + 1] = k
else:
moves = np.diff(self.za)
max_ind = np.where(moves==moves.max())[0]
turnover = self.za.size
diffs = np.diff(max_ind)
if np.unique(diffs).size > 1:
raise ValueError, 'Can\'t deal with non-uniform cal data yet.'
if max_ind.size > 1:
turnover = diffs[0]
cs = ce = np.array([])
ss = np.arange(self.za.size)[::turnover]
se = np.roll((ss - 1) % self.za.size, -1)
for k, val in enumerate(ss):
self.scan[val:se[k] + 1] = k
self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}
self.nscan = np.unique(self.scan).size
def getind(self,start,end,blk):
"""Return indices corresponding to start and end indices, strings as
defined in self.ind"""
if blk is None:
# Return all blocks
blk = np.arange(self.ind[start].size)
ind=np.array([])
for k,val in enumerate(blk):
ind=np.append(ind,np.arange(self.ind[start][val],self.ind[end][val]))
return ind.astype(int)
def getscanind(self,blk=None,zarange=[0,90]):
"""Return indices of periods of stepping. Scanblock goes from 0 to
Nscans-1, and will return the indices of the scan blocks requested.
Default is to return all scan blocks and all zenith angles."""
ind=self.getind('ss','se',arr(blk))
ind=ind[(self.za[ind]>=zarange[0]) & (self.za[ind]<=zarange[1])]
return ind
def getcalind(self,blk=None):
"""Return indices of periods of calibrator staring. If blk is defined,
return all indices of cal stares, including leading and trailing for
each block."""
if blk!=None:
blk=arr(blk)
cblk=np.array([]).astype(int) # Initialize cal stare indices
cs=self.ind['cs']
ce=self.ind['ce']
for k,val in enumerate(blk):
ss=self.ind['ss'][val] # Scan start
se=self.ind['se'][val] # Scan stop
# Find leading cal stare | if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[-1])
# Find trailing cal stare
ind=np.where(cs>=se)[0]
if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[0])
else:
cblk=None
return np.unique(self.getind('cs','ce',blk=cblk))
def calccalmean(self,blk):
"""Calculate mean of lead/trail cal stare for each scan block"""
calind=self.getcalind(blk)
x=self.spec[calind,:]
return np.nanmean(x,axis=0)
def getmask(self):
""" Get NtxNf mask"""
mask=np.ones(self.spec.shape)
# Right now just make out DC and clock freq
mask[:,1024]=0;
mask[:,0]=0;
return mask
def applymask(self,mask):
"""Set spec values to 0 where mask is zero"""
self.spec[mask==0]=np.nan
def removedrift(self,deg=10):
"""Fit and remove a polynomial from P(t) for each frequency channel for
a block of contiguous, constant elevation stares"""
# First remove a secular zeropoint drift over the entire scanset. Fit just the
# scans but remove from cal stares as well.
x=self.t
scanind=self.getscanind()
for k in range(self.nf):
y=self.spec[:,k]
if not np.any(np.isnan(y)):
p=np.polyfit(x[scanind],y[scanind],deg=deg)
# Don't remove mean
p[-1]=0
self.spec[:,k]=self.spec[:,k]-np.poly1d(p)(x)
return
for k in range(self.nscan):
# Each scan
ind=self.getscanind(k)
for j,val in enumerate | ind=np.where(ce<=ss)[0] | random_line_split |
reduc_spec.py | )
'''
if all([((type(arg) is tuple) or (arg is None)) for arg in args]):
ts, tf = args[0], args[1]
d=in_out.read_time_range(dt_0=ts,dt_f=tf, ext=kwargs.get('ext'))
elif any(('.h5' in arg for arg in args)):
d=in_out.read_to_arrays([arg for arg in args if '.h5' in arg])
else:
raise ValueError
# Modified Julian date
self.mjd=d['mjd'][:,0]
# Hours since beginning of read
self.t=(self.mjd-self.mjd[0])*24;
# Sample rate in MHz
if np.unique(d['samp_rate_mhz']).size > 1:
raise NameError('Sample rate changed during accumulation')
else:
self.samp_rate = d['samp_rate_mhz'][0]
# Accumulation length in s
if np.unique(d['acc_len_secs']).size > 1:
raise NameError('Accumulation length changed during accumulation')
else:
self.acc_len = d['acc_len_secs'][0]
# spectrum data
self.spec=d['spec'].astype(float)
# mask data
m=self.getmask()
self.applymask(m)
# Frequency axis
self.f = np.linspace(0,self.samp_rate/2,self.spec.shape[1])
# Add LO frequency
if d.has_key('LO_freq'):
self.lo=d['LO_freq']
else:
self.lo=9500
# Zenith angle in degrees.
self.za=d['angle_degs']-d['zenith_degs']
self.za=self.za[:,0]
# Airmass
self.am=self.za2am(self.za)
# az/el -> RA/Dec
az=120.0 # Hard coded to SE for now
self.ra,self.dec=azel2radec(az,90-self.za,self.mjd)
# Get stepping/cal indices
self._getscanind()
# Useful information
self.nf = self.f.size
##################
# Do the reduction
##################
#zarange=[20,50]
#self.reduc(zarange)
def splitbylo(self,lo):
"""Split out structure into a single LO, lo in GHz"""
ind=np.where(self.lo==lo)[0]
self.splitbyind(ind)
def splitbyscans(self,scans):
"""Split out structure, keeping scans in scans"""
ind=np.where(np.array([val in scans for dum,val in enumerate(self.scan)]))[0]
self.splitbyind(ind)
def splitbyind(self,ind):
"""Split out by time index"""
fields=['mjd','dec','ra','lo','scan','t','spec','za','am']
for k,val in enumerate(fields):
x=getattr(self,val)
setattr(self,val,x[ind])
self._getscanind()
def za2am(self,x):
"""Zenith angle in degrees to airmass"""
return 1/cosd(x)
def reduc(self,zarange=[20,50]):
"""Main reduction script. Elrange is two element list or tuple over
which to perform airmass regression (inclusive)"""
# First, take out a secular gain drift for each constant elevation
# stare. Fit P(t) to each channel in a contiguous elevation stare,
# normalize fit to mean=1, and normalize each chan to this.
#deg=10
#self.removedrift(deg)
# Convert P-> T RJ
#self.P2T()
# Now fit a line to P(am) in each scan and store the results.
self.fitam(zarange)
def P2T(self):
"""Scale by P->TRJ factor"""
# Convert to RJ temperature
#fac=planck.I2Ta(self.f*1e6,1).value
fac = planck(self.f*1e6, 1)
fac=fac/fac[0]
self.spec=self.spec*np.tile(fac,(self.spec.shape[0],1))
def _getscanind(self):
"""Identify start/stop indices of cal and scanning"""
zamin = self.za.min()
first = np.where(self.za==zamin)[0]
self.scan = np.zeros(self.spec.shape[0])
if zamin < 0:
cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]
ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1
ce = ss
se = np.roll((cs - 1) % self.za.size, -1) + 1
for k, val in enumerate(cs):
self.scan[val:se[k] + 1] = k
else:
moves = np.diff(self.za)
max_ind = np.where(moves==moves.max())[0]
turnover = self.za.size
diffs = np.diff(max_ind)
if np.unique(diffs).size > 1:
raise ValueError, 'Can\'t deal with non-uniform cal data yet.'
if max_ind.size > 1:
turnover = diffs[0]
cs = ce = np.array([])
ss = np.arange(self.za.size)[::turnover]
se = np.roll((ss - 1) % self.za.size, -1)
for k, val in enumerate(ss):
self.scan[val:se[k] + 1] = k
self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}
self.nscan = np.unique(self.scan).size
def getind(self,start,end,blk):
"""Return indices corresponding to start and end indices, strings as
defined in self.ind"""
if blk is None:
# Return all blocks
blk = np.arange(self.ind[start].size)
ind=np.array([])
for k,val in enumerate(blk):
ind=np.append(ind,np.arange(self.ind[start][val],self.ind[end][val]))
return ind.astype(int)
def getscanind(self,blk=None,zarange=[0,90]):
"""Return indices of periods of stepping. Scanblock goes from 0 to
Nscans-1, and will return the indices of the scan blocks requested.
Default is to return all scan blocks and all zenith angles."""
ind=self.getind('ss','se',arr(blk))
ind=ind[(self.za[ind]>=zarange[0]) & (self.za[ind]<=zarange[1])]
return ind
def getcalind(self,blk=None):
"""Return indices of periods of calibrator staring. If blk is defined,
return all indices of cal stares, including leading and trailing for
each block."""
if blk!=None:
blk=arr(blk)
cblk=np.array([]).astype(int) # Initialize cal stare indices
cs=self.ind['cs']
ce=self.ind['ce']
for k,val in enumerate(blk):
ss=self.ind['ss'][val] # Scan start
se=self.ind['se'][val] # Scan stop
# Find leading cal stare
ind=np.where(ce<=ss)[0]
if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[-1])
# Find trailing cal stare
ind=np.where(cs>=se)[0]
if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[0])
else:
cblk=None
return np.unique(self.getind('cs','ce',blk=cblk))
def calccalmean(self,blk):
"""Calculate mean of lead/trail cal stare for each scan block"""
calind=self.getcalind(blk)
x=self.spec[calind,:]
return np.nanmean(x,axis=0)
def getmask(self):
""" Get NtxNf mask"""
mask=np.ones(self.spec.shape)
# Right now just make out DC and clock freq
mask[:,1024]=0;
mask[:,0]=0;
return mask
def applymask(self,mask):
"""Set spec values to 0 where mask is zero"""
self.spec[mask==0]=np.nan
def removedrift(self,deg=10):
"""Fit and remove a polynomial from P(t) for each frequency channel for
a block of contiguous, constant elevation stares"""
# First remove a secular zeropoint drift over the entire scanset. Fit just the
# scans but remove from cal stares as well.
x=self.t
scanind=self.getscanind()
for k in range(self.nf):
y=self.spec[:,k]
if not np.any(np.isnan(y)):
|
return
for k in range(self.nscan):
# Each scan
ind=self.getscanind(k)
for j,val in | p=np.polyfit(x[scanind],y[scanind],deg=deg)
# Don't remove mean
p[-1]=0
self.spec[:,k]=self.spec[:,k]-np.poly1d(p)(x) | conditional_block |
reduc_spec.py | )
'''
if all([((type(arg) is tuple) or (arg is None)) for arg in args]):
ts, tf = args[0], args[1]
d=in_out.read_time_range(dt_0=ts,dt_f=tf, ext=kwargs.get('ext'))
elif any(('.h5' in arg for arg in args)):
d=in_out.read_to_arrays([arg for arg in args if '.h5' in arg])
else:
raise ValueError
# Modified Julian date
self.mjd=d['mjd'][:,0]
# Hours since beginning of read
self.t=(self.mjd-self.mjd[0])*24;
# Sample rate in MHz
if np.unique(d['samp_rate_mhz']).size > 1:
raise NameError('Sample rate changed during accumulation')
else:
self.samp_rate = d['samp_rate_mhz'][0]
# Accumulation length in s
if np.unique(d['acc_len_secs']).size > 1:
raise NameError('Accumulation length changed during accumulation')
else:
self.acc_len = d['acc_len_secs'][0]
# spectrum data
self.spec=d['spec'].astype(float)
# mask data
m=self.getmask()
self.applymask(m)
# Frequency axis
self.f = np.linspace(0,self.samp_rate/2,self.spec.shape[1])
# Add LO frequency
if d.has_key('LO_freq'):
self.lo=d['LO_freq']
else:
self.lo=9500
# Zenith angle in degrees.
self.za=d['angle_degs']-d['zenith_degs']
self.za=self.za[:,0]
# Airmass
self.am=self.za2am(self.za)
# az/el -> RA/Dec
az=120.0 # Hard coded to SE for now
self.ra,self.dec=azel2radec(az,90-self.za,self.mjd)
# Get stepping/cal indices
self._getscanind()
# Useful information
self.nf = self.f.size
##################
# Do the reduction
##################
#zarange=[20,50]
#self.reduc(zarange)
def splitbylo(self,lo):
"""Split out structure into a single LO, lo in GHz"""
ind=np.where(self.lo==lo)[0]
self.splitbyind(ind)
def splitbyscans(self,scans):
"""Split out structure, keeping scans in scans"""
ind=np.where(np.array([val in scans for dum,val in enumerate(self.scan)]))[0]
self.splitbyind(ind)
def splitbyind(self,ind):
"""Split out by time index"""
fields=['mjd','dec','ra','lo','scan','t','spec','za','am']
for k,val in enumerate(fields):
x=getattr(self,val)
setattr(self,val,x[ind])
self._getscanind()
def za2am(self,x):
|
def reduc(self,zarange=[20,50]):
"""Main reduction script. Elrange is two element list or tuple over
which to perform airmass regression (inclusive)"""
# First, take out a secular gain drift for each constant elevation
# stare. Fit P(t) to each channel in a contiguous elevation stare,
# normalize fit to mean=1, and normalize each chan to this.
#deg=10
#self.removedrift(deg)
# Convert P-> T RJ
#self.P2T()
# Now fit a line to P(am) in each scan and store the results.
self.fitam(zarange)
def P2T(self):
"""Scale by P->TRJ factor"""
# Convert to RJ temperature
#fac=planck.I2Ta(self.f*1e6,1).value
fac = planck(self.f*1e6, 1)
fac=fac/fac[0]
self.spec=self.spec*np.tile(fac,(self.spec.shape[0],1))
def _getscanind(self):
"""Identify start/stop indices of cal and scanning"""
zamin = self.za.min()
first = np.where(self.za==zamin)[0]
self.scan = np.zeros(self.spec.shape[0])
if zamin < 0:
cs = first[np.where((first - np.roll(first, 1)) != 1)[0]]
ss = first[np.where((np.roll(first,-1) - first) != 1)[0]] + 1
ce = ss
se = np.roll((cs - 1) % self.za.size, -1) + 1
for k, val in enumerate(cs):
self.scan[val:se[k] + 1] = k
else:
moves = np.diff(self.za)
max_ind = np.where(moves==moves.max())[0]
turnover = self.za.size
diffs = np.diff(max_ind)
if np.unique(diffs).size > 1:
raise ValueError, 'Can\'t deal with non-uniform cal data yet.'
if max_ind.size > 1:
turnover = diffs[0]
cs = ce = np.array([])
ss = np.arange(self.za.size)[::turnover]
se = np.roll((ss - 1) % self.za.size, -1)
for k, val in enumerate(ss):
self.scan[val:se[k] + 1] = k
self.ind = {'cs': cs, 'ce': ce, 'ss': ss, 'se': se}
self.nscan = np.unique(self.scan).size
def getind(self,start,end,blk):
"""Return indices corresponding to start and end indices, strings as
defined in self.ind"""
if blk is None:
# Return all blocks
blk = np.arange(self.ind[start].size)
ind=np.array([])
for k,val in enumerate(blk):
ind=np.append(ind,np.arange(self.ind[start][val],self.ind[end][val]))
return ind.astype(int)
def getscanind(self,blk=None,zarange=[0,90]):
"""Return indices of periods of stepping. Scanblock goes from 0 to
Nscans-1, and will return the indices of the scan blocks requested.
Default is to return all scan blocks and all zenith angles."""
ind=self.getind('ss','se',arr(blk))
ind=ind[(self.za[ind]>=zarange[0]) & (self.za[ind]<=zarange[1])]
return ind
def getcalind(self,blk=None):
"""Return indices of periods of calibrator staring. If blk is defined,
return all indices of cal stares, including leading and trailing for
each block."""
if blk!=None:
blk=arr(blk)
cblk=np.array([]).astype(int) # Initialize cal stare indices
cs=self.ind['cs']
ce=self.ind['ce']
for k,val in enumerate(blk):
ss=self.ind['ss'][val] # Scan start
se=self.ind['se'][val] # Scan stop
# Find leading cal stare
ind=np.where(ce<=ss)[0]
if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[-1])
# Find trailing cal stare
ind=np.where(cs>=se)[0]
if ind.size>0:
# If it exists, append it
cblk=np.append(cblk,ind[0])
else:
cblk=None
return np.unique(self.getind('cs','ce',blk=cblk))
def calccalmean(self,blk):
"""Calculate mean of lead/trail cal stare for each scan block"""
calind=self.getcalind(blk)
x=self.spec[calind,:]
return np.nanmean(x,axis=0)
def getmask(self):
""" Get NtxNf mask"""
mask=np.ones(self.spec.shape)
# Right now just make out DC and clock freq
mask[:,1024]=0;
mask[:,0]=0;
return mask
def applymask(self,mask):
"""Set spec values to 0 where mask is zero"""
self.spec[mask==0]=np.nan
def removedrift(self,deg=10):
"""Fit and remove a polynomial from P(t) for each frequency channel for
a block of contiguous, constant elevation stares"""
# First remove a secular zeropoint drift over the entire scanset. Fit just the
# scans but remove from cal stares as well.
x=self.t
scanind=self.getscanind()
for k in range(self.nf):
y=self.spec[:,k]
if not np.any(np.isnan(y)):
p=np.polyfit(x[scanind],y[scanind],deg=deg)
# Don't remove mean
p[-1]=0
self.spec[:,k]=self.spec[:,k]-np.poly1d(p)(x)
return
for k in range(self.nscan):
# Each scan
ind=self.getscanind(k)
for j,val in | """Zenith angle in degrees to airmass"""
return 1/cosd(x) | identifier_body |
_ToolBar.ts | : (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onafteropen" helpKeyword="WinJS.UI.ToolBar.onafteropen">
/// Occurs immediately after the control is opened.
/// </field>
onafteropen: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onbeforeclose" helpKeyword="WinJS.UI.ToolBar.onbeforeclose">
/// Occurs immediately before the control is closed. Is cancelable.
/// </field>
onbeforeclose: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onafterclose" helpKeyword="WinJS.UI.ToolBar.onafterclose">
/// Occurs immediately after the control is closed.
/// </field>
onafterclose: (ev: CustomEvent) => void;
open(): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.open">
/// <summary locid="WinJS.UI.ToolBar.open">
/// Opens the ToolBar
/// </summary>
/// </signature>
this._commandingSurface.open();
}
close(): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.close">
/// <summary locid="WinJS.UI.ToolBar.close">
/// Closes the ToolBar
/// </summary>
/// </signature>
this._commandingSurface.close();
}
dispose() {
/// <signature helpKeyword="WinJS.UI.ToolBar.dispose">
/// <summary locid="WinJS.UI.ToolBar.dispose">
/// Disposes this ToolBar.
/// </summary>
/// </signature>
if (this._disposed) {
return;
}
this._disposed = true;
_LightDismissService.hidden(this._dismissable);
// Disposing the _commandingSurface will trigger dispose on its OpenCloseMachine and synchronously complete any animations that might have been running.
this._commandingSurface.dispose();
// If page navigation is happening, we don't want the ToolBar left behind in the body.
// Synchronoulsy close the ToolBar to force it out of the body and back into its parent element.
this._synchronousClose();
_ElementUtilities._inputPaneListener.removeEventListener(this._dom.root, "showing", this._handleShowingKeyboardBound);
_Dispose.disposeSubTree(this.element);
}
forceLayout() {
/// <signature helpKeyword="WinJS.UI.ToolBar.forceLayout">
/// <summary locid="WinJS.UI.ToolBar.forceLayout">
/// Forces the ToolBar to update its layout. Use this function when the window did not change size, but the container of the ToolBar changed size.
/// </summary>
/// </signature>
this._commandingSurface.forceLayout();
}
getCommandById(id: string): _Command.ICommand {
/// <signature helpKeyword="WinJS.UI.ToolBar.getCommandById">
/// <summary locid="WinJS.UI.ToolBar.getCommandById">
/// Retrieves the command with the specified ID from this ToolBar.
/// If more than one command is found, this method returns the first command found.
/// </summary>
/// <param name="id" type="String" locid="WinJS.UI.ToolBar.getCommandById_p:id">Id of the command to return.</param>
/// <returns type="object" locid="WinJS.UI.ToolBar.getCommandById_returnValue">
/// The command found, or null if no command is found.
/// </returns>
/// </signature>
return this._commandingSurface.getCommandById(id);
}
showOnlyCommands(commands: Array<string|_Command.ICommand>): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.showOnlyCommands">
/// <summary locid="WinJS.UI.ToolBar.showOnlyCommands">
/// Show the specified commands, hiding all of the others in the ToolBar.
/// </summary>
/// <param name="commands" type="Array" locid="WinJS.UI.ToolBar.showOnlyCommands_p:commands">
/// An array of the commands to show. The array elements may be Command objects, or the string identifiers (IDs) of commands.
/// </param>
/// </signature>
return this._commandingSurface.showOnlyCommands(commands);
}
private _writeProfilerMark(text: string) {
_WriteProfilerMark("WinJS.UI.ToolBar:" + this._id + ":" + text);
}
private _initializeDom(root: HTMLElement): void {
this._writeProfilerMark("_intializeDom,info");
// Attaching JS control to DOM element
root["winControl"] = this;
this._id = root.id || _ElementUtilities._uniqueID(root);
_ElementUtilities.addClass(root, _Constants.ClassNames.controlCssClass);
_ElementUtilities.addClass(root, _Constants.ClassNames.disposableCssClass);
// Make sure we have an ARIA role
var role = root.getAttribute("role");
if (!role) {
root.setAttribute("role", "menubar");
}
var label = root.getAttribute("aria-label");
if (!label) {
root.setAttribute("aria-label", strings.ariaLabel);
}
// Create element for commandingSurface and reparent any declarative Commands.
// The CommandingSurface constructor will parse child elements as AppBarCommands.
var commandingSurfaceEl = document.createElement("DIV");
_ElementUtilities._reparentChildren(root, commandingSurfaceEl);
root.appendChild(commandingSurfaceEl);
// While the ToolBar is open, it will place itself in the <body> so it can become a light dismissible
// overlay. It leaves the placeHolder element behind as stand in at the ToolBar's original DOM location
// to avoid reflowing surrounding app content and create the illusion that the ToolBar hasn't moved along
// the x or y planes.
var placeHolder = _Global.document.createElement("DIV");
_ElementUtilities.addClass(placeHolder, _Constants.ClassNames.placeHolderCssClass);
// If the ToolBar's original HTML parent node is disposed while the ToolBar is open and repositioned as
// a temporary child of the <body>, make sure that calling dispose on the placeHolder element will trigger
// dispose on the ToolBar as well.
_Dispose.markDisposable(placeHolder, this.dispose.bind(this));
this._dom = {
root: root,
commandingSurfaceEl: commandingSurfaceEl,
placeHolder: placeHolder,
};
}
private _handleShowingKeyboard(event: { detail: { originalEvent: _WinRT.Windows.UI.ViewManagement.InputPaneVisibilityEventArgs } }) {
// Because the ToolBar takes up layout space and is not an overlay, it doesn't have the same expectation
// to move itself to get out of the way of a showing IHM. Instsead we just close the ToolBar to avoid
// scenarios where the ToolBar is occluded, but the click-eating-div is still present since it may seem
// strange to end users that an occluded ToolBar (out of sight, out of mind) is still eating their first
// click.
// Mitigation:
// Because (1) custom content in a ToolBar can only be included as a 'content' type command, because (2)
// the ToolBar only supports closedDisplayModes 'compact' and 'full', and because (3) 'content' type
// commands in the overflowarea use a separate contentflyout to display their contents:
// Interactable custom content contained within the ToolBar actionarea or overflowarea, will remain
// visible and interactable even when showing the IHM closes the ToolBar.
this.close();
}
private _synchronousOpen(): void {
this._isOpenedMode = true;
this._updateDomImpl();
}
private _synchronousClose(): void {
this._isOpenedMode = false;
this._updateDomImpl();
}
// State private to the _updateDomImpl family of method. No other methods should make use of it.
//
// Nothing has been rendered yet so these are all initialized to undefined. Because
// they are undefined, the first time _updateDomImpl is called, they will all be
// rendered.
private _updateDomImpl_renderedState = {
isOpenedMode: <boolean>undefined,
closedDisplayMode: <string>undefined,
prevInlineWidth: <string>undefined,
};
private _updateDomImpl(): void {
var rendered = this._updateDomImpl_renderedState;
if (rendered.isOpenedMode !== this._isOpenedMode) {
if (this._isOpenedMode) {
this._updateDomImpl_renderOpened();
} else {
this._updateDomImpl_renderClosed();
}
rendered.isOpenedMode = this._isOpenedMode;
}
if (rendered.closedDisplayMode !== this.closedDisplayMode) {
removeClass(this._dom.root, closedDisplayModeClassMap[rendered.closedDisplayMode]);
addClass(this._dom.root, closedDisplayModeClassMap[this.closedDisplayMode]);
rendered.closedDisplayMode = this.closedDisplayMode;
}
this._commandingSurface.updateDom();
}
private _getClosedHeight(): number {
if (this._cachedClosedHeight === null) {
var wasOpen = this._isOpenedMode;
if (this._isOpenedMode) | {
this._synchronousClose();
} | conditional_block |
|
_ToolBar.ts | same stacking context pitfalls
// as any other light dismissible. https://github.com/winjs/winjs/wiki/Dismissables-and-Stacking-Contexts
// - Reposition the ToolBar element to be exactly overlaid on top of the placeholder element.
// - Render the ToolBar as opened, via the _CommandingSurface API, increasing the overall height of the ToolBar.
// - Closing the ToolBar is basically the same steps but in reverse.
// - One limitation to this implementation is that developers may not position the ToolBar element themselves directly via the CSS "position" or "float" properties.
// - This is because The ToolBar expects its element to be in the flow of the document when closed, and the placeholder element would not receive these same styles
// when inserted to replace the ToolBar element.
// - An easy workaround for developers is to wrap the ToolBar into another DIV element that they may style and position however they'd like.
//
// - Responding to the IHM:
// - If the ToolBar is opened when the IHM is shown, it will close itself.This is to avoid scenarios where the IHM totally occludes the opened ToolBar. If the ToolBar
// did not close itself, then the next mouse or touch input within the App wouldn't appear to do anything since it would just go to closing the light dismissible
// ToolBar anyway.
var strings = {
get ariaLabel() { return _Resources._getWinJSString("ui/toolbarAriaLabel").value; },
get overflowButtonAriaLabel() { return _Resources._getWinJSString("ui/toolbarOverflowButtonAriaLabel").value; },
get mustContainCommands() { return "The toolbar can only contain WinJS.UI.Command or WinJS.UI.AppBarCommand controls"; },
get duplicateConstruction() { return "Invalid argument: Controls may only be instantiated one time for each DOM element"; }
};
var ClosedDisplayMode = {
/// <field locid="WinJS.UI.ToolBar.ClosedDisplayMode.compact" helpKeyword="WinJS.UI.ToolBar.ClosedDisplayMode.compact">
/// When the ToolBar is closed, the height of the ToolBar is reduced such that button commands are still visible, but their labels are hidden.
/// </field>
compact: "compact",
/// <field locid="WinJS.UI.ToolBar.ClosedDisplayMode.full" helpKeyword="WinJS.UI.ToolBar.ClosedDisplayMode.full">
/// When the ToolBar is closed, the height of the ToolBar is always sized to content.
/// </field>
full: "full",
};
var closedDisplayModeClassMap = {};
closedDisplayModeClassMap[ClosedDisplayMode.compact] = _Constants.ClassNames.compactClass;
closedDisplayModeClassMap[ClosedDisplayMode.full] = _Constants.ClassNames.fullClass;
// Versions of add/removeClass that are no ops when called with falsy class names.
function addClass(element: HTMLElement, className: string): void {
className && _ElementUtilities.addClass(element, className);
}
function removeClass(element: HTMLElement, className: string): void {
className && _ElementUtilities.removeClass(element, className);
}
/// <field>
/// <summary locid="WinJS.UI.ToolBar">
/// Displays ICommands within the flow of the app. Use the ToolBar around other statically positioned app content.
/// </summary>
/// </field>
/// <icon src="ui_winjs.ui.toolbar.12x12.png" width="12" height="12" />
/// <icon src="ui_winjs.ui.toolbar.16x16.png" width="16" height="16" />
/// <htmlSnippet supportsContent="true"><![CDATA[<div data-win-control="WinJS.UI.ToolBar">
/// <button data-win-control="WinJS.UI.Command" data-win-options="{id:'',label:'example',icon:'back',type:'button',onclick:null,section:'primary'}"></button>
/// </div>]]></htmlSnippet>
/// <part name="toolbar" class="win-toolbar" locid="WinJS.UI.ToolBar_part:toolbar">The entire ToolBar control.</part>
/// <part name="toolbar-overflowbutton" class="win-toolbar-overflowbutton" locid="WinJS.UI.ToolBar_part:ToolBar-overflowbutton">The toolbar overflow button.</part>
/// <part name="toolbar-overflowarea" class="win-toolbar-overflowarea" locid="WinJS.UI.ToolBar_part:ToolBar-overflowarea">The container for toolbar commands that overflow.</part>
/// <resource type="javascript" src="//$(TARGET_DESTINATION)/js/WinJS.js" shared="true" />
/// <resource type="css" src="//$(TARGET_DESTINATION)/css/ui-dark.css" shared="true" />
export class ToolBar {
private _id: string;
private _disposed: boolean;
private _commandingSurface: _ICommandingSurface._CommandingSurface;
private _isOpenedMode: boolean;
private _handleShowingKeyboardBound: (ev: any) => void;
private _dismissable: _LightDismissService.LightDismissableElement;
private _cachedClosedHeight: number;
private _dom: {
root: HTMLElement;
commandingSurfaceEl: HTMLElement;
placeHolder: HTMLElement;
}
/// <field locid="WinJS.UI.ToolBar.ClosedDisplayMode" helpKeyword="WinJS.UI.ToolBar.ClosedDisplayMode">
/// Display options for the actionarea when the ToolBar is closed.
/// </field>
static ClosedDisplayMode = ClosedDisplayMode;
static supportedForProcessing: boolean = true;
/// <field type="HTMLElement" domElement="true" hidden="true" locid="WinJS.UI.ToolBar.element" helpKeyword="WinJS.UI.ToolBar.element">
/// Gets the DOM element that hosts the ToolBar.
/// </field>
get element() |
/// <field type="WinJS.Binding.List" locid="WinJS.UI.ToolBar.data" helpKeyword="WinJS.UI.ToolBar.data">
/// Gets or sets the Binding List of WinJS.UI.Command for the ToolBar.
/// </field>
get data() {
return this._commandingSurface.data;
}
set data(value: BindingList.List<_Command.ICommand>) {
this._commandingSurface.data = value;
}
/// <field type="String" locid="WinJS.UI.ToolBar.closedDisplayMode" helpKeyword="WinJS.UI.ToolBar.closedDisplayMode">
/// Gets or sets the closedDisplayMode for the ToolBar. Values are "compact" and "full".
/// </field>
get closedDisplayMode() {
return this._commandingSurface.closedDisplayMode;
}
set closedDisplayMode(value: string) {
if (ClosedDisplayMode[value]) {
this._commandingSurface.closedDisplayMode = value;
this._cachedClosedHeight = null;
}
}
/// <field type="Boolean" hidden="true" locid="WinJS.UI.ToolBar.opened" helpKeyword="WinJS.UI.ToolBar.opened">
/// Gets or sets whether the ToolBar is currently opened.
/// </field>
get opened(): boolean {
return this._commandingSurface.opened;
}
set opened(value: boolean) {
this._commandingSurface.opened = value;
}
constructor(element?: HTMLElement, options: any = {}) {
/// <signature helpKeyword="WinJS.UI.ToolBar.ToolBar">
/// <summary locid="WinJS.UI.ToolBar.constructor">
/// Creates a new ToolBar control.
/// </summary>
/// <param name="element" type="HTMLElement" domElement="true" locid="WinJS.UI.ToolBar.constructor_p:element">
/// The DOM element that will host the control.
/// </param>
/// <param name="options" type="Object" locid="WinJS.UI.ToolBar.constructor_p:options">
/// The set of properties and values to apply to the new ToolBar control.
/// </param>
/// <returns type="WinJS.UI.ToolBar" locid="WinJS.UI.ToolBar.constructor_returnValue">
/// The new ToolBar control.
/// </returns>
/// </signature>
this._writeProfilerMark("constructor,StartTM");
// Check to make sure we weren't duplicated
if (element && element["winControl"]) {
throw new _ErrorFromName("WinJS.UI.ToolBar.DuplicateConstruction", strings.duplicateConstruction);
}
this._initializeDom(element || _Global.document.createElement("div"));
var stateMachine = new _OpenCloseMachine.OpenCloseMachine({
eventElement: this.element,
onOpen: () => {
var openAnimation = this._commandingSurface.createOpenAnimation(this._getClosedHeight());
this._synchronousOpen();
return openAnimation.execute();
},
onClose: () => {
var closeAnimation = this._commandingSurface.createCloseAnimation(this._getClosedHeight());
return closeAnimation.execute().then(() => {
this._synchronousClose();
});
},
onUpdateDom: () => {
this._updateDomImpl();
},
onUpdateDomWithIsOpened: (isOpened: boolean) => {
this._isOpenedMode = isOpened;
this._updateDomImpl();
}
});
// Events
this._handleShowingKeyboardBound = this._handleShowingKeyboard.bind(this);
_ElementUtilities._inputPaneListener.addEventListener(this._dom.root, "showing", this._handleShowingKeyboardBound);
// Initialize private state.
this._disposed = false | {
return this._dom.root;
} | identifier_body |
_ToolBar.ts | Surface.opened;
}
set opened(value: boolean) {
this._commandingSurface.opened = value;
}
constructor(element?: HTMLElement, options: any = {}) {
/// <signature helpKeyword="WinJS.UI.ToolBar.ToolBar">
/// <summary locid="WinJS.UI.ToolBar.constructor">
/// Creates a new ToolBar control.
/// </summary>
/// <param name="element" type="HTMLElement" domElement="true" locid="WinJS.UI.ToolBar.constructor_p:element">
/// The DOM element that will host the control.
/// </param>
/// <param name="options" type="Object" locid="WinJS.UI.ToolBar.constructor_p:options">
/// The set of properties and values to apply to the new ToolBar control.
/// </param>
/// <returns type="WinJS.UI.ToolBar" locid="WinJS.UI.ToolBar.constructor_returnValue">
/// The new ToolBar control.
/// </returns>
/// </signature>
this._writeProfilerMark("constructor,StartTM");
// Check to make sure we weren't duplicated
if (element && element["winControl"]) {
throw new _ErrorFromName("WinJS.UI.ToolBar.DuplicateConstruction", strings.duplicateConstruction);
}
this._initializeDom(element || _Global.document.createElement("div"));
var stateMachine = new _OpenCloseMachine.OpenCloseMachine({
eventElement: this.element,
onOpen: () => {
var openAnimation = this._commandingSurface.createOpenAnimation(this._getClosedHeight());
this._synchronousOpen();
return openAnimation.execute();
},
onClose: () => {
var closeAnimation = this._commandingSurface.createCloseAnimation(this._getClosedHeight());
return closeAnimation.execute().then(() => {
this._synchronousClose();
});
},
onUpdateDom: () => {
this._updateDomImpl();
},
onUpdateDomWithIsOpened: (isOpened: boolean) => {
this._isOpenedMode = isOpened;
this._updateDomImpl();
}
});
// Events
this._handleShowingKeyboardBound = this._handleShowingKeyboard.bind(this);
_ElementUtilities._inputPaneListener.addEventListener(this._dom.root, "showing", this._handleShowingKeyboardBound);
// Initialize private state.
this._disposed = false;
this._cachedClosedHeight = null;
this._commandingSurface = new _CommandingSurface._CommandingSurface(this._dom.commandingSurfaceEl, { openCloseMachine: stateMachine });
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-actionarea"), _Constants.ClassNames.actionAreaCssClass);
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-overflowarea"), _Constants.ClassNames.overflowAreaCssClass);
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-overflowbutton"), _Constants.ClassNames.overflowButtonCssClass);
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-ellipsis"), _Constants.ClassNames.ellipsisCssClass);
this._isOpenedMode = _Constants.defaultOpened;
this._dismissable = new _LightDismissService.LightDismissableElement({
element: this._dom.root,
tabIndex: this._dom.root.hasAttribute("tabIndex") ? this._dom.root.tabIndex : -1,
onLightDismiss: () => {
this.close();
},
onTakeFocus: (useSetActive) => {
this._dismissable.restoreFocus() ||
this._commandingSurface.takeFocus(useSetActive);
}
});
// Initialize public properties.
this.closedDisplayMode = _Constants.defaultClosedDisplayMode;
this.opened = this._isOpenedMode;
_Control.setOptions(this, options);
// Exit the Init state.
_ElementUtilities._inDom(this.element).then(() => {
return this._commandingSurface.initialized;
}).then(() => {
stateMachine.exitInit();
this._writeProfilerMark("constructor,StopTM");
});
}
/// <field type="Function" locid="WinJS.UI.ToolBar.onbeforeopen" helpKeyword="WinJS.UI.ToolBar.onbeforeopen">
/// Occurs immediately before the control is opened. Is cancelable.
/// </field>
onbeforeopen: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onafteropen" helpKeyword="WinJS.UI.ToolBar.onafteropen">
/// Occurs immediately after the control is opened.
/// </field>
onafteropen: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onbeforeclose" helpKeyword="WinJS.UI.ToolBar.onbeforeclose">
/// Occurs immediately before the control is closed. Is cancelable.
/// </field>
onbeforeclose: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onafterclose" helpKeyword="WinJS.UI.ToolBar.onafterclose">
/// Occurs immediately after the control is closed.
/// </field>
onafterclose: (ev: CustomEvent) => void;
open(): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.open">
/// <summary locid="WinJS.UI.ToolBar.open">
/// Opens the ToolBar
/// </summary>
/// </signature>
this._commandingSurface.open();
}
close(): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.close">
/// <summary locid="WinJS.UI.ToolBar.close">
/// Closes the ToolBar
/// </summary>
/// </signature>
this._commandingSurface.close();
}
dispose() {
/// <signature helpKeyword="WinJS.UI.ToolBar.dispose">
/// <summary locid="WinJS.UI.ToolBar.dispose">
/// Disposes this ToolBar.
/// </summary>
/// </signature>
if (this._disposed) {
return;
}
this._disposed = true;
_LightDismissService.hidden(this._dismissable);
// Disposing the _commandingSurface will trigger dispose on its OpenCloseMachine and synchronously complete any animations that might have been running.
this._commandingSurface.dispose();
// If page navigation is happening, we don't want the ToolBar left behind in the body.
// Synchronoulsy close the ToolBar to force it out of the body and back into its parent element.
this._synchronousClose();
_ElementUtilities._inputPaneListener.removeEventListener(this._dom.root, "showing", this._handleShowingKeyboardBound);
_Dispose.disposeSubTree(this.element);
}
forceLayout() {
/// <signature helpKeyword="WinJS.UI.ToolBar.forceLayout">
/// <summary locid="WinJS.UI.ToolBar.forceLayout">
/// Forces the ToolBar to update its layout. Use this function when the window did not change size, but the container of the ToolBar changed size.
/// </summary>
/// </signature>
this._commandingSurface.forceLayout();
}
getCommandById(id: string): _Command.ICommand {
/// <signature helpKeyword="WinJS.UI.ToolBar.getCommandById">
/// <summary locid="WinJS.UI.ToolBar.getCommandById">
/// Retrieves the command with the specified ID from this ToolBar.
/// If more than one command is found, this method returns the first command found.
/// </summary>
/// <param name="id" type="String" locid="WinJS.UI.ToolBar.getCommandById_p:id">Id of the command to return.</param>
/// <returns type="object" locid="WinJS.UI.ToolBar.getCommandById_returnValue">
/// The command found, or null if no command is found.
/// </returns>
/// </signature>
return this._commandingSurface.getCommandById(id);
}
showOnlyCommands(commands: Array<string|_Command.ICommand>): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.showOnlyCommands">
/// <summary locid="WinJS.UI.ToolBar.showOnlyCommands">
/// Show the specified commands, hiding all of the others in the ToolBar.
/// </summary>
/// <param name="commands" type="Array" locid="WinJS.UI.ToolBar.showOnlyCommands_p:commands">
/// An array of the commands to show. The array elements may be Command objects, or the string identifiers (IDs) of commands.
/// </param>
/// </signature>
return this._commandingSurface.showOnlyCommands(commands);
}
private _writeProfilerMark(text: string) {
_WriteProfilerMark("WinJS.UI.ToolBar:" + this._id + ":" + text);
}
private _initializeDom(root: HTMLElement): void {
this._writeProfilerMark("_intializeDom,info");
// Attaching JS control to DOM element
root["winControl"] = this;
this._id = root.id || _ElementUtilities._uniqueID(root);
_ElementUtilities.addClass(root, _Constants.ClassNames.controlCssClass);
_ElementUtilities.addClass(root, _Constants.ClassNames.disposableCssClass);
// Make sure we have an ARIA role
var role = root.getAttribute("role");
if (!role) { | root.setAttribute("role", "menubar");
}
var label = root.getAttribute("aria-label"); | random_line_split |
|
_ToolBar.ts | private _isOpenedMode: boolean;
private _handleShowingKeyboardBound: (ev: any) => void;
private _dismissable: _LightDismissService.LightDismissableElement;
private _cachedClosedHeight: number;
private _dom: {
root: HTMLElement;
commandingSurfaceEl: HTMLElement;
placeHolder: HTMLElement;
}
/// <field locid="WinJS.UI.ToolBar.ClosedDisplayMode" helpKeyword="WinJS.UI.ToolBar.ClosedDisplayMode">
/// Display options for the actionarea when the ToolBar is closed.
/// </field>
static ClosedDisplayMode = ClosedDisplayMode;
static supportedForProcessing: boolean = true;
/// <field type="HTMLElement" domElement="true" hidden="true" locid="WinJS.UI.ToolBar.element" helpKeyword="WinJS.UI.ToolBar.element">
/// Gets the DOM element that hosts the ToolBar.
/// </field>
get element() {
return this._dom.root;
}
/// <field type="WinJS.Binding.List" locid="WinJS.UI.ToolBar.data" helpKeyword="WinJS.UI.ToolBar.data">
/// Gets or sets the Binding List of WinJS.UI.Command for the ToolBar.
/// </field>
get data() {
return this._commandingSurface.data;
}
set data(value: BindingList.List<_Command.ICommand>) {
this._commandingSurface.data = value;
}
/// <field type="String" locid="WinJS.UI.ToolBar.closedDisplayMode" helpKeyword="WinJS.UI.ToolBar.closedDisplayMode">
/// Gets or sets the closedDisplayMode for the ToolBar. Values are "compact" and "full".
/// </field>
get closedDisplayMode() {
return this._commandingSurface.closedDisplayMode;
}
set closedDisplayMode(value: string) {
if (ClosedDisplayMode[value]) {
this._commandingSurface.closedDisplayMode = value;
this._cachedClosedHeight = null;
}
}
/// <field type="Boolean" hidden="true" locid="WinJS.UI.ToolBar.opened" helpKeyword="WinJS.UI.ToolBar.opened">
/// Gets or sets whether the ToolBar is currently opened.
/// </field>
get opened(): boolean {
return this._commandingSurface.opened;
}
set opened(value: boolean) {
this._commandingSurface.opened = value;
}
constructor(element?: HTMLElement, options: any = {}) {
/// <signature helpKeyword="WinJS.UI.ToolBar.ToolBar">
/// <summary locid="WinJS.UI.ToolBar.constructor">
/// Creates a new ToolBar control.
/// </summary>
/// <param name="element" type="HTMLElement" domElement="true" locid="WinJS.UI.ToolBar.constructor_p:element">
/// The DOM element that will host the control.
/// </param>
/// <param name="options" type="Object" locid="WinJS.UI.ToolBar.constructor_p:options">
/// The set of properties and values to apply to the new ToolBar control.
/// </param>
/// <returns type="WinJS.UI.ToolBar" locid="WinJS.UI.ToolBar.constructor_returnValue">
/// The new ToolBar control.
/// </returns>
/// </signature>
this._writeProfilerMark("constructor,StartTM");
// Check to make sure we weren't duplicated
if (element && element["winControl"]) {
throw new _ErrorFromName("WinJS.UI.ToolBar.DuplicateConstruction", strings.duplicateConstruction);
}
this._initializeDom(element || _Global.document.createElement("div"));
var stateMachine = new _OpenCloseMachine.OpenCloseMachine({
eventElement: this.element,
onOpen: () => {
var openAnimation = this._commandingSurface.createOpenAnimation(this._getClosedHeight());
this._synchronousOpen();
return openAnimation.execute();
},
onClose: () => {
var closeAnimation = this._commandingSurface.createCloseAnimation(this._getClosedHeight());
return closeAnimation.execute().then(() => {
this._synchronousClose();
});
},
onUpdateDom: () => {
this._updateDomImpl();
},
onUpdateDomWithIsOpened: (isOpened: boolean) => {
this._isOpenedMode = isOpened;
this._updateDomImpl();
}
});
// Events
this._handleShowingKeyboardBound = this._handleShowingKeyboard.bind(this);
_ElementUtilities._inputPaneListener.addEventListener(this._dom.root, "showing", this._handleShowingKeyboardBound);
// Initialize private state.
this._disposed = false;
this._cachedClosedHeight = null;
this._commandingSurface = new _CommandingSurface._CommandingSurface(this._dom.commandingSurfaceEl, { openCloseMachine: stateMachine });
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-actionarea"), _Constants.ClassNames.actionAreaCssClass);
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-overflowarea"), _Constants.ClassNames.overflowAreaCssClass);
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-overflowbutton"), _Constants.ClassNames.overflowButtonCssClass);
addClass(<HTMLElement>this._dom.commandingSurfaceEl.querySelector(".win-commandingsurface-ellipsis"), _Constants.ClassNames.ellipsisCssClass);
this._isOpenedMode = _Constants.defaultOpened;
this._dismissable = new _LightDismissService.LightDismissableElement({
element: this._dom.root,
tabIndex: this._dom.root.hasAttribute("tabIndex") ? this._dom.root.tabIndex : -1,
onLightDismiss: () => {
this.close();
},
onTakeFocus: (useSetActive) => {
this._dismissable.restoreFocus() ||
this._commandingSurface.takeFocus(useSetActive);
}
});
// Initialize public properties.
this.closedDisplayMode = _Constants.defaultClosedDisplayMode;
this.opened = this._isOpenedMode;
_Control.setOptions(this, options);
// Exit the Init state.
_ElementUtilities._inDom(this.element).then(() => {
return this._commandingSurface.initialized;
}).then(() => {
stateMachine.exitInit();
this._writeProfilerMark("constructor,StopTM");
});
}
/// <field type="Function" locid="WinJS.UI.ToolBar.onbeforeopen" helpKeyword="WinJS.UI.ToolBar.onbeforeopen">
/// Occurs immediately before the control is opened. Is cancelable.
/// </field>
onbeforeopen: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onafteropen" helpKeyword="WinJS.UI.ToolBar.onafteropen">
/// Occurs immediately after the control is opened.
/// </field>
onafteropen: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onbeforeclose" helpKeyword="WinJS.UI.ToolBar.onbeforeclose">
/// Occurs immediately before the control is closed. Is cancelable.
/// </field>
onbeforeclose: (ev: CustomEvent) => void;
/// <field type="Function" locid="WinJS.UI.ToolBar.onafterclose" helpKeyword="WinJS.UI.ToolBar.onafterclose">
/// Occurs immediately after the control is closed.
/// </field>
onafterclose: (ev: CustomEvent) => void;
open(): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.open">
/// <summary locid="WinJS.UI.ToolBar.open">
/// Opens the ToolBar
/// </summary>
/// </signature>
this._commandingSurface.open();
}
close(): void {
/// <signature helpKeyword="WinJS.UI.ToolBar.close">
/// <summary locid="WinJS.UI.ToolBar.close">
/// Closes the ToolBar
/// </summary>
/// </signature>
this._commandingSurface.close();
}
dispose() {
/// <signature helpKeyword="WinJS.UI.ToolBar.dispose">
/// <summary locid="WinJS.UI.ToolBar.dispose">
/// Disposes this ToolBar.
/// </summary>
/// </signature>
if (this._disposed) {
return;
}
this._disposed = true;
_LightDismissService.hidden(this._dismissable);
// Disposing the _commandingSurface will trigger dispose on its OpenCloseMachine and synchronously complete any animations that might have been running.
this._commandingSurface.dispose();
// If page navigation is happening, we don't want the ToolBar left behind in the body.
// Synchronoulsy close the ToolBar to force it out of the body and back into its parent element.
this._synchronousClose();
_ElementUtilities._inputPaneListener.removeEventListener(this._dom.root, "showing", this._handleShowingKeyboardBound);
_Dispose.disposeSubTree(this.element);
}
forceLayout() {
/// <signature helpKeyword="WinJS.UI.ToolBar.forceLayout">
/// <summary locid="WinJS.UI.ToolBar.forceLayout">
/// Forces the ToolBar to update its layout. Use this function when the window did not change size, but the container of the ToolBar changed size.
/// </summary>
/// </signature>
this._commandingSurface.forceLayout();
}
| getCommandById | identifier_name |
|
update.py | pragma: no cover
toml = None # type: ignore
CruftState = Dict[str, Any]
@example(skip_apply_ask=False)
@example()
def update(
project_dir: Path = Path("."),
cookiecutter_input: bool = False,
skip_apply_ask: bool = True,
skip_update: bool = False,
checkout: Optional[str] = None,
strict: bool = True,
) -> bool:
"""Update specified project's cruft to the latest and greatest release."""
pyproject_file = project_dir / "pyproject.toml"
cruft_file = get_cruft_file(project_dir)
# If the project dir is a git repository, we ensure
# that the user has a clean working directory before proceeding.
if not _is_project_repo_clean(project_dir):
typer.secho(
"Cruft cannot apply updates on an unclean git project."
" Please make sure your git working tree is clean before proceeding.",
fg=typer.colors.RED,
)
return False
cruft_state = json.loads(cruft_file.read_text())
with TemporaryDirectory() as compare_directory_str:
# Initial setup
compare_directory = Path(compare_directory_str)
template_dir = compare_directory / "template"
repo = get_cookiecutter_repo(cruft_state["template"], template_dir, checkout)
directory = cruft_state.get("directory", None)
if directory:
template_dir = template_dir / directory
last_commit = repo.head.object.hexsha
# Bail early if the repo is already up to date
if is_project_updated(repo, cruft_state["commit"], last_commit, strict):
typer.secho(
"Nothing to do, project's cruft is already up to date!", fg=typer.colors.GREEN
)
return True
# Generate clean outputs via the cookiecutter
# from the current cruft state commit of the cookiectter and the updated
# cookiecutter.
old_main_directory, new_main_directory, new_context = _generate_project_updates(
compare_directory, cruft_state, template_dir, cookiecutter_input, repo
)
# Get all paths that we are supposed to skip before generating the diff and applying updates
skip_paths = _get_skip_paths(cruft_state, pyproject_file)
# We also get the list of paths that were deleted from the project
# directory but were present in the template that the project is linked against
# This is to avoid introducing changes that won't apply cleanly to the current project.
deleted_paths = _get_deleted_files(old_main_directory, project_dir)
# We now remove both the skipped and deleted paths from the new and old project
_remove_paths(old_main_directory, new_main_directory, skip_paths | deleted_paths)
# Given the two versions of the cookiecutter outputs based
# on the current project's context we calculate the diff and
# apply the updates to the current project.
if _apply_project_updates(
old_main_directory, new_main_directory, project_dir, skip_update, skip_apply_ask
):
# Update the cruft state and dump the new state
# to the cruft file
cruft_state["commit"] = last_commit
cruft_state["context"] = new_context
cruft_state["directory"] = directory
cruft_file.write_text(json_dumps(cruft_state))
typer.secho(
"Good work! Project's cruft has been updated and is as clean as possible!",
fg=typer.colors.GREEN,
)
return True
#####################################
# Generating clean outputs for diff #
#####################################
def _generate_output(
cruft_state: CruftState, template_dir: Path, cookiecutter_input: bool, new_output_dir: Path
):
new_context = generate_cookiecutter_context(
cruft_state["template"],
template_dir,
extra_context=cruft_state["context"]["cookiecutter"],
no_input=not cookiecutter_input,
)
project_dir = generate_files(
repo_dir=template_dir,
context=new_context,
overwrite_if_exists=True,
output_dir=new_output_dir,
)
return new_context, Path(project_dir)
def _generate_project_updates(
compare_directory: Path,
cruft_state: CruftState,
template_dir: Path,
cookiecutter_input: bool,
repo: Repo,
):
new_output_dir = compare_directory / "new_output"
new_context, new_main_directory = _generate_output(
cruft_state, template_dir, cookiecutter_input, new_output_dir
)
repo.head.reset(commit=cruft_state["commit"], working_tree=True)
old_output_dir = compare_directory / "old_output"
# We should not prompt for the cookiecutter input for the current
# project state
_, old_main_directory = _generate_output(cruft_state, template_dir, False, old_output_dir)
return old_main_directory, new_main_directory, new_context
##############################
# Removing unnecessary files #
##############################
def _get_skip_paths(cruft_state: CruftState, pyproject_file: Path) -> Set[Path]:
skip_cruft = cruft_state.get("skip", [])
if toml and pyproject_file.is_file():
pyproject_cruft = toml.loads(pyproject_file.read_text()).get("tool", {}).get("cruft", {})
skip_cruft.extend(pyproject_cruft.get("skip", []))
return set(map(Path, skip_cruft))
def _get_deleted_files(template_dir: Path, project_dir: Path):
cwd = Path.cwd()
os.chdir(template_dir)
template_paths = set(Path(".").glob("**/*"))
os.chdir(cwd)
os.chdir(project_dir)
deleted_paths = set(filter(lambda path: not path.exists(), template_paths))
os.chdir(cwd)
return deleted_paths
def _remove_paths(old_main_directory: Path, new_main_directory: Path, paths_to_remove: Set[Path]):
for path_to_remove in paths_to_remove:
old_path = old_main_directory / path_to_remove
new_path = new_main_directory / path_to_remove
for path in (old_path, new_path):
if path.is_dir():
rmtree(path)
elif path.is_file():
path.unlink()
#################################################
# Calculating project diff and applying updates #
#################################################
def _get_diff(old_main_directory: Path, new_main_directory: Path):
diff = run(
[
"git",
"diff",
"--no-index",
"--no-ext-diff",
"--no-color",
str(old_main_directory),
str(new_main_directory),
],
stdout=PIPE,
stderr=PIPE,
).stdout.decode()
diff = diff.replace(str(old_main_directory), "").replace(str(new_main_directory), "")
return diff
def _view_diff(old_main_directory: Path, new_main_directory: Path):
run(["git", "diff", "--no-index", str(old_main_directory), str(new_main_directory)])
def _is_git_repo(directory: Path):
# Taken from https://stackoverflow.com/a/16925062
# This works even if we are in a sub folder in a git
# repo
output = run(
["git", "rev-parse", "--is-inside-work-tree"], stdout=PIPE, stderr=DEVNULL, cwd=directory
)
if b"true" in output.stdout:
return True
return False
def _is_project_repo_clean(directory: Path):
if not _is_git_repo(directory):
return True
output = run(["git", "status", "--porcelain"], stdout=PIPE, stderr=DEVNULL, cwd=directory)
if output.stdout.strip():
return False
return True
def _apply_patch_with_rejections(diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "--reject"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
typer.secho(
(
"Project directory may have *.rej files reflecting merge conflicts with the update."
" Please resolve those conflicts manually."
),
fg=typer.colors.YELLOW,
)
def | (diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "-3"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
if _is_project_repo_clean(expanded_dir_path):
typer.secho(
"Failed to apply the update. Retrying again with a different update stratergy.",
fg=typer.colors.YELLOW,
)
_apply_patch_with_rejections(diff, expanded_dir_path)
def _apply_patch(diff: str, expanded_dir_path: Path):
# Git 3 way merge is the our best bet
# at applying patches. But it only works
# with git repos. If the repo is not a git dir
# we fall back to git apply --reject which applies
# diffs cleanly where applicable otherwise creates
# *.rej files where there are conflicts
if _is_git_repo(expanded_dir_path):
_apply_three_way_patch | _apply_three_way_patch | identifier_name |
update.py | pragma: no cover
toml = None # type: ignore
CruftState = Dict[str, Any]
@example(skip_apply_ask=False)
@example()
def update(
project_dir: Path = Path("."),
cookiecutter_input: bool = False,
skip_apply_ask: bool = True,
skip_update: bool = False,
checkout: Optional[str] = None,
strict: bool = True,
) -> bool:
"""Update specified project's cruft to the latest and greatest release."""
pyproject_file = project_dir / "pyproject.toml"
cruft_file = get_cruft_file(project_dir)
# If the project dir is a git repository, we ensure
# that the user has a clean working directory before proceeding.
if not _is_project_repo_clean(project_dir):
typer.secho(
"Cruft cannot apply updates on an unclean git project."
" Please make sure your git working tree is clean before proceeding.",
fg=typer.colors.RED,
)
return False
cruft_state = json.loads(cruft_file.read_text())
with TemporaryDirectory() as compare_directory_str:
# Initial setup
compare_directory = Path(compare_directory_str)
template_dir = compare_directory / "template"
repo = get_cookiecutter_repo(cruft_state["template"], template_dir, checkout)
directory = cruft_state.get("directory", None)
if directory:
template_dir = template_dir / directory
last_commit = repo.head.object.hexsha
# Bail early if the repo is already up to date
if is_project_updated(repo, cruft_state["commit"], last_commit, strict):
typer.secho(
"Nothing to do, project's cruft is already up to date!", fg=typer.colors.GREEN
)
return True
# Generate clean outputs via the cookiecutter
# from the current cruft state commit of the cookiectter and the updated
# cookiecutter.
old_main_directory, new_main_directory, new_context = _generate_project_updates(
compare_directory, cruft_state, template_dir, cookiecutter_input, repo
)
# Get all paths that we are supposed to skip before generating the diff and applying updates
skip_paths = _get_skip_paths(cruft_state, pyproject_file)
# We also get the list of paths that were deleted from the project
# directory but were present in the template that the project is linked against
# This is to avoid introducing changes that won't apply cleanly to the current project.
deleted_paths = _get_deleted_files(old_main_directory, project_dir)
# We now remove both the skipped and deleted paths from the new and old project
_remove_paths(old_main_directory, new_main_directory, skip_paths | deleted_paths)
# Given the two versions of the cookiecutter outputs based
# on the current project's context we calculate the diff and
# apply the updates to the current project.
if _apply_project_updates(
old_main_directory, new_main_directory, project_dir, skip_update, skip_apply_ask
):
# Update the cruft state and dump the new state
# to the cruft file
cruft_state["commit"] = last_commit
cruft_state["context"] = new_context
cruft_state["directory"] = directory
cruft_file.write_text(json_dumps(cruft_state))
typer.secho(
"Good work! Project's cruft has been updated and is as clean as possible!",
fg=typer.colors.GREEN,
)
return True
#####################################
# Generating clean outputs for diff #
#####################################
def _generate_output(
cruft_state: CruftState, template_dir: Path, cookiecutter_input: bool, new_output_dir: Path
):
new_context = generate_cookiecutter_context(
cruft_state["template"],
template_dir,
extra_context=cruft_state["context"]["cookiecutter"],
no_input=not cookiecutter_input,
)
project_dir = generate_files(
repo_dir=template_dir,
context=new_context,
overwrite_if_exists=True,
output_dir=new_output_dir,
)
return new_context, Path(project_dir)
def _generate_project_updates(
compare_directory: Path,
cruft_state: CruftState,
template_dir: Path,
cookiecutter_input: bool,
repo: Repo,
):
new_output_dir = compare_directory / "new_output"
new_context, new_main_directory = _generate_output(
cruft_state, template_dir, cookiecutter_input, new_output_dir
)
repo.head.reset(commit=cruft_state["commit"], working_tree=True)
old_output_dir = compare_directory / "old_output"
# We should not prompt for the cookiecutter input for the current
# project state
_, old_main_directory = _generate_output(cruft_state, template_dir, False, old_output_dir)
return old_main_directory, new_main_directory, new_context
##############################
# Removing unnecessary files #
##############################
def _get_skip_paths(cruft_state: CruftState, pyproject_file: Path) -> Set[Path]:
skip_cruft = cruft_state.get("skip", [])
if toml and pyproject_file.is_file():
pyproject_cruft = toml.loads(pyproject_file.read_text()).get("tool", {}).get("cruft", {})
skip_cruft.extend(pyproject_cruft.get("skip", []))
return set(map(Path, skip_cruft))
def _get_deleted_files(template_dir: Path, project_dir: Path):
cwd = Path.cwd()
os.chdir(template_dir)
template_paths = set(Path(".").glob("**/*"))
os.chdir(cwd)
os.chdir(project_dir)
deleted_paths = set(filter(lambda path: not path.exists(), template_paths))
os.chdir(cwd)
return deleted_paths
def _remove_paths(old_main_directory: Path, new_main_directory: Path, paths_to_remove: Set[Path]):
for path_to_remove in paths_to_remove:
old_path = old_main_directory / path_to_remove
new_path = new_main_directory / path_to_remove
for path in (old_path, new_path):
if path.is_dir():
rmtree(path)
elif path.is_file():
path.unlink()
#################################################
# Calculating project diff and applying updates #
#################################################
def _get_diff(old_main_directory: Path, new_main_directory: Path):
diff = run(
[
"git",
"diff",
"--no-index",
"--no-ext-diff",
"--no-color",
str(old_main_directory),
str(new_main_directory),
],
stdout=PIPE,
stderr=PIPE,
).stdout.decode()
diff = diff.replace(str(old_main_directory), "").replace(str(new_main_directory), "")
return diff
def _view_diff(old_main_directory: Path, new_main_directory: Path):
|
def _is_git_repo(directory: Path):
# Taken from https://stackoverflow.com/a/16925062
# This works even if we are in a sub folder in a git
# repo
output = run(
["git", "rev-parse", "--is-inside-work-tree"], stdout=PIPE, stderr=DEVNULL, cwd=directory
)
if b"true" in output.stdout:
return True
return False
def _is_project_repo_clean(directory: Path):
if not _is_git_repo(directory):
return True
output = run(["git", "status", "--porcelain"], stdout=PIPE, stderr=DEVNULL, cwd=directory)
if output.stdout.strip():
return False
return True
def _apply_patch_with_rejections(diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "--reject"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
typer.secho(
(
"Project directory may have *.rej files reflecting merge conflicts with the update."
" Please resolve those conflicts manually."
),
fg=typer.colors.YELLOW,
)
def _apply_three_way_patch(diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "-3"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
if _is_project_repo_clean(expanded_dir_path):
typer.secho(
"Failed to apply the update. Retrying again with a different update stratergy.",
fg=typer.colors.YELLOW,
)
_apply_patch_with_rejections(diff, expanded_dir_path)
def _apply_patch(diff: str, expanded_dir_path: Path):
# Git 3 way merge is the our best bet
# at applying patches. But it only works
# with git repos. If the repo is not a git dir
# we fall back to git apply --reject which applies
# diffs cleanly where applicable otherwise creates
# *.rej files where there are conflicts
if _is_git_repo(expanded_dir_path):
_apply_three_way_patch | run(["git", "diff", "--no-index", str(old_main_directory), str(new_main_directory)]) | identifier_body |
update.py | toml = None # type: ignore
CruftState = Dict[str, Any]
@example(skip_apply_ask=False)
@example()
def update(
project_dir: Path = Path("."),
cookiecutter_input: bool = False,
skip_apply_ask: bool = True,
skip_update: bool = False,
checkout: Optional[str] = None,
strict: bool = True,
) -> bool:
"""Update specified project's cruft to the latest and greatest release."""
pyproject_file = project_dir / "pyproject.toml"
cruft_file = get_cruft_file(project_dir)
# If the project dir is a git repository, we ensure
# that the user has a clean working directory before proceeding.
if not _is_project_repo_clean(project_dir):
typer.secho(
"Cruft cannot apply updates on an unclean git project."
" Please make sure your git working tree is clean before proceeding.",
fg=typer.colors.RED,
)
return False
cruft_state = json.loads(cruft_file.read_text())
with TemporaryDirectory() as compare_directory_str:
# Initial setup
compare_directory = Path(compare_directory_str)
template_dir = compare_directory / "template"
repo = get_cookiecutter_repo(cruft_state["template"], template_dir, checkout)
directory = cruft_state.get("directory", None)
if directory:
template_dir = template_dir / directory
last_commit = repo.head.object.hexsha
# Bail early if the repo is already up to date
if is_project_updated(repo, cruft_state["commit"], last_commit, strict):
typer.secho(
"Nothing to do, project's cruft is already up to date!", fg=typer.colors.GREEN
)
return True
# Generate clean outputs via the cookiecutter
# from the current cruft state commit of the cookiectter and the updated
# cookiecutter.
old_main_directory, new_main_directory, new_context = _generate_project_updates(
compare_directory, cruft_state, template_dir, cookiecutter_input, repo
)
# Get all paths that we are supposed to skip before generating the diff and applying updates
skip_paths = _get_skip_paths(cruft_state, pyproject_file)
# We also get the list of paths that were deleted from the project
# directory but were present in the template that the project is linked against
# This is to avoid introducing changes that won't apply cleanly to the current project.
deleted_paths = _get_deleted_files(old_main_directory, project_dir)
# We now remove both the skipped and deleted paths from the new and old project
_remove_paths(old_main_directory, new_main_directory, skip_paths | deleted_paths)
# Given the two versions of the cookiecutter outputs based
# on the current project's context we calculate the diff and
# apply the updates to the current project.
if _apply_project_updates(
old_main_directory, new_main_directory, project_dir, skip_update, skip_apply_ask
):
# Update the cruft state and dump the new state
# to the cruft file
cruft_state["commit"] = last_commit
cruft_state["context"] = new_context
cruft_state["directory"] = directory
cruft_file.write_text(json_dumps(cruft_state))
typer.secho(
"Good work! Project's cruft has been updated and is as clean as possible!",
fg=typer.colors.GREEN,
)
return True
#####################################
# Generating clean outputs for diff #
#####################################
def _generate_output(
cruft_state: CruftState, template_dir: Path, cookiecutter_input: bool, new_output_dir: Path
):
new_context = generate_cookiecutter_context(
cruft_state["template"],
template_dir,
extra_context=cruft_state["context"]["cookiecutter"],
no_input=not cookiecutter_input,
)
project_dir = generate_files(
repo_dir=template_dir,
context=new_context,
overwrite_if_exists=True,
output_dir=new_output_dir,
)
return new_context, Path(project_dir)
def _generate_project_updates(
compare_directory: Path,
cruft_state: CruftState,
template_dir: Path,
cookiecutter_input: bool,
repo: Repo,
):
new_output_dir = compare_directory / "new_output"
new_context, new_main_directory = _generate_output(
cruft_state, template_dir, cookiecutter_input, new_output_dir
)
repo.head.reset(commit=cruft_state["commit"], working_tree=True)
old_output_dir = compare_directory / "old_output"
# We should not prompt for the cookiecutter input for the current
# project state
_, old_main_directory = _generate_output(cruft_state, template_dir, False, old_output_dir)
return old_main_directory, new_main_directory, new_context
##############################
# Removing unnecessary files #
##############################
def _get_skip_paths(cruft_state: CruftState, pyproject_file: Path) -> Set[Path]:
skip_cruft = cruft_state.get("skip", [])
if toml and pyproject_file.is_file():
pyproject_cruft = toml.loads(pyproject_file.read_text()).get("tool", {}).get("cruft", {})
skip_cruft.extend(pyproject_cruft.get("skip", []))
return set(map(Path, skip_cruft))
def _get_deleted_files(template_dir: Path, project_dir: Path):
cwd = Path.cwd()
os.chdir(template_dir)
template_paths = set(Path(".").glob("**/*"))
os.chdir(cwd)
os.chdir(project_dir)
deleted_paths = set(filter(lambda path: not path.exists(), template_paths))
os.chdir(cwd)
return deleted_paths
def _remove_paths(old_main_directory: Path, new_main_directory: Path, paths_to_remove: Set[Path]):
for path_to_remove in paths_to_remove:
old_path = old_main_directory / path_to_remove
new_path = new_main_directory / path_to_remove
for path in (old_path, new_path):
if path.is_dir():
rmtree(path)
elif path.is_file():
path.unlink()
#################################################
# Calculating project diff and applying updates #
#################################################
def _get_diff(old_main_directory: Path, new_main_directory: Path):
diff = run(
[
"git",
"diff",
"--no-index",
"--no-ext-diff",
"--no-color",
str(old_main_directory),
str(new_main_directory),
],
stdout=PIPE,
stderr=PIPE,
).stdout.decode()
diff = diff.replace(str(old_main_directory), "").replace(str(new_main_directory), "")
return diff
def _view_diff(old_main_directory: Path, new_main_directory: Path):
run(["git", "diff", "--no-index", str(old_main_directory), str(new_main_directory)])
def _is_git_repo(directory: Path):
# Taken from https://stackoverflow.com/a/16925062
# This works even if we are in a sub folder in a git
# repo
output = run(
["git", "rev-parse", "--is-inside-work-tree"], stdout=PIPE, stderr=DEVNULL, cwd=directory
)
if b"true" in output.stdout:
return True
return False
def _is_project_repo_clean(directory: Path):
if not _is_git_repo(directory):
return True
output = run(["git", "status", "--porcelain"], stdout=PIPE, stderr=DEVNULL, cwd=directory)
if output.stdout.strip():
return False
return True
def _apply_patch_with_rejections(diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "--reject"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
typer.secho(
(
"Project directory may have *.rej files reflecting merge conflicts with the update."
" Please resolve those conflicts manually."
),
fg=typer.colors.YELLOW,
)
def _apply_three_way_patch(diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "-3"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
if _is_project_repo_clean(expanded_dir_path):
typer.secho(
"Failed to apply the update. Retrying again with a different update stratergy.",
fg=typer.colors.YELLOW,
)
_apply_patch_with_rejections(diff, expanded_dir_path)
def _apply_patch(diff: str, expanded_dir_path: Path):
# Git 3 way merge is the our best bet
# at applying patches. But it only works
# with git repos. If the repo is not a git dir
# we fall back to git apply --reject which applies
# diffs cleanly where applicable otherwise creates
# *.rej files where there are conflicts
if _is_git_repo(expanded_dir_path):
| _apply_three_way_patch(diff, expanded_dir_path) | conditional_block |
|
update.py | json_dumps,
)
try:
import toml # type: ignore
except ImportError: # pragma: no cover
toml = None # type: ignore
CruftState = Dict[str, Any]
@example(skip_apply_ask=False)
@example()
def update(
project_dir: Path = Path("."),
cookiecutter_input: bool = False,
skip_apply_ask: bool = True,
skip_update: bool = False,
checkout: Optional[str] = None,
strict: bool = True,
) -> bool:
"""Update specified project's cruft to the latest and greatest release."""
pyproject_file = project_dir / "pyproject.toml"
cruft_file = get_cruft_file(project_dir)
# If the project dir is a git repository, we ensure
# that the user has a clean working directory before proceeding.
if not _is_project_repo_clean(project_dir):
typer.secho(
"Cruft cannot apply updates on an unclean git project."
" Please make sure your git working tree is clean before proceeding.",
fg=typer.colors.RED,
)
return False
cruft_state = json.loads(cruft_file.read_text())
with TemporaryDirectory() as compare_directory_str:
# Initial setup
compare_directory = Path(compare_directory_str)
template_dir = compare_directory / "template"
repo = get_cookiecutter_repo(cruft_state["template"], template_dir, checkout)
directory = cruft_state.get("directory", None)
if directory:
template_dir = template_dir / directory
last_commit = repo.head.object.hexsha
# Bail early if the repo is already up to date
if is_project_updated(repo, cruft_state["commit"], last_commit, strict):
typer.secho(
"Nothing to do, project's cruft is already up to date!", fg=typer.colors.GREEN
)
return True
# Generate clean outputs via the cookiecutter
# from the current cruft state commit of the cookiectter and the updated
# cookiecutter.
old_main_directory, new_main_directory, new_context = _generate_project_updates(
compare_directory, cruft_state, template_dir, cookiecutter_input, repo
)
# Get all paths that we are supposed to skip before generating the diff and applying updates
skip_paths = _get_skip_paths(cruft_state, pyproject_file)
# We also get the list of paths that were deleted from the project
# directory but were present in the template that the project is linked against
# This is to avoid introducing changes that won't apply cleanly to the current project.
deleted_paths = _get_deleted_files(old_main_directory, project_dir)
# We now remove both the skipped and deleted paths from the new and old project
_remove_paths(old_main_directory, new_main_directory, skip_paths | deleted_paths)
# Given the two versions of the cookiecutter outputs based
# on the current project's context we calculate the diff and
# apply the updates to the current project.
if _apply_project_updates(
old_main_directory, new_main_directory, project_dir, skip_update, skip_apply_ask
):
# Update the cruft state and dump the new state
# to the cruft file
cruft_state["commit"] = last_commit
cruft_state["context"] = new_context
cruft_state["directory"] = directory
cruft_file.write_text(json_dumps(cruft_state))
typer.secho(
"Good work! Project's cruft has been updated and is as clean as possible!",
fg=typer.colors.GREEN,
)
return True
#####################################
# Generating clean outputs for diff #
#####################################
def _generate_output(
cruft_state: CruftState, template_dir: Path, cookiecutter_input: bool, new_output_dir: Path
):
new_context = generate_cookiecutter_context(
cruft_state["template"],
template_dir,
extra_context=cruft_state["context"]["cookiecutter"],
no_input=not cookiecutter_input,
)
project_dir = generate_files(
repo_dir=template_dir,
context=new_context,
overwrite_if_exists=True,
output_dir=new_output_dir,
)
return new_context, Path(project_dir)
def _generate_project_updates(
compare_directory: Path,
cruft_state: CruftState,
template_dir: Path,
cookiecutter_input: bool,
repo: Repo,
):
new_output_dir = compare_directory / "new_output"
new_context, new_main_directory = _generate_output(
cruft_state, template_dir, cookiecutter_input, new_output_dir
)
repo.head.reset(commit=cruft_state["commit"], working_tree=True)
old_output_dir = compare_directory / "old_output"
# We should not prompt for the cookiecutter input for the current
# project state
_, old_main_directory = _generate_output(cruft_state, template_dir, False, old_output_dir)
return old_main_directory, new_main_directory, new_context
##############################
# Removing unnecessary files #
##############################
def _get_skip_paths(cruft_state: CruftState, pyproject_file: Path) -> Set[Path]:
skip_cruft = cruft_state.get("skip", [])
if toml and pyproject_file.is_file():
pyproject_cruft = toml.loads(pyproject_file.read_text()).get("tool", {}).get("cruft", {})
skip_cruft.extend(pyproject_cruft.get("skip", []))
return set(map(Path, skip_cruft))
def _get_deleted_files(template_dir: Path, project_dir: Path):
cwd = Path.cwd()
os.chdir(template_dir)
template_paths = set(Path(".").glob("**/*"))
os.chdir(cwd)
os.chdir(project_dir)
deleted_paths = set(filter(lambda path: not path.exists(), template_paths))
os.chdir(cwd)
return deleted_paths
def _remove_paths(old_main_directory: Path, new_main_directory: Path, paths_to_remove: Set[Path]):
for path_to_remove in paths_to_remove:
old_path = old_main_directory / path_to_remove
new_path = new_main_directory / path_to_remove
for path in (old_path, new_path):
if path.is_dir():
rmtree(path)
elif path.is_file():
path.unlink()
#################################################
# Calculating project diff and applying updates #
#################################################
def _get_diff(old_main_directory: Path, new_main_directory: Path):
diff = run(
[
"git",
"diff",
"--no-index",
"--no-ext-diff",
"--no-color",
str(old_main_directory),
str(new_main_directory),
],
stdout=PIPE,
stderr=PIPE,
).stdout.decode()
diff = diff.replace(str(old_main_directory), "").replace(str(new_main_directory), "")
return diff
def _view_diff(old_main_directory: Path, new_main_directory: Path):
run(["git", "diff", "--no-index", str(old_main_directory), str(new_main_directory)])
def _is_git_repo(directory: Path):
# Taken from https://stackoverflow.com/a/16925062
# This works even if we are in a sub folder in a git
# repo
output = run(
["git", "rev-parse", "--is-inside-work-tree"], stdout=PIPE, stderr=DEVNULL, cwd=directory
)
if b"true" in output.stdout:
return True
return False
def _is_project_repo_clean(directory: Path):
if not _is_git_repo(directory):
return True
output = run(["git", "status", "--porcelain"], stdout=PIPE, stderr=DEVNULL, cwd=directory)
if output.stdout.strip():
return False
return True
def _apply_patch_with_rejections(diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "--reject"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
typer.secho(
(
"Project directory may have *.rej files reflecting merge conflicts with the update."
" Please resolve those conflicts manually."
),
fg=typer.colors.YELLOW,
)
def _apply_three_way_patch(diff: str, expanded_dir_path: Path):
try:
run(
["git", "apply", "-3"],
input=diff.encode(),
stderr=PIPE,
stdout=PIPE,
check=True,
cwd=expanded_dir_path,
)
except CalledProcessError as error:
typer.secho(error.stderr.decode(), err=True)
if _is_project_repo_clean(expanded_dir_path):
typer.secho(
"Failed to apply the update. Retrying again with a different update stratergy.",
fg=typer.colors.YELLOW,
)
_apply_patch_with_rejections(diff, expanded_dir_path)
def _apply_patch(diff: str, expanded_dir_path: Path):
# Git 3 way merge is the our best bet
# at applying patches. But it only works
# with git repos. If the repo is not a git dir
| generate_cookiecutter_context,
get_cookiecutter_repo,
get_cruft_file,
is_project_updated, | random_line_split |
|
main.rs | if reader.read_u32() != 0 {
println!("Failed to connect to igbp");
return Ok(());
}
qbo
};
println!("Allocate framebuffers");
let mut mem : Vec<BufferMemory> = Vec::with_capacity(3);
unsafe { mem.set_len(3); }
// Disables caching when talking to the gpu.
unsafe { svc::set_memory_attribute(mem.as_mut_ptr() as _, mem.len() * std::mem::size_of::<BufferMemory>(), 0x8, 0x8).expect("Failed to set memory attribute"); }
let gpu_buffer = {
let mut create = NvMapIocCreateArgs {
size: (mem.len() * std::mem::size_of::<BufferMemory>()) as u32,
handle: 0
};
println!("NVMAP_IOC_CREATE {:?} ({:?})", create, unsafe { std::mem::transmute::<&NvMapIocCreateArgs, &[u8; std::mem::size_of::<NvMapIocCreateArgs>()]>(&create) });
let ret = nvdrv.ioctl(nvmap, NVMAP_IOC_CREATE,
// TODO: This is unsafe. And illegal. Rust assumes aliasing
// doesn't happen with references, which is exactly what we're
// doing. In theory, because we never *read* the content of
// those, I believe this is, erm, "mostly OK" ? But I should
// find a better way to deal with it.
unsafe { std::slice::from_raw_parts(&create as *const NvMapIocCreateArgs as *const u8, std::mem::size_of::<NvMapIocCreateArgs>()) },
unsafe { std::slice::from_raw_parts_mut(&mut create as *mut NvMapIocCreateArgs as *mut u8, std::mem::size_of::<NvMapIocCreateArgs>()) })?;
if ret != 0 |
GpuBuffer {
nvmap_handle: create.handle,
size: mem.len() * std::mem::size_of::<BufferMemory>(),
alignment: 0x1000,
kind: 0
}
};
let buffers = {
let mut alloc = NvMapIocAllocArgs {
handle: gpu_buffer.nvmap_handle,
heapmask: 0,
flags: 0,
align: gpu_buffer.alignment,
kind: gpu_buffer.kind,
pad: [0; 7],
addr: mem.as_mut_ptr() as u64
};
println!("NVMAP_IOC_ALLOC {:?} ({:?})", alloc, unsafe { std::mem::transmute::<&NvMapIocAllocArgs, &[u8; std::mem::size_of::<NvMapIocAllocArgs>()]>(&alloc) });
let ret = nvdrv.ioctl(nvmap, NVMAP_IOC_ALLOC,
// TODO: This is unsafe. And illegal. Rust assumes aliasing
// doesn't happen with references, which is exactly what we're
// doing. In theory, because we never *read* the content of
// those, I believe this is, erm, "mostly OK" ? But I should
// find a better way to deal with it.
unsafe { std::slice::from_raw_parts(&alloc as *const NvMapIocAllocArgs as *const u8, std::mem::size_of::<NvMapIocAllocArgs>()) },
unsafe { std::slice::from_raw_parts_mut(&mut alloc as *mut NvMapIocAllocArgs as *mut u8, std::mem::size_of::<NvMapIocAllocArgs>()) })?;
if ret != 0 {
return Err(MyError::IoctlError(ret));
}
let mut buffers = Vec::with_capacity(3);
for i in 0..3 {
buffers.push(GraphicBuffer {
width: queue_buffer_output.width,
height: queue_buffer_output.height,
stride: queue_buffer_output.width,
format: 1, // RGBA_8888
usage: 0xb00, // TODO: Wat?
gpu_buffer: &gpu_buffer,
index: i,
offset_gpu_buffer: 0x3c0000 * i
});
}
buffers
};
println!("Tell IGBP about the buffers");
for (i, buf) in buffers.iter().enumerate() {
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(i as u32); // slot
parcel.write_u32(1); // Unknown
parcel.write_u32(0x16c); // Flattened GraphicsBuffer length
parcel.write_u32(0); // Unknown
buf.write_to_parcel(&mut parcel);
let mut parcel_out = RawParcel::default();
relay_svc.transact_parcel(binder_id as i32, SET_PREALLOCATED_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
println!("{:?}", parcel_out);
}
println!("Set scaling mode");
disp_svc.set_layer_scaling_mode(2, layer_id)?;
println!("Add layer to stack");
for stack in [0x0, 0x2, 0x4, 0x5, 0xA].iter() {
manager_disp_svc.add_to_layer_stack(*stack, layer_id)?;
}
println!("Set Z layer");
system_disp_svc.set_layer_z(layer_id, 2)?;
println!("Loading image from FERRIS");
let image = BMPDecoder::new(Cursor::new(&FERRIS[..]));
println!("Getting frame");
let frame = image.into_frames()?.next().unwrap().into_buffer();
//println!("Resizing FERRIS");
//let frame = image::imageops::resize(&image.into_frames()?.next().unwrap().into_buffer(), 1280, 760, image::FilterType::Lanczos3);
let vevent = unsafe { Event::from_kobject(disp_svc.get_display_vsync_event(display_id)?) };
for _ in 0..60 {
println!("Dequeue buffer");
let slot = {
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(1); // Pixel format
parcel.write_u32(1280); // width
parcel.write_u32(720); // height
parcel.write_u32(0); // get_frame_timestamp
parcel.write_u32(0xb00); // usage
let mut parcel_out = RawParcel::default();
relay_svc.transact_parcel(binder_id as i32, DEQUEUE_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
println!("{:?}", parcel_out);
let mut parcel_out = parcel_out.into_parcel_reader();
let slot = parcel_out.read_u32();
// Read fence
parcel_out.0.seek(SeekFrom::Current(44));
let status = parcel_out.read_u32();
if status != 0 {
println!("WTF: {}", status);
return Err(MyError::ParcelError(status));
}
slot
};
// Request buffer if it hasn't been requested already.
println!("Request buffer {}", slot);
{
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(slot); // Slot
let mut parcel_out = RawParcel::default();
let res = relay_svc.transact_parcel(binder_id as i32, REQUEST_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
let mut parcel_out = parcel_out.into_parcel_reader();
let non_null = parcel_out.read_u32() != 0;
if non_null {
let len = parcel_out.read_u32();
if len != 0x16c {
println!("Invalid length: {}", len);
return Ok(())
}
let unk = parcel_out.read_u32();
// TODO: Get graphicbuffer.
parcel_out.0.seek(SeekFrom::Current(0x16c));
}
let status = parcel_out.read_u32();
if status != 0 {
println!("WTF: {}", status);
return Err(MyError::ParcelError(status));
}
}
// Blit
println!("Blit");
{
fn pdep(mask: u32, mut value: u32) -> u32 {
let mut out = 0;
for shift in 0..32 {
let bit = 1 << shift;
if mask & bit != 0 {
if value & 1 != 0 {
out |= bit
}
value >>= 1;
}
}
out
}
fn swizzle_x(v: u32) -> u32 { pdep(!0x7B4, v) }
fn swizzle_y(v: u32) -> u32 { pdep(0x7B4, v) }
let x0 = 0;
let y0 = | {
return Err(MyError::IoctlError(ret));
} | conditional_block |
main.rs | .write_u32(1); // Pixel format
parcel.write_u32(1280); // width
parcel.write_u32(720); // height
parcel.write_u32(0); // get_frame_timestamp
parcel.write_u32(0xb00); // usage
let mut parcel_out = RawParcel::default();
relay_svc.transact_parcel(binder_id as i32, DEQUEUE_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
println!("{:?}", parcel_out);
let mut parcel_out = parcel_out.into_parcel_reader();
let slot = parcel_out.read_u32();
// Read fence
parcel_out.0.seek(SeekFrom::Current(44));
let status = parcel_out.read_u32();
if status != 0 {
println!("WTF: {}", status);
return Err(MyError::ParcelError(status));
}
slot
};
// Request buffer if it hasn't been requested already.
println!("Request buffer {}", slot);
{
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(slot); // Slot
let mut parcel_out = RawParcel::default();
let res = relay_svc.transact_parcel(binder_id as i32, REQUEST_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
let mut parcel_out = parcel_out.into_parcel_reader();
let non_null = parcel_out.read_u32() != 0;
if non_null {
let len = parcel_out.read_u32();
if len != 0x16c {
println!("Invalid length: {}", len);
return Ok(())
}
let unk = parcel_out.read_u32();
// TODO: Get graphicbuffer.
parcel_out.0.seek(SeekFrom::Current(0x16c));
}
let status = parcel_out.read_u32();
if status != 0 {
println!("WTF: {}", status);
return Err(MyError::ParcelError(status));
}
}
// Blit
println!("Blit");
{
fn pdep(mask: u32, mut value: u32) -> u32 {
let mut out = 0;
for shift in 0..32 {
let bit = 1 << shift;
if mask & bit != 0 {
if value & 1 != 0 {
out |= bit
}
value >>= 1;
}
}
out
}
fn swizzle_x(v: u32) -> u32 { pdep(!0x7B4, v) }
fn swizzle_y(v: u32) -> u32 { pdep(0x7B4, v) }
let x0 = 0;
let y0 = 0;
let mut offs_x0 = swizzle_x(x0);
let mut offs_y = swizzle_y(y0);
let x_mask = swizzle_x(!0);
let y_mask = swizzle_y(!0);
let incr_y = swizzle_x(128 * 10);
let tile_height = 128;
offs_x0 += incr_y * (y0 / tile_height);
// TODO: Add clipping.
for y in 0..frame.height() {
let mut offs_x = offs_x0;
for x in 0..frame.width() {
let pixel = frame.get_pixel(x, y);
mem[slot as usize][offs_y as usize + offs_x as usize] = LE::read_u32(pixel.channels());
offs_x = offs_x.wrapping_sub(x_mask) & x_mask;
}
offs_y = offs_y.wrapping_sub(y_mask) & y_mask;
if offs_y == 0 {
offs_x0 += incr_y; // wrap into next tile row
}
}
}
// Enqueue buffer
println!("Enqueue buffer");
{
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(slot); // Slot
parcel.write_u32(0x54); parcel.write_u32(0); // unknown, but always those values
parcel.write_u32(0x588bbba9); parcel.write_u32(0); // Timestamp, u64
parcel.write_u32(1); // unknown, but always those values
parcel.write_u32(0);
parcel.write_u32(0);
parcel.write_u32(0); // sometimes zero
parcel.write_u32(0);
parcel.write_u32(0);
parcel.write_u32(0); // Also seen 2
parcel.write_u32(0);
parcel.write_u32(0);
parcel.write_u32(1); // fence?
parcel.write_u32(1);
parcel.write_u32(0xa3);
parcel.write_u32(0);
parcel.write_u32(-1i32 as u32);
parcel.write_u32(0);
parcel.write_u32(-1i32 as u32);
parcel.write_u32(0);
parcel.write_u32(-1i32 as u32);
parcel.write_u32(0);
let mut parcel_out = RawParcel::default();
let res = relay_svc.transact_parcel(binder_id as i32, QUEUE_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
let mut parcel_out = parcel_out.into_parcel_reader();
println!("{:?}", QueueBufferOutput::from_parcel(&mut parcel_out));
let status = parcel_out.read_u32();
if status != 0 {
println!("WTF: {}", status);
return Err(MyError::ParcelError(status));
}
}
vevent.wait()?;
vevent.reset()?;
}
Ok(())
}
//static FERRIS : &'static [u8; 8] = [0, 0, 0, 0, 0, 0, 0, 0];
//static FERRIS: &'static [u8; 33061] = include_bytes!("../img/ferris.png");
static FERRIS: &'static [u8; 153718] = include_bytes!("../img/ferris.bmp");
// Graphic buffer stuff
//struct IGraphicBufferProducer(Arc<IHOSBinderDriver>, u32);
//
//impl IGraphicBufferProducer {
// pub fn dequeue_buffer(&self) {
//
// }
//}
//struct Display(Arc<IManagerDisplayService>, u64);
//
//impl Drop for Display {
// fn drop(&mut self) {
// self.0.close_display(self.1);
// }
//}
// TODO: Layer trait?
//struct ManagedLayer(Arc<IManagerDisplayService>, u64);
//
//impl Drop for ManagedLayer {
// fn drop(&mut self) {
// self.0.destroy_managed_layer(self.1);
// }
//}
/// Binder object in a parcel
#[repr(C)]
#[derive(Debug)]
struct FlatBinderObject {
ty: u32,
flags: u32,
inner: usize, // Can either be a void *binder or a u32 handle
cookie: usize
}
impl FlatBinderObject {
fn from_parcel(parcel: &mut ParcelReader) -> FlatBinderObject {
FlatBinderObject {
ty: parcel.read_u32(),
flags: parcel.read_u32(),
inner: parcel.read_u64() as usize,
cookie: parcel.read_u64() as usize
}
}
}
// Returned by igbp_connect
#[repr(C)]
#[derive(Debug)]
struct QueueBufferOutput {
width: u32,
height: u32,
transform_hint: u32,
num_pending_buffers: u32
}
impl QueueBufferOutput {
fn from_parcel(parcel: &mut ParcelReader) -> QueueBufferOutput {
let width = parcel.read_u32();
let height = parcel.read_u32();
let transform_hint = parcel.read_u32();
let num_pending_buffers = parcel.read_u32();
QueueBufferOutput {
width, height, transform_hint, num_pending_buffers
}
}
}
#[repr(C)]
struct GraphicBuffer<'a> {
width: u32,
height: u32,
stride: u32,
format: u32,
usage: u32,
gpu_buffer: &'a GpuBuffer,
index: u32,
offset_gpu_buffer: u32,
}
impl<'a> GraphicBuffer<'a> {
fn write_to_parcel(&self, parcel: &mut OwnedParcel) {
}
}
#[repr(C)]
struct GpuBuffer {
nvmap_handle: u32,
size: usize,
alignment: u32,
kind: u8
}
// nvmap stuff
#[repr(C, align(4096))]
struct BufferMemory([u32; 0x3c0000/4]);
impl std::ops::Deref for BufferMemory {
type Target = [u32];
fn | deref | identifier_name |
|
main.rs | , which is exactly what we're
// doing. In theory, because we never *read* the content of
// those, I believe this is, erm, "mostly OK" ? But I should
// find a better way to deal with it.
unsafe { std::slice::from_raw_parts(&create as *const NvMapIocCreateArgs as *const u8, std::mem::size_of::<NvMapIocCreateArgs>()) },
unsafe { std::slice::from_raw_parts_mut(&mut create as *mut NvMapIocCreateArgs as *mut u8, std::mem::size_of::<NvMapIocCreateArgs>()) })?;
if ret != 0 {
return Err(MyError::IoctlError(ret));
}
GpuBuffer {
nvmap_handle: create.handle,
size: mem.len() * std::mem::size_of::<BufferMemory>(),
alignment: 0x1000,
kind: 0
}
};
let buffers = {
let mut alloc = NvMapIocAllocArgs {
handle: gpu_buffer.nvmap_handle,
heapmask: 0,
flags: 0,
align: gpu_buffer.alignment,
kind: gpu_buffer.kind,
pad: [0; 7],
addr: mem.as_mut_ptr() as u64
};
println!("NVMAP_IOC_ALLOC {:?} ({:?})", alloc, unsafe { std::mem::transmute::<&NvMapIocAllocArgs, &[u8; std::mem::size_of::<NvMapIocAllocArgs>()]>(&alloc) });
let ret = nvdrv.ioctl(nvmap, NVMAP_IOC_ALLOC,
// TODO: This is unsafe. And illegal. Rust assumes aliasing
// doesn't happen with references, which is exactly what we're
// doing. In theory, because we never *read* the content of
// those, I believe this is, erm, "mostly OK" ? But I should
// find a better way to deal with it.
unsafe { std::slice::from_raw_parts(&alloc as *const NvMapIocAllocArgs as *const u8, std::mem::size_of::<NvMapIocAllocArgs>()) },
unsafe { std::slice::from_raw_parts_mut(&mut alloc as *mut NvMapIocAllocArgs as *mut u8, std::mem::size_of::<NvMapIocAllocArgs>()) })?;
if ret != 0 {
return Err(MyError::IoctlError(ret));
}
let mut buffers = Vec::with_capacity(3);
for i in 0..3 {
buffers.push(GraphicBuffer {
width: queue_buffer_output.width,
height: queue_buffer_output.height,
stride: queue_buffer_output.width,
format: 1, // RGBA_8888
usage: 0xb00, // TODO: Wat?
gpu_buffer: &gpu_buffer,
index: i,
offset_gpu_buffer: 0x3c0000 * i
});
}
buffers
};
println!("Tell IGBP about the buffers");
for (i, buf) in buffers.iter().enumerate() {
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(i as u32); // slot
parcel.write_u32(1); // Unknown
parcel.write_u32(0x16c); // Flattened GraphicsBuffer length
parcel.write_u32(0); // Unknown
buf.write_to_parcel(&mut parcel);
let mut parcel_out = RawParcel::default();
relay_svc.transact_parcel(binder_id as i32, SET_PREALLOCATED_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
println!("{:?}", parcel_out);
}
println!("Set scaling mode");
disp_svc.set_layer_scaling_mode(2, layer_id)?;
println!("Add layer to stack");
for stack in [0x0, 0x2, 0x4, 0x5, 0xA].iter() {
manager_disp_svc.add_to_layer_stack(*stack, layer_id)?;
}
println!("Set Z layer");
system_disp_svc.set_layer_z(layer_id, 2)?;
println!("Loading image from FERRIS");
let image = BMPDecoder::new(Cursor::new(&FERRIS[..]));
println!("Getting frame");
let frame = image.into_frames()?.next().unwrap().into_buffer();
//println!("Resizing FERRIS");
//let frame = image::imageops::resize(&image.into_frames()?.next().unwrap().into_buffer(), 1280, 760, image::FilterType::Lanczos3);
let vevent = unsafe { Event::from_kobject(disp_svc.get_display_vsync_event(display_id)?) };
for _ in 0..60 {
println!("Dequeue buffer");
let slot = {
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(1); // Pixel format
parcel.write_u32(1280); // width
parcel.write_u32(720); // height
parcel.write_u32(0); // get_frame_timestamp
parcel.write_u32(0xb00); // usage
let mut parcel_out = RawParcel::default();
relay_svc.transact_parcel(binder_id as i32, DEQUEUE_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
println!("{:?}", parcel_out);
let mut parcel_out = parcel_out.into_parcel_reader();
let slot = parcel_out.read_u32();
// Read fence
parcel_out.0.seek(SeekFrom::Current(44));
let status = parcel_out.read_u32();
if status != 0 {
println!("WTF: {}", status);
return Err(MyError::ParcelError(status));
}
slot
};
// Request buffer if it hasn't been requested already.
println!("Request buffer {}", slot);
{
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(slot); // Slot
let mut parcel_out = RawParcel::default();
let res = relay_svc.transact_parcel(binder_id as i32, REQUEST_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
let mut parcel_out = parcel_out.into_parcel_reader();
let non_null = parcel_out.read_u32() != 0;
if non_null {
let len = parcel_out.read_u32();
if len != 0x16c {
println!("Invalid length: {}", len);
return Ok(())
}
let unk = parcel_out.read_u32();
// TODO: Get graphicbuffer.
parcel_out.0.seek(SeekFrom::Current(0x16c));
}
let status = parcel_out.read_u32();
if status != 0 {
println!("WTF: {}", status);
return Err(MyError::ParcelError(status));
}
}
// Blit
println!("Blit");
{
fn pdep(mask: u32, mut value: u32) -> u32 {
let mut out = 0;
for shift in 0..32 {
let bit = 1 << shift;
if mask & bit != 0 {
if value & 1 != 0 {
out |= bit
}
value >>= 1;
}
}
out
}
fn swizzle_x(v: u32) -> u32 { pdep(!0x7B4, v) }
fn swizzle_y(v: u32) -> u32 { pdep(0x7B4, v) }
let x0 = 0;
let y0 = 0;
let mut offs_x0 = swizzle_x(x0);
let mut offs_y = swizzle_y(y0);
let x_mask = swizzle_x(!0);
let y_mask = swizzle_y(!0);
let incr_y = swizzle_x(128 * 10);
let tile_height = 128;
offs_x0 += incr_y * (y0 / tile_height);
// TODO: Add clipping.
for y in 0..frame.height() {
let mut offs_x = offs_x0;
for x in 0..frame.width() {
let pixel = frame.get_pixel(x, y);
mem[slot as usize][offs_y as usize + offs_x as usize] = LE::read_u32(pixel.channels());
offs_x = offs_x.wrapping_sub(x_mask) & x_mask;
}
offs_y = offs_y.wrapping_sub(y_mask) & y_mask;
if offs_y == 0 {
offs_x0 += incr_y; // wrap into next tile row
}
}
}
// Enqueue buffer
println!("Enqueue buffer");
{
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(slot); // Slot | random_line_split |
||
main.rs |
}
impl From<megaton_hammer::error::Error> for MyError {
fn from(err: megaton_hammer::error::Error) -> MyError {
MyError::MegatonError(err)
}
}
fn main() -> std::result::Result<(), MyError> {
// Let's get ferris to show up on my switch.
println!("Initialize NV");
let nvdrv = nns::nvdrv::INvDrvServices::new_nvdrv_a(|cb| {
println!("Create transfer memory");
let transfer_mem = TransferMemory::new(0x30000)?;
// TODO: Find a better way.
let temporary_process = unsafe { KObject::new(megaton_hammer::kernel::svc::CURRENT_PROCESS) };
let ret = cb(0x30000, &temporary_process, transfer_mem.as_ref());
unsafe { std::mem::forget(temporary_process); }
ret
})?;
println!("Open /dev/nvhost-as-gpu");
let (nvasgpu, err) = nvdrv.open(u8_slice_to_i8_slice(&b"/dev/nvhost-as-gpu"[..]))?;
if err != 0 {
panic!("Failed to open");
}
println!("Open /dev/nvmap");
let (nvmap, err) = nvdrv.open(u8_slice_to_i8_slice(&b"/dev/nvmap"[..]))?;
if err != 0 {
panic!("Failed to open");
}
println!("Initialize vi");
let vi_m = nn::visrv::sf::IManagerRootService::new()?;
println!("get_display_service");
let disp_svc = vi_m.get_display_service(1)?;
println!("get_relay_service");
let relay_svc = disp_svc.get_relay_service()?;
println!("get_system_display_service");
let system_disp_svc = disp_svc.get_system_display_service()?;
println!("get_manager_display_service");
let manager_disp_svc = disp_svc.get_manager_display_service()?;
println!("Open display");
let display_id = {
let mut display = [0u8; 64];
display[..b"Default".len()].copy_from_slice(b"Default");
disp_svc.open_display(display)?
};
println!("Open a layer");
let layer_id = manager_disp_svc.create_managed_layer(1, display_id, 0)?;
let binder_id = {
let mut parcel = RawParcel::default();
let mut display = [0u8; 64];
display[..b"Default".len()].copy_from_slice(b"Default");
let _window_size = disp_svc.open_layer(display, layer_id, 0, parcel.as_bytes_mut())?;
let mut reader = parcel.into_parcel_reader();
let fbo = FlatBinderObject::from_parcel(&mut reader);
let binder = fbo.inner as i32;
relay_svc.adjust_refcount(binder, 1, 0)?;
relay_svc.adjust_refcount(binder, 1, 1)?;
binder
};
// Connect to the IGBP. Take a look at the following link for reference.
// https://android.googlesource.com/platform/frameworks/native/+/e2786ea5aec3a12d948feb85ffbb535fc89c0fe6/libs/gui/IGraphicBufferProducer.cpp#297
println!("Connect to the IGBP");
let queue_buffer_output = {
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(0); // IProducerListener is null because we don't support it in MegatonHammer (nor in libt) yet.
parcel.write_u32(2); // API
parcel.write_u32(0); // ProducerControlledByApp.
let mut parcel_out = RawParcel::default();
relay_svc.transact_parcel(binder_id as i32, CONNECT, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
let mut reader = parcel_out.into_parcel_reader();
let qbo = QueueBufferOutput::from_parcel(&mut reader);
if reader.read_u32() != 0 {
println!("Failed to connect to igbp");
return Ok(());
}
qbo
};
println!("Allocate framebuffers");
let mut mem : Vec<BufferMemory> = Vec::with_capacity(3);
unsafe { mem.set_len(3); }
// Disables caching when talking to the gpu.
unsafe { svc::set_memory_attribute(mem.as_mut_ptr() as _, mem.len() * std::mem::size_of::<BufferMemory>(), 0x8, 0x8).expect("Failed to set memory attribute"); }
let gpu_buffer = {
let mut create = NvMapIocCreateArgs {
size: (mem.len() * std::mem::size_of::<BufferMemory>()) as u32,
handle: 0
};
println!("NVMAP_IOC_CREATE {:?} ({:?})", create, unsafe { std::mem::transmute::<&NvMapIocCreateArgs, &[u8; std::mem::size_of::<NvMapIocCreateArgs>()]>(&create) });
let ret = nvdrv.ioctl(nvmap, NVMAP_IOC_CREATE,
// TODO: This is unsafe. And illegal. Rust assumes aliasing
// doesn't happen with references, which is exactly what we're
// doing. In theory, because we never *read* the content of
// those, I believe this is, erm, "mostly OK" ? But I should
// find a better way to deal with it.
unsafe { std::slice::from_raw_parts(&create as *const NvMapIocCreateArgs as *const u8, std::mem::size_of::<NvMapIocCreateArgs>()) },
unsafe { std::slice::from_raw_parts_mut(&mut create as *mut NvMapIocCreateArgs as *mut u8, std::mem::size_of::<NvMapIocCreateArgs>()) })?;
if ret != 0 {
return Err(MyError::IoctlError(ret));
}
GpuBuffer {
nvmap_handle: create.handle,
size: mem.len() * std::mem::size_of::<BufferMemory>(),
alignment: 0x1000,
kind: 0
}
};
let buffers = {
let mut alloc = NvMapIocAllocArgs {
handle: gpu_buffer.nvmap_handle,
heapmask: 0,
flags: 0,
align: gpu_buffer.alignment,
kind: gpu_buffer.kind,
pad: [0; 7],
addr: mem.as_mut_ptr() as u64
};
println!("NVMAP_IOC_ALLOC {:?} ({:?})", alloc, unsafe { std::mem::transmute::<&NvMapIocAllocArgs, &[u8; std::mem::size_of::<NvMapIocAllocArgs>()]>(&alloc) });
let ret = nvdrv.ioctl(nvmap, NVMAP_IOC_ALLOC,
// TODO: This is unsafe. And illegal. Rust assumes aliasing
// doesn't happen with references, which is exactly what we're
// doing. In theory, because we never *read* the content of
// those, I believe this is, erm, "mostly OK" ? But I should
// find a better way to deal with it.
unsafe { std::slice::from_raw_parts(&alloc as *const NvMapIocAllocArgs as *const u8, std::mem::size_of::<NvMapIocAllocArgs>()) },
unsafe { std::slice::from_raw_parts_mut(&mut alloc as *mut NvMapIocAllocArgs as *mut u8, std::mem::size_of::<NvMapIocAllocArgs>()) })?;
if ret != 0 {
return Err(MyError::IoctlError(ret));
}
let mut buffers = Vec::with_capacity(3);
for i in 0..3 {
buffers.push(GraphicBuffer {
width: queue_buffer_output.width,
height: queue_buffer_output.height,
stride: queue_buffer_output.width,
format: 1, // RGBA_8888
usage: 0xb00, // TODO: Wat?
gpu_buffer: &gpu_buffer,
index: i,
offset_gpu_buffer: 0x3c0000 * i
});
}
buffers
};
println!("Tell IGBP about the buffers");
for (i, buf) in buffers.iter().enumerate() {
let mut parcel = OwnedParcel::new();
parcel.write_interface_token("android.gui.IGraphicBufferProducer");
parcel.write_u32(i as u32); // slot
parcel.write_u32(1); // Unknown
parcel.write_u32(0x16c); // Flattened GraphicsBuffer length
parcel.write_u32(0); // Unknown
buf.write_to_parcel(&mut parcel);
let mut parcel_out = RawParcel::default();
relay_svc.transact_parcel(binder_id as i32, SET_PREALLOCATED_BUFFER, 0, parcel.build().as_bytes(), parcel_out.as_bytes_mut())?;
println!("{ | {
MyError::ImageError(err)
} | identifier_body |
|
multi.rs | storage worker. Responses from the storage worker are
//! then serialized onto the session buffer.
use super::*;
use crate::poll::Poll;
use crate::QUEUE_RETRIES;
use common::signal::Signal;
use config::WorkerConfig;
use core::marker::PhantomData;
use core::time::Duration;
use entrystore::EntryStore;
use mio::event::Event;
use mio::{Events, Token, Waker};
use protocol_common::{Compose, Execute, Parse, ParseError};
use queues::TrackedItem;
use session::Session;
use std::io::{BufRead, Write};
use std::sync::Arc;
const WAKER_TOKEN: Token = Token(usize::MAX);
const STORAGE_THREAD_ID: usize = 0;
/// A builder for the request/response worker which communicates to the storage
/// thread over a queue.
pub struct MultiWorkerBuilder<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser, | _storage: PhantomData<Storage>,
_request: PhantomData<Request>,
_response: PhantomData<Response>,
}
impl<Storage, Parser, Request, Response> MultiWorkerBuilder<Storage, Parser, Request, Response> {
/// Create a new builder from the provided config and parser.
pub fn new<T: WorkerConfig>(config: &T, parser: Parser) -> Result<Self, std::io::Error> {
let poll = Poll::new().map_err(|e| {
error!("{}", e);
std::io::Error::new(std::io::ErrorKind::Other, "Failed to create epoll instance")
})?;
Ok(Self {
poll,
nevent: config.worker().nevent(),
timeout: Duration::from_millis(config.worker().timeout() as u64),
_request: PhantomData,
_response: PhantomData,
_storage: PhantomData,
parser,
})
}
/// Get the waker that is registered to the epoll instance.
pub(crate) fn waker(&self) -> Arc<Waker> {
self.poll.waker()
}
/// Converts the builder into a `MultiWorker` by providing the queues that
/// are necessary for communication between components.
pub fn build(
self,
signal_queue: Queues<(), Signal>,
session_queue: Queues<(), Session>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
) -> MultiWorker<Storage, Parser, Request, Response> {
MultiWorker {
nevent: self.nevent,
parser: self.parser,
poll: self.poll,
timeout: self.timeout,
signal_queue,
_storage: PhantomData,
storage_queue,
session_queue,
}
}
}
/// Represents a finalized request/response worker which is ready to be run.
pub struct MultiWorker<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser,
poll: Poll,
timeout: Duration,
session_queue: Queues<(), Session>,
signal_queue: Queues<(), Signal>,
_storage: PhantomData<Storage>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
}
impl<Storage, Parser, Request, Response> MultiWorker<Storage, Parser, Request, Response>
where
Parser: Parse<Request>,
Response: Compose,
Storage: Execute<Request, Response> + EntryStore,
{
/// Run the worker in a loop, handling new events.
pub fn run(&mut self) {
// these are buffers which are re-used in each loop iteration to receive
// events and queue messages
let mut events = Events::with_capacity(self.nevent);
let mut responses = Vec::with_capacity(QUEUE_CAPACITY);
let mut sessions = Vec::with_capacity(QUEUE_CAPACITY);
loop {
WORKER_EVENT_LOOP.increment();
// get events with timeout
if self.poll.poll(&mut events, self.timeout).is_err() {
error!("Error polling");
}
let timestamp = Instant::now();
let count = events.iter().count();
WORKER_EVENT_TOTAL.add(count as _);
if count == self.nevent {
WORKER_EVENT_MAX_REACHED.increment();
} else {
WORKER_EVENT_DEPTH.increment(timestamp, count as _, 1);
}
// process all events
for event in events.iter() {
match event.token() {
WAKER_TOKEN => {
self.handle_new_sessions(&mut sessions);
self.handle_storage_queue(&mut responses);
// check if we received any signals from the admin thread
while let Some(signal) =
self.signal_queue.try_recv().map(|v| v.into_inner())
{
match signal {
Signal::FlushAll => {}
Signal::Shutdown => {
// if we received a shutdown, we can return
// and stop processing events
return;
}
}
}
}
_ => {
self.handle_event(event, timestamp);
}
}
}
// wakes the storage thread if necessary
let _ = self.storage_queue.wake();
}
}
fn handle_event(&mut self, event: &Event, timestamp: Instant) {
let token = event.token();
// handle error events first
if event.is_error() {
WORKER_EVENT_ERROR.increment();
self.handle_error(token);
}
// handle write events before read events to reduce write buffer
// growth if there is also a readable event
if event.is_writable() {
WORKER_EVENT_WRITE.increment();
self.do_write(token);
}
// read events are handled last
if event.is_readable() {
WORKER_EVENT_READ.increment();
if let Ok(session) = self.poll.get_mut_session(token) {
session.set_timestamp(timestamp);
}
let _ = self.do_read(token);
}
if let Ok(session) = self.poll.get_mut_session(token) {
if session.read_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in read buffer",
session,
session.read_pending()
);
}
if session.write_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in write buffer",
session,
session.read_pending()
);
}
}
}
fn handle_session_read(&mut self, token: Token) -> Result<(), std::io::Error> {
let session = self.poll.get_mut_session(token)?;
match self.parser.parse(session.buffer()) {
Ok(request) => {
let consumed = request.consumed();
let request = request.into_inner();
trace!("parsed request for sesion: {:?}", session);
session.consume(consumed);
let mut message = TokenWrapper::new(request, token);
for retry in 0..QUEUE_RETRIES {
if let Err(m) = self.storage_queue.try_send_to(STORAGE_THREAD_ID, message) {
if (retry + 1) == QUEUE_RETRIES {
error!("queue full trying to send message to storage thread");
let _ = self.poll.close_session(token);
}
// try to wake storage thread
let _ = self.storage_queue.wake();
message = m;
} else {
break;
}
}
Ok(())
}
Err(ParseError::Incomplete) => {
trace!("incomplete request for session: {:?}", session);
Err(std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"incomplete request",
))
}
Err(_) => {
debug!("bad request for session: {:?}", session);
trace!("session: {:?} read buffer: {:?}", session, session.buffer());
let _ = self.poll.close_session(token);
Err(std::io::Error::new(
std::io::ErrorKind::Other,
"bad request",
))
}
}
}
fn handle_storage_queue(
&mut self,
responses: &mut Vec<TrackedItem<WrappedResult<Request, Response>>>,
) {
trace!("handling event for storage queue");
// process all storage queue responses
self.storage_queue.try_recv_all(responses);
for message in responses.drain(..).map(|v| v.into_inner()) {
let token = message.token();
let mut reregister = false;
if let Ok(session) = self.poll.get_mut_session(token) {
let result = message.into_inner();
trace!("composing response for session: {:?}", session);
result.compose(session);
session.finalize_response();
// if we have pending writes, we should attempt to flush the session
// now. if we still have pending bytes, we should re-register to
// remove the read interest.
if session.write_pending() > 0 {
let _ = session.flush();
if session.write_pending() > 0 {
reregister = true;
}
}
if session.read_pending() > 0 && self.handle_session_read(token).is_ok() {
let _ = self.storage_queue.wake();
}
}
if reregister {
self.poll.reregister(token);
}
}
let _ = self.storage_queue.wake();
}
fn handle_new_sessions(&mut self, sessions: &mut Vec<TrackedItem<Session>>) {
self.session_queue.try_recv_all(sessions);
for session in sessions.drain(..).map(|v| v.into_inner()) {
let pending = session.read_pending();
trace!(
"new session: {:?} with {} bytes pending in read buffer",
session,
pending
);
| poll: Poll,
timeout: Duration, | random_line_split |
multi.rs | worker. Responses from the storage worker are
//! then serialized onto the session buffer.
use super::*;
use crate::poll::Poll;
use crate::QUEUE_RETRIES;
use common::signal::Signal;
use config::WorkerConfig;
use core::marker::PhantomData;
use core::time::Duration;
use entrystore::EntryStore;
use mio::event::Event;
use mio::{Events, Token, Waker};
use protocol_common::{Compose, Execute, Parse, ParseError};
use queues::TrackedItem;
use session::Session;
use std::io::{BufRead, Write};
use std::sync::Arc;
const WAKER_TOKEN: Token = Token(usize::MAX);
const STORAGE_THREAD_ID: usize = 0;
/// A builder for the request/response worker which communicates to the storage
/// thread over a queue.
pub struct MultiWorkerBuilder<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser,
poll: Poll,
timeout: Duration,
_storage: PhantomData<Storage>,
_request: PhantomData<Request>,
_response: PhantomData<Response>,
}
impl<Storage, Parser, Request, Response> MultiWorkerBuilder<Storage, Parser, Request, Response> {
/// Create a new builder from the provided config and parser.
pub fn new<T: WorkerConfig>(config: &T, parser: Parser) -> Result<Self, std::io::Error> {
let poll = Poll::new().map_err(|e| {
error!("{}", e);
std::io::Error::new(std::io::ErrorKind::Other, "Failed to create epoll instance")
})?;
Ok(Self {
poll,
nevent: config.worker().nevent(),
timeout: Duration::from_millis(config.worker().timeout() as u64),
_request: PhantomData,
_response: PhantomData,
_storage: PhantomData,
parser,
})
}
/// Get the waker that is registered to the epoll instance.
pub(crate) fn waker(&self) -> Arc<Waker> {
self.poll.waker()
}
/// Converts the builder into a `MultiWorker` by providing the queues that
/// are necessary for communication between components.
pub fn build(
self,
signal_queue: Queues<(), Signal>,
session_queue: Queues<(), Session>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
) -> MultiWorker<Storage, Parser, Request, Response> {
MultiWorker {
nevent: self.nevent,
parser: self.parser,
poll: self.poll,
timeout: self.timeout,
signal_queue,
_storage: PhantomData,
storage_queue,
session_queue,
}
}
}
/// Represents a finalized request/response worker which is ready to be run.
pub struct MultiWorker<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser,
poll: Poll,
timeout: Duration,
session_queue: Queues<(), Session>,
signal_queue: Queues<(), Signal>,
_storage: PhantomData<Storage>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
}
impl<Storage, Parser, Request, Response> MultiWorker<Storage, Parser, Request, Response>
where
Parser: Parse<Request>,
Response: Compose,
Storage: Execute<Request, Response> + EntryStore,
{
/// Run the worker in a loop, handling new events.
pub fn run(&mut self) {
// these are buffers which are re-used in each loop iteration to receive
// events and queue messages
let mut events = Events::with_capacity(self.nevent);
let mut responses = Vec::with_capacity(QUEUE_CAPACITY);
let mut sessions = Vec::with_capacity(QUEUE_CAPACITY);
loop {
WORKER_EVENT_LOOP.increment();
// get events with timeout
if self.poll.poll(&mut events, self.timeout).is_err() {
error!("Error polling");
}
let timestamp = Instant::now();
let count = events.iter().count();
WORKER_EVENT_TOTAL.add(count as _);
if count == self.nevent {
WORKER_EVENT_MAX_REACHED.increment();
} else {
WORKER_EVENT_DEPTH.increment(timestamp, count as _, 1);
}
// process all events
for event in events.iter() {
match event.token() {
WAKER_TOKEN => {
self.handle_new_sessions(&mut sessions);
self.handle_storage_queue(&mut responses);
// check if we received any signals from the admin thread
while let Some(signal) =
self.signal_queue.try_recv().map(|v| v.into_inner())
{
match signal {
Signal::FlushAll => {}
Signal::Shutdown => {
// if we received a shutdown, we can return
// and stop processing events
return;
}
}
}
}
_ => {
self.handle_event(event, timestamp);
}
}
}
// wakes the storage thread if necessary
let _ = self.storage_queue.wake();
}
}
fn handle_event(&mut self, event: &Event, timestamp: Instant) {
let token = event.token();
// handle error events first
if event.is_error() |
// handle write events before read events to reduce write buffer
// growth if there is also a readable event
if event.is_writable() {
WORKER_EVENT_WRITE.increment();
self.do_write(token);
}
// read events are handled last
if event.is_readable() {
WORKER_EVENT_READ.increment();
if let Ok(session) = self.poll.get_mut_session(token) {
session.set_timestamp(timestamp);
}
let _ = self.do_read(token);
}
if let Ok(session) = self.poll.get_mut_session(token) {
if session.read_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in read buffer",
session,
session.read_pending()
);
}
if session.write_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in write buffer",
session,
session.read_pending()
);
}
}
}
fn handle_session_read(&mut self, token: Token) -> Result<(), std::io::Error> {
let session = self.poll.get_mut_session(token)?;
match self.parser.parse(session.buffer()) {
Ok(request) => {
let consumed = request.consumed();
let request = request.into_inner();
trace!("parsed request for sesion: {:?}", session);
session.consume(consumed);
let mut message = TokenWrapper::new(request, token);
for retry in 0..QUEUE_RETRIES {
if let Err(m) = self.storage_queue.try_send_to(STORAGE_THREAD_ID, message) {
if (retry + 1) == QUEUE_RETRIES {
error!("queue full trying to send message to storage thread");
let _ = self.poll.close_session(token);
}
// try to wake storage thread
let _ = self.storage_queue.wake();
message = m;
} else {
break;
}
}
Ok(())
}
Err(ParseError::Incomplete) => {
trace!("incomplete request for session: {:?}", session);
Err(std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"incomplete request",
))
}
Err(_) => {
debug!("bad request for session: {:?}", session);
trace!("session: {:?} read buffer: {:?}", session, session.buffer());
let _ = self.poll.close_session(token);
Err(std::io::Error::new(
std::io::ErrorKind::Other,
"bad request",
))
}
}
}
fn handle_storage_queue(
&mut self,
responses: &mut Vec<TrackedItem<WrappedResult<Request, Response>>>,
) {
trace!("handling event for storage queue");
// process all storage queue responses
self.storage_queue.try_recv_all(responses);
for message in responses.drain(..).map(|v| v.into_inner()) {
let token = message.token();
let mut reregister = false;
if let Ok(session) = self.poll.get_mut_session(token) {
let result = message.into_inner();
trace!("composing response for session: {:?}", session);
result.compose(session);
session.finalize_response();
// if we have pending writes, we should attempt to flush the session
// now. if we still have pending bytes, we should re-register to
// remove the read interest.
if session.write_pending() > 0 {
let _ = session.flush();
if session.write_pending() > 0 {
reregister = true;
}
}
if session.read_pending() > 0 && self.handle_session_read(token).is_ok() {
let _ = self.storage_queue.wake();
}
}
if reregister {
self.poll.reregister(token);
}
}
let _ = self.storage_queue.wake();
}
fn handle_new_sessions(&mut self, sessions: &mut Vec<TrackedItem<Session>>) {
self.session_queue.try_recv_all(sessions);
for session in sessions.drain(..).map(|v| v.into_inner()) {
let pending = session.read_pending();
trace!(
"new session: {:?} with {} bytes pending in read buffer",
session,
pending
| {
WORKER_EVENT_ERROR.increment();
self.handle_error(token);
} | conditional_block |
multi.rs | worker. Responses from the storage worker are
//! then serialized onto the session buffer.
use super::*;
use crate::poll::Poll;
use crate::QUEUE_RETRIES;
use common::signal::Signal;
use config::WorkerConfig;
use core::marker::PhantomData;
use core::time::Duration;
use entrystore::EntryStore;
use mio::event::Event;
use mio::{Events, Token, Waker};
use protocol_common::{Compose, Execute, Parse, ParseError};
use queues::TrackedItem;
use session::Session;
use std::io::{BufRead, Write};
use std::sync::Arc;
const WAKER_TOKEN: Token = Token(usize::MAX);
const STORAGE_THREAD_ID: usize = 0;
/// A builder for the request/response worker which communicates to the storage
/// thread over a queue.
pub struct MultiWorkerBuilder<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser,
poll: Poll,
timeout: Duration,
_storage: PhantomData<Storage>,
_request: PhantomData<Request>,
_response: PhantomData<Response>,
}
impl<Storage, Parser, Request, Response> MultiWorkerBuilder<Storage, Parser, Request, Response> {
/// Create a new builder from the provided config and parser.
pub fn new<T: WorkerConfig>(config: &T, parser: Parser) -> Result<Self, std::io::Error> {
let poll = Poll::new().map_err(|e| {
error!("{}", e);
std::io::Error::new(std::io::ErrorKind::Other, "Failed to create epoll instance")
})?;
Ok(Self {
poll,
nevent: config.worker().nevent(),
timeout: Duration::from_millis(config.worker().timeout() as u64),
_request: PhantomData,
_response: PhantomData,
_storage: PhantomData,
parser,
})
}
/// Get the waker that is registered to the epoll instance.
pub(crate) fn waker(&self) -> Arc<Waker> {
self.poll.waker()
}
/// Converts the builder into a `MultiWorker` by providing the queues that
/// are necessary for communication between components.
pub fn build(
self,
signal_queue: Queues<(), Signal>,
session_queue: Queues<(), Session>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
) -> MultiWorker<Storage, Parser, Request, Response> |
}
/// Represents a finalized request/response worker which is ready to be run.
pub struct MultiWorker<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser,
poll: Poll,
timeout: Duration,
session_queue: Queues<(), Session>,
signal_queue: Queues<(), Signal>,
_storage: PhantomData<Storage>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
}
impl<Storage, Parser, Request, Response> MultiWorker<Storage, Parser, Request, Response>
where
Parser: Parse<Request>,
Response: Compose,
Storage: Execute<Request, Response> + EntryStore,
{
/// Run the worker in a loop, handling new events.
pub fn run(&mut self) {
// these are buffers which are re-used in each loop iteration to receive
// events and queue messages
let mut events = Events::with_capacity(self.nevent);
let mut responses = Vec::with_capacity(QUEUE_CAPACITY);
let mut sessions = Vec::with_capacity(QUEUE_CAPACITY);
loop {
WORKER_EVENT_LOOP.increment();
// get events with timeout
if self.poll.poll(&mut events, self.timeout).is_err() {
error!("Error polling");
}
let timestamp = Instant::now();
let count = events.iter().count();
WORKER_EVENT_TOTAL.add(count as _);
if count == self.nevent {
WORKER_EVENT_MAX_REACHED.increment();
} else {
WORKER_EVENT_DEPTH.increment(timestamp, count as _, 1);
}
// process all events
for event in events.iter() {
match event.token() {
WAKER_TOKEN => {
self.handle_new_sessions(&mut sessions);
self.handle_storage_queue(&mut responses);
// check if we received any signals from the admin thread
while let Some(signal) =
self.signal_queue.try_recv().map(|v| v.into_inner())
{
match signal {
Signal::FlushAll => {}
Signal::Shutdown => {
// if we received a shutdown, we can return
// and stop processing events
return;
}
}
}
}
_ => {
self.handle_event(event, timestamp);
}
}
}
// wakes the storage thread if necessary
let _ = self.storage_queue.wake();
}
}
fn handle_event(&mut self, event: &Event, timestamp: Instant) {
let token = event.token();
// handle error events first
if event.is_error() {
WORKER_EVENT_ERROR.increment();
self.handle_error(token);
}
// handle write events before read events to reduce write buffer
// growth if there is also a readable event
if event.is_writable() {
WORKER_EVENT_WRITE.increment();
self.do_write(token);
}
// read events are handled last
if event.is_readable() {
WORKER_EVENT_READ.increment();
if let Ok(session) = self.poll.get_mut_session(token) {
session.set_timestamp(timestamp);
}
let _ = self.do_read(token);
}
if let Ok(session) = self.poll.get_mut_session(token) {
if session.read_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in read buffer",
session,
session.read_pending()
);
}
if session.write_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in write buffer",
session,
session.read_pending()
);
}
}
}
fn handle_session_read(&mut self, token: Token) -> Result<(), std::io::Error> {
let session = self.poll.get_mut_session(token)?;
match self.parser.parse(session.buffer()) {
Ok(request) => {
let consumed = request.consumed();
let request = request.into_inner();
trace!("parsed request for sesion: {:?}", session);
session.consume(consumed);
let mut message = TokenWrapper::new(request, token);
for retry in 0..QUEUE_RETRIES {
if let Err(m) = self.storage_queue.try_send_to(STORAGE_THREAD_ID, message) {
if (retry + 1) == QUEUE_RETRIES {
error!("queue full trying to send message to storage thread");
let _ = self.poll.close_session(token);
}
// try to wake storage thread
let _ = self.storage_queue.wake();
message = m;
} else {
break;
}
}
Ok(())
}
Err(ParseError::Incomplete) => {
trace!("incomplete request for session: {:?}", session);
Err(std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"incomplete request",
))
}
Err(_) => {
debug!("bad request for session: {:?}", session);
trace!("session: {:?} read buffer: {:?}", session, session.buffer());
let _ = self.poll.close_session(token);
Err(std::io::Error::new(
std::io::ErrorKind::Other,
"bad request",
))
}
}
}
fn handle_storage_queue(
&mut self,
responses: &mut Vec<TrackedItem<WrappedResult<Request, Response>>>,
) {
trace!("handling event for storage queue");
// process all storage queue responses
self.storage_queue.try_recv_all(responses);
for message in responses.drain(..).map(|v| v.into_inner()) {
let token = message.token();
let mut reregister = false;
if let Ok(session) = self.poll.get_mut_session(token) {
let result = message.into_inner();
trace!("composing response for session: {:?}", session);
result.compose(session);
session.finalize_response();
// if we have pending writes, we should attempt to flush the session
// now. if we still have pending bytes, we should re-register to
// remove the read interest.
if session.write_pending() > 0 {
let _ = session.flush();
if session.write_pending() > 0 {
reregister = true;
}
}
if session.read_pending() > 0 && self.handle_session_read(token).is_ok() {
let _ = self.storage_queue.wake();
}
}
if reregister {
self.poll.reregister(token);
}
}
let _ = self.storage_queue.wake();
}
fn handle_new_sessions(&mut self, sessions: &mut Vec<TrackedItem<Session>>) {
self.session_queue.try_recv_all(sessions);
for session in sessions.drain(..).map(|v| v.into_inner()) {
let pending = session.read_pending();
trace!(
"new session: {:?} with {} bytes pending in read buffer",
session,
pending
| {
MultiWorker {
nevent: self.nevent,
parser: self.parser,
poll: self.poll,
timeout: self.timeout,
signal_queue,
_storage: PhantomData,
storage_queue,
session_queue,
}
} | identifier_body |
multi.rs | storage worker. Responses from the storage worker are
//! then serialized onto the session buffer.
use super::*;
use crate::poll::Poll;
use crate::QUEUE_RETRIES;
use common::signal::Signal;
use config::WorkerConfig;
use core::marker::PhantomData;
use core::time::Duration;
use entrystore::EntryStore;
use mio::event::Event;
use mio::{Events, Token, Waker};
use protocol_common::{Compose, Execute, Parse, ParseError};
use queues::TrackedItem;
use session::Session;
use std::io::{BufRead, Write};
use std::sync::Arc;
const WAKER_TOKEN: Token = Token(usize::MAX);
const STORAGE_THREAD_ID: usize = 0;
/// A builder for the request/response worker which communicates to the storage
/// thread over a queue.
pub struct MultiWorkerBuilder<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser,
poll: Poll,
timeout: Duration,
_storage: PhantomData<Storage>,
_request: PhantomData<Request>,
_response: PhantomData<Response>,
}
impl<Storage, Parser, Request, Response> MultiWorkerBuilder<Storage, Parser, Request, Response> {
/// Create a new builder from the provided config and parser.
pub fn new<T: WorkerConfig>(config: &T, parser: Parser) -> Result<Self, std::io::Error> {
let poll = Poll::new().map_err(|e| {
error!("{}", e);
std::io::Error::new(std::io::ErrorKind::Other, "Failed to create epoll instance")
})?;
Ok(Self {
poll,
nevent: config.worker().nevent(),
timeout: Duration::from_millis(config.worker().timeout() as u64),
_request: PhantomData,
_response: PhantomData,
_storage: PhantomData,
parser,
})
}
/// Get the waker that is registered to the epoll instance.
pub(crate) fn waker(&self) -> Arc<Waker> {
self.poll.waker()
}
/// Converts the builder into a `MultiWorker` by providing the queues that
/// are necessary for communication between components.
pub fn build(
self,
signal_queue: Queues<(), Signal>,
session_queue: Queues<(), Session>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
) -> MultiWorker<Storage, Parser, Request, Response> {
MultiWorker {
nevent: self.nevent,
parser: self.parser,
poll: self.poll,
timeout: self.timeout,
signal_queue,
_storage: PhantomData,
storage_queue,
session_queue,
}
}
}
/// Represents a finalized request/response worker which is ready to be run.
pub struct MultiWorker<Storage, Parser, Request, Response> {
nevent: usize,
parser: Parser,
poll: Poll,
timeout: Duration,
session_queue: Queues<(), Session>,
signal_queue: Queues<(), Signal>,
_storage: PhantomData<Storage>,
storage_queue: Queues<TokenWrapper<Request>, WrappedResult<Request, Response>>,
}
impl<Storage, Parser, Request, Response> MultiWorker<Storage, Parser, Request, Response>
where
Parser: Parse<Request>,
Response: Compose,
Storage: Execute<Request, Response> + EntryStore,
{
/// Run the worker in a loop, handling new events.
pub fn run(&mut self) {
// these are buffers which are re-used in each loop iteration to receive
// events and queue messages
let mut events = Events::with_capacity(self.nevent);
let mut responses = Vec::with_capacity(QUEUE_CAPACITY);
let mut sessions = Vec::with_capacity(QUEUE_CAPACITY);
loop {
WORKER_EVENT_LOOP.increment();
// get events with timeout
if self.poll.poll(&mut events, self.timeout).is_err() {
error!("Error polling");
}
let timestamp = Instant::now();
let count = events.iter().count();
WORKER_EVENT_TOTAL.add(count as _);
if count == self.nevent {
WORKER_EVENT_MAX_REACHED.increment();
} else {
WORKER_EVENT_DEPTH.increment(timestamp, count as _, 1);
}
// process all events
for event in events.iter() {
match event.token() {
WAKER_TOKEN => {
self.handle_new_sessions(&mut sessions);
self.handle_storage_queue(&mut responses);
// check if we received any signals from the admin thread
while let Some(signal) =
self.signal_queue.try_recv().map(|v| v.into_inner())
{
match signal {
Signal::FlushAll => {}
Signal::Shutdown => {
// if we received a shutdown, we can return
// and stop processing events
return;
}
}
}
}
_ => {
self.handle_event(event, timestamp);
}
}
}
// wakes the storage thread if necessary
let _ = self.storage_queue.wake();
}
}
fn handle_event(&mut self, event: &Event, timestamp: Instant) {
let token = event.token();
// handle error events first
if event.is_error() {
WORKER_EVENT_ERROR.increment();
self.handle_error(token);
}
// handle write events before read events to reduce write buffer
// growth if there is also a readable event
if event.is_writable() {
WORKER_EVENT_WRITE.increment();
self.do_write(token);
}
// read events are handled last
if event.is_readable() {
WORKER_EVENT_READ.increment();
if let Ok(session) = self.poll.get_mut_session(token) {
session.set_timestamp(timestamp);
}
let _ = self.do_read(token);
}
if let Ok(session) = self.poll.get_mut_session(token) {
if session.read_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in read buffer",
session,
session.read_pending()
);
}
if session.write_pending() > 0 {
trace!(
"session: {:?} has {} bytes pending in write buffer",
session,
session.read_pending()
);
}
}
}
fn handle_session_read(&mut self, token: Token) -> Result<(), std::io::Error> {
let session = self.poll.get_mut_session(token)?;
match self.parser.parse(session.buffer()) {
Ok(request) => {
let consumed = request.consumed();
let request = request.into_inner();
trace!("parsed request for sesion: {:?}", session);
session.consume(consumed);
let mut message = TokenWrapper::new(request, token);
for retry in 0..QUEUE_RETRIES {
if let Err(m) = self.storage_queue.try_send_to(STORAGE_THREAD_ID, message) {
if (retry + 1) == QUEUE_RETRIES {
error!("queue full trying to send message to storage thread");
let _ = self.poll.close_session(token);
}
// try to wake storage thread
let _ = self.storage_queue.wake();
message = m;
} else {
break;
}
}
Ok(())
}
Err(ParseError::Incomplete) => {
trace!("incomplete request for session: {:?}", session);
Err(std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"incomplete request",
))
}
Err(_) => {
debug!("bad request for session: {:?}", session);
trace!("session: {:?} read buffer: {:?}", session, session.buffer());
let _ = self.poll.close_session(token);
Err(std::io::Error::new(
std::io::ErrorKind::Other,
"bad request",
))
}
}
}
fn handle_storage_queue(
&mut self,
responses: &mut Vec<TrackedItem<WrappedResult<Request, Response>>>,
) {
trace!("handling event for storage queue");
// process all storage queue responses
self.storage_queue.try_recv_all(responses);
for message in responses.drain(..).map(|v| v.into_inner()) {
let token = message.token();
let mut reregister = false;
if let Ok(session) = self.poll.get_mut_session(token) {
let result = message.into_inner();
trace!("composing response for session: {:?}", session);
result.compose(session);
session.finalize_response();
// if we have pending writes, we should attempt to flush the session
// now. if we still have pending bytes, we should re-register to
// remove the read interest.
if session.write_pending() > 0 {
let _ = session.flush();
if session.write_pending() > 0 {
reregister = true;
}
}
if session.read_pending() > 0 && self.handle_session_read(token).is_ok() {
let _ = self.storage_queue.wake();
}
}
if reregister {
self.poll.reregister(token);
}
}
let _ = self.storage_queue.wake();
}
fn | (&mut self, sessions: &mut Vec<TrackedItem<Session>>) {
self.session_queue.try_recv_all(sessions);
for session in sessions.drain(..).map(|v| v.into_inner()) {
let pending = session.read_pending();
trace!(
"new session: {:?} with {} bytes pending in read buffer",
session,
pending
| handle_new_sessions | identifier_name |
scanner.go | used if a match is returned
AddDescription(desc ServiceDescription) string
// Scan the IPv4 network for services matching given descriptions.
// Returns a map of IPs (string encoded) pointing to the IDs of those descriptions which matched
Scan() map[string][]string
// By default, after an IP is found with Scan it is ignored in future searches.
// Unlock instructs the scanner to include responses for that IP address in future scans.
Unlock(ip net.IP)
}
// A ServiceFoundNotification indicates that a service was found at ip IP which
// matched all of MatchingDescriptionIDs.
type ServiceFoundNotification struct {
IP net.IP
MatchingDescriptionIDs []string
}
// Scanner implements IScanner. It searches the IPv4 network for services
// matching given descriptions. Once services are found, they are locked and
// returned to the caller. It is up to the caller to unlock IPs (via Unlock())
// if they are no longer in use.
type Scanner struct {
interfaces map[string]net.Interface
ilock sync.RWMutex // protects interfaces
descriptionsByID map[string]ServiceDescription
dlock sync.RWMutex // protects descriptionsByID
activeServicesByIP map[string]struct{}
slock *sync.RWMutex // protects activeServicesByIP
log log.Logger
}
// NewScanner properly instantiates a Scanner.
func NewScanner() *Scanner {
s := &Scanner{
interfaces: make(map[string]net.Interface),
ilock: sync.RWMutex{},
descriptionsByID: make(map[string]ServiceDescription),
dlock: sync.RWMutex{},
activeServicesByIP: make(map[string]struct{}),
slock: &sync.RWMutex{},
log: Log.New("obj", "ipv4.scanner", "id", logext.RandId(8)),
}
err := s.refreshInterfaces()
if err != nil {
panic("ipv4.NewScanner(): scanner could not refresh interfaces: " + err.Error())
}
return s
}
// AddDescription adds a ServiceDescription to the Scanner. On following scans,
// the Scanner will find services which match the description.
func (s *Scanner) AddDescription(desc ServiceDescription) string {
s.dlock.Lock()
defer s.dlock.Unlock()
id := uuid.New()
s.descriptionsByID[id] = desc
return id
}
// Scan the IPv4 network for services matching given descriptions.
// Returns a map of IPs (string encoded) pointing to the IDs of those descriptions which matched
func (s *Scanner) Scan() map[string][]string | for _, a := range addrs {
switch v := a.(type) {
case *net.IPAddr:
s.log.Warn("ipv4 scanner got a *net.IPAddr, which isn't useful and maybe shoudln't happen?", "interface", intf.Name, "*net.IPAddr", v)
case *net.IPNet:
if v.IP.DefaultMask() != nil { // ignore IPs without default mask (IPv6?)
ip := v.IP
for ip := ip.Mask(v.Mask); v.Contains(ip); incrementIP(ip) {
wg.Add(1)
numChecked++
// To save space, try and only use 4 bytes
if x := ip.To4(); x != nil {
ip = x
}
dup := make(net.IP, len(ip)) // make a copy of the IP ([]byte)
copy(dup, ip)
go func() {
defer wg.Done()
s.slock.RLock()
_, ok := s.activeServicesByIP[dup.String()] // ignore IPs already in use
s.slock.RUnlock()
if ok { // ignore IPs already in use
s.log.Debug("scanner ignoring IP that is already in use", "ip", dup.String())
numAlreadyInUse++
} else {
ids := s.getMatchingDescriptions(dup)
if len(ids) > 0 { // At least one service matches
s.log.Debug("found possible matches for ipv4 service", "num_matches", len(ids), "matching_ids", ids)
numFound++
flock.Lock()
foundServices[dup.String()] = ids
flock.Unlock()
s.slock.Lock()
s.activeServicesByIP[dup.String()] = struct{}{} // mark IP as in use
s.slock.Unlock()
}
}
}()
}
}
default:
s.log.Warn("ipv4 scanner encountered address of unknown type", "type", fmt.Sprintf("%T", a))
}
}
}
s.log.Debug("ipv4 scanner waiting for waitgroup to finish")
wg.Wait()
s.log.Debug("ipv4 scanner done waiting (all waitgroup items completed)")
s.log.Info("ipv4 scan complete", "ips_checked", numChecked, "possibilities_found", numFound, "ips_already_in_use", numAlreadyInUse)
return foundServices
}
// Unlock unlocks the provided IP, such that it will no longer be ignored in
// future scans.
func (s *Scanner) Unlock(ip net.IP) {
s.slock.Lock()
defer s.slock.Unlock()
delete(s.activeServicesByIP, ip.String())
s.log.Debug("ipv4 scanner unlocked IP", "ip", ip.String())
}
func (s *Scanner) getMatchingDescriptions(ip net.IP) []string {
var matchedDrivers []string
matchedPorts := make(map[uint16]bool) // true if found open, false if not, nil key if untested
s.dlock.RLock()
defer s.dlock.RUnlock()
for id, desc := range s.descriptionsByID {
match := true
for _, port := range desc.OpenPorts {
// Try the cache first
if portIsOpen, ok := matchedPorts[port]; ok {
if !portIsOpen {
match = false
s.log.Debug("ipv4 scanner found a service description which is not a match for services available at the target IP, because a port which is expected to be open is closed (according to cache)", "ip", ip.String(), "description_id", id, "port", port, "desc_ports", desc.OpenPorts)
break
}
} else {
// No cached entry, try dialing
timeout := 1 * time.Second
url := ip.String() + ":" + strconv.Itoa(int(port))
conn, err := net.DialTimeout("tcp", url, timeout)
if err != nil {
match = false
matchedPorts[port] = false
s.log.Debug("ipv4 scanner found a service description which is not a match for the services available at the target IP, because a port which is expected to be open is closed (timed out trying)", "ip", ip.String(), "description_id", id, "port", port, "url", url, "timeout", timeout, "err", err, "desc_ports", desc.OpenPorts)
break
}
conn.Close()
}
}
if match {
matchedDrivers = append(matchedDrivers, id) // add
s.log.Debug("ipv4 scanner found a service description match", "ip", ip.String(), "service_desc", id)
}
}
return matchedDrivers
}
// refreshInterfaces searches the device for any new or removed network interfaces
func (s *Scanner) refreshInterfaces() error {
s.ilock.Lock() // Lock the interfaces for writing
defer s.ilock.Unlock()
ifaces, err := net.Interfaces()
if err != nil {
return fmt.Errorf("error while refreshing ipv4 interfaces: %v", err)
}
foundInterfaces := make(map[string]net.Interface)
newInterfaces := make(map[string]struct{})
for _, iface := range ifaces {
name := iface.Name
if _, ok := ignoredIPv4Interfaces[name]; !ok { // ignore certain interfaces
foundInterfaces[name] = iface
if _, ok := s.interfaces[name]; !ok {
newInterfaces[name] = struct{}{}
}
delete(s.interfaces, name) // unmark the interface - anything left once we're done has disappeared
}
}
if len(s.interfaces) > 0 {
names := make([]string, len(s.interfaces))
i := 0
for name := range s.interfaces {
names[i] = name
}
s.log.Warn("STUB: IPv4 interfaces have disappeared, but handling logic is unimplemented! Services on the missing interfaces may still be active", "deleted_interfaces", names)
}
s.interfaces = foundInterfaces
if len(newInterfaces) > 0 {
names := make([]string, len(newInterfaces))
i := 0
for name := range newInterfaces {
names[i] = name | {
if len(s.descriptionsByID) == 0 {
s.log.Debug("scanner has no descriptions, ignoring scan")
return map[string][]string{}
}
s.log.Debug("ip4v scanner beginning scan", "interfaces", s.interfaces, "target_descriptions", s.descriptionsByID)
foundServices := make(map[string][]string)
flock := sync.Mutex{} // protects foundServices
var wg sync.WaitGroup
var numChecked, numFound, numAlreadyInUse int
s.ilock.RLock()
defer s.ilock.RUnlock()
for name, intf := range s.interfaces {
addrs, err := intf.Addrs()
if err != nil {
panic("could not get addresses from " + name + ": " + err.Error())
}
s.log.Debug("ip4v scanner scanning interface", "interface", name, "num_addrs", len(addrs)) | identifier_body |
scanner.go | used if a match is returned
AddDescription(desc ServiceDescription) string
// Scan the IPv4 network for services matching given descriptions.
// Returns a map of IPs (string encoded) pointing to the IDs of those descriptions which matched
Scan() map[string][]string
// By default, after an IP is found with Scan it is ignored in future searches.
// Unlock instructs the scanner to include responses for that IP address in future scans.
Unlock(ip net.IP)
}
// A ServiceFoundNotification indicates that a service was found at ip IP which
// matched all of MatchingDescriptionIDs.
type ServiceFoundNotification struct {
IP net.IP
MatchingDescriptionIDs []string
}
// Scanner implements IScanner. It searches the IPv4 network for services
// matching given descriptions. Once services are found, they are locked and
// returned to the caller. It is up to the caller to unlock IPs (via Unlock())
// if they are no longer in use.
type Scanner struct {
interfaces map[string]net.Interface
ilock sync.RWMutex // protects interfaces
descriptionsByID map[string]ServiceDescription
dlock sync.RWMutex // protects descriptionsByID
activeServicesByIP map[string]struct{}
slock *sync.RWMutex // protects activeServicesByIP
log log.Logger
}
// NewScanner properly instantiates a Scanner.
func NewScanner() *Scanner {
s := &Scanner{
interfaces: make(map[string]net.Interface),
ilock: sync.RWMutex{},
descriptionsByID: make(map[string]ServiceDescription),
dlock: sync.RWMutex{},
activeServicesByIP: make(map[string]struct{}),
slock: &sync.RWMutex{},
log: Log.New("obj", "ipv4.scanner", "id", logext.RandId(8)),
}
err := s.refreshInterfaces()
if err != nil {
panic("ipv4.NewScanner(): scanner could not refresh interfaces: " + err.Error())
}
return s
}
// AddDescription adds a ServiceDescription to the Scanner. On following scans,
// the Scanner will find services which match the description.
func (s *Scanner) AddDescription(desc ServiceDescription) string {
s.dlock.Lock()
defer s.dlock.Unlock()
id := uuid.New()
s.descriptionsByID[id] = desc
return id
}
// Scan the IPv4 network for services matching given descriptions.
// Returns a map of IPs (string encoded) pointing to the IDs of those descriptions which matched
func (s *Scanner) Scan() map[string][]string {
if len(s.descriptionsByID) == 0 {
s.log.Debug("scanner has no descriptions, ignoring scan")
return map[string][]string{}
}
s.log.Debug("ip4v scanner beginning scan", "interfaces", s.interfaces, "target_descriptions", s.descriptionsByID)
foundServices := make(map[string][]string)
flock := sync.Mutex{} // protects foundServices
var wg sync.WaitGroup
var numChecked, numFound, numAlreadyInUse int
s.ilock.RLock()
defer s.ilock.RUnlock()
for name, intf := range s.interfaces {
addrs, err := intf.Addrs()
if err != nil {
panic("could not get addresses from " + name + ": " + err.Error())
}
s.log.Debug("ip4v scanner scanning interface", "interface", name, "num_addrs", len(addrs))
for _, a := range addrs {
switch v := a.(type) {
case *net.IPAddr:
s.log.Warn("ipv4 scanner got a *net.IPAddr, which isn't useful and maybe shoudln't happen?", "interface", intf.Name, "*net.IPAddr", v)
case *net.IPNet:
if v.IP.DefaultMask() != nil { // ignore IPs without default mask (IPv6?)
ip := v.IP
for ip := ip.Mask(v.Mask); v.Contains(ip); incrementIP(ip) {
wg.Add(1)
numChecked++
// To save space, try and only use 4 bytes
if x := ip.To4(); x != nil {
ip = x
}
dup := make(net.IP, len(ip)) // make a copy of the IP ([]byte)
copy(dup, ip)
go func() {
defer wg.Done()
s.slock.RLock()
_, ok := s.activeServicesByIP[dup.String()] // ignore IPs already in use
s.slock.RUnlock()
if ok { // ignore IPs already in use
s.log.Debug("scanner ignoring IP that is already in use", "ip", dup.String())
numAlreadyInUse++
} else {
ids := s.getMatchingDescriptions(dup)
if len(ids) > 0 { // At least one service matches
s.log.Debug("found possible matches for ipv4 service", "num_matches", len(ids), "matching_ids", ids)
numFound++
flock.Lock()
foundServices[dup.String()] = ids
flock.Unlock()
s.slock.Lock()
s.activeServicesByIP[dup.String()] = struct{}{} // mark IP as in use
s.slock.Unlock()
}
}
}()
}
}
default:
s.log.Warn("ipv4 scanner encountered address of unknown type", "type", fmt.Sprintf("%T", a))
}
}
}
s.log.Debug("ipv4 scanner waiting for waitgroup to finish")
wg.Wait()
s.log.Debug("ipv4 scanner done waiting (all waitgroup items completed)")
s.log.Info("ipv4 scan complete", "ips_checked", numChecked, "possibilities_found", numFound, "ips_already_in_use", numAlreadyInUse)
return foundServices
}
// Unlock unlocks the provided IP, such that it will no longer be ignored in
// future scans.
func (s *Scanner) Unlock(ip net.IP) {
s.slock.Lock()
defer s.slock.Unlock()
delete(s.activeServicesByIP, ip.String())
s.log.Debug("ipv4 scanner unlocked IP", "ip", ip.String())
}
func (s *Scanner) getMatchingDescriptions(ip net.IP) []string {
var matchedDrivers []string
matchedPorts := make(map[uint16]bool) // true if found open, false if not, nil key if untested
s.dlock.RLock()
defer s.dlock.RUnlock()
for id, desc := range s.descriptionsByID {
match := true
for _, port := range desc.OpenPorts {
// Try the cache first
if portIsOpen, ok := matchedPorts[port]; ok {
if !portIsOpen {
match = false
s.log.Debug("ipv4 scanner found a service description which is not a match for services available at the target IP, because a port which is expected to be open is closed (according to cache)", "ip", ip.String(), "description_id", id, "port", port, "desc_ports", desc.OpenPorts)
break
}
} else {
// No cached entry, try dialing
timeout := 1 * time.Second
url := ip.String() + ":" + strconv.Itoa(int(port))
conn, err := net.DialTimeout("tcp", url, timeout)
if err != nil {
match = false
matchedPorts[port] = false
s.log.Debug("ipv4 scanner found a service description which is not a match for the services available at the target IP, because a port which is expected to be open is closed (timed out trying)", "ip", ip.String(), "description_id", id, "port", port, "url", url, "timeout", timeout, "err", err, "desc_ports", desc.OpenPorts)
break
}
conn.Close()
}
}
if match {
matchedDrivers = append(matchedDrivers, id) // add
s.log.Debug("ipv4 scanner found a service description match", "ip", ip.String(), "service_desc", id)
}
}
return matchedDrivers
}
// refreshInterfaces searches the device for any new or removed network interfaces
func (s *Scanner) refreshInterfaces() error {
s.ilock.Lock() // Lock the interfaces for writing
defer s.ilock.Unlock()
ifaces, err := net.Interfaces()
if err != nil {
return fmt.Errorf("error while refreshing ipv4 interfaces: %v", err)
}
foundInterfaces := make(map[string]net.Interface)
newInterfaces := make(map[string]struct{})
for _, iface := range ifaces {
name := iface.Name
if _, ok := ignoredIPv4Interfaces[name]; !ok { // ignore certain interfaces
foundInterfaces[name] = iface
if _, ok := s.interfaces[name]; !ok {
newInterfaces[name] = struct{}{}
}
delete(s.interfaces, name) // unmark the interface - anything left once we're done has disappeared
}
}
if len(s.interfaces) > 0 |
s.interfaces = foundInterfaces
if len(newInterfaces) > 0 {
names := make([]string, len(newInterfaces))
i := 0
for name := range newInterfaces {
names[i] = | {
names := make([]string, len(s.interfaces))
i := 0
for name := range s.interfaces {
names[i] = name
}
s.log.Warn("STUB: IPv4 interfaces have disappeared, but handling logic is unimplemented! Services on the missing interfaces may still be active", "deleted_interfaces", names)
} | conditional_block |
scanner.go | // Unlock instructs the scanner to include responses for that IP address in future scans.
Unlock(ip net.IP)
}
// A ServiceFoundNotification indicates that a service was found at ip IP which
// matched all of MatchingDescriptionIDs.
type ServiceFoundNotification struct {
IP net.IP
MatchingDescriptionIDs []string
}
// Scanner implements IScanner. It searches the IPv4 network for services
// matching given descriptions. Once services are found, they are locked and
// returned to the caller. It is up to the caller to unlock IPs (via Unlock())
// if they are no longer in use.
type Scanner struct {
interfaces map[string]net.Interface
ilock sync.RWMutex // protects interfaces
descriptionsByID map[string]ServiceDescription
dlock sync.RWMutex // protects descriptionsByID
activeServicesByIP map[string]struct{}
slock *sync.RWMutex // protects activeServicesByIP
log log.Logger
}
// NewScanner properly instantiates a Scanner.
func NewScanner() *Scanner {
s := &Scanner{
interfaces: make(map[string]net.Interface),
ilock: sync.RWMutex{},
descriptionsByID: make(map[string]ServiceDescription),
dlock: sync.RWMutex{},
activeServicesByIP: make(map[string]struct{}),
slock: &sync.RWMutex{},
log: Log.New("obj", "ipv4.scanner", "id", logext.RandId(8)),
}
err := s.refreshInterfaces()
if err != nil {
panic("ipv4.NewScanner(): scanner could not refresh interfaces: " + err.Error())
}
return s
}
// AddDescription adds a ServiceDescription to the Scanner. On following scans,
// the Scanner will find services which match the description.
func (s *Scanner) AddDescription(desc ServiceDescription) string {
s.dlock.Lock()
defer s.dlock.Unlock()
id := uuid.New()
s.descriptionsByID[id] = desc
return id
}
// Scan the IPv4 network for services matching given descriptions.
// Returns a map of IPs (string encoded) pointing to the IDs of those descriptions which matched
func (s *Scanner) Scan() map[string][]string {
if len(s.descriptionsByID) == 0 {
s.log.Debug("scanner has no descriptions, ignoring scan")
return map[string][]string{}
}
s.log.Debug("ip4v scanner beginning scan", "interfaces", s.interfaces, "target_descriptions", s.descriptionsByID)
foundServices := make(map[string][]string)
flock := sync.Mutex{} // protects foundServices
var wg sync.WaitGroup
var numChecked, numFound, numAlreadyInUse int
s.ilock.RLock()
defer s.ilock.RUnlock()
for name, intf := range s.interfaces {
addrs, err := intf.Addrs()
if err != nil {
panic("could not get addresses from " + name + ": " + err.Error())
}
s.log.Debug("ip4v scanner scanning interface", "interface", name, "num_addrs", len(addrs))
for _, a := range addrs {
switch v := a.(type) {
case *net.IPAddr:
s.log.Warn("ipv4 scanner got a *net.IPAddr, which isn't useful and maybe shoudln't happen?", "interface", intf.Name, "*net.IPAddr", v)
case *net.IPNet:
if v.IP.DefaultMask() != nil { // ignore IPs without default mask (IPv6?)
ip := v.IP
for ip := ip.Mask(v.Mask); v.Contains(ip); incrementIP(ip) {
wg.Add(1)
numChecked++
// To save space, try and only use 4 bytes
if x := ip.To4(); x != nil {
ip = x
}
dup := make(net.IP, len(ip)) // make a copy of the IP ([]byte)
copy(dup, ip)
go func() {
defer wg.Done()
s.slock.RLock()
_, ok := s.activeServicesByIP[dup.String()] // ignore IPs already in use
s.slock.RUnlock()
if ok { // ignore IPs already in use
s.log.Debug("scanner ignoring IP that is already in use", "ip", dup.String())
numAlreadyInUse++
} else {
ids := s.getMatchingDescriptions(dup)
if len(ids) > 0 { // At least one service matches
s.log.Debug("found possible matches for ipv4 service", "num_matches", len(ids), "matching_ids", ids)
numFound++
flock.Lock()
foundServices[dup.String()] = ids
flock.Unlock()
s.slock.Lock()
s.activeServicesByIP[dup.String()] = struct{}{} // mark IP as in use
s.slock.Unlock()
}
}
}()
}
}
default:
s.log.Warn("ipv4 scanner encountered address of unknown type", "type", fmt.Sprintf("%T", a))
}
}
}
s.log.Debug("ipv4 scanner waiting for waitgroup to finish")
wg.Wait()
s.log.Debug("ipv4 scanner done waiting (all waitgroup items completed)")
s.log.Info("ipv4 scan complete", "ips_checked", numChecked, "possibilities_found", numFound, "ips_already_in_use", numAlreadyInUse)
return foundServices
}
// Unlock unlocks the provided IP, such that it will no longer be ignored in
// future scans.
func (s *Scanner) Unlock(ip net.IP) {
s.slock.Lock()
defer s.slock.Unlock()
delete(s.activeServicesByIP, ip.String())
s.log.Debug("ipv4 scanner unlocked IP", "ip", ip.String())
}
func (s *Scanner) getMatchingDescriptions(ip net.IP) []string {
var matchedDrivers []string
matchedPorts := make(map[uint16]bool) // true if found open, false if not, nil key if untested
s.dlock.RLock()
defer s.dlock.RUnlock()
for id, desc := range s.descriptionsByID {
match := true
for _, port := range desc.OpenPorts {
// Try the cache first
if portIsOpen, ok := matchedPorts[port]; ok {
if !portIsOpen {
match = false
s.log.Debug("ipv4 scanner found a service description which is not a match for services available at the target IP, because a port which is expected to be open is closed (according to cache)", "ip", ip.String(), "description_id", id, "port", port, "desc_ports", desc.OpenPorts)
break
}
} else {
// No cached entry, try dialing
timeout := 1 * time.Second
url := ip.String() + ":" + strconv.Itoa(int(port))
conn, err := net.DialTimeout("tcp", url, timeout)
if err != nil {
match = false
matchedPorts[port] = false
s.log.Debug("ipv4 scanner found a service description which is not a match for the services available at the target IP, because a port which is expected to be open is closed (timed out trying)", "ip", ip.String(), "description_id", id, "port", port, "url", url, "timeout", timeout, "err", err, "desc_ports", desc.OpenPorts)
break
}
conn.Close()
}
}
if match {
matchedDrivers = append(matchedDrivers, id) // add
s.log.Debug("ipv4 scanner found a service description match", "ip", ip.String(), "service_desc", id)
}
}
return matchedDrivers
}
// refreshInterfaces searches the device for any new or removed network interfaces
func (s *Scanner) refreshInterfaces() error {
s.ilock.Lock() // Lock the interfaces for writing
defer s.ilock.Unlock()
ifaces, err := net.Interfaces()
if err != nil {
return fmt.Errorf("error while refreshing ipv4 interfaces: %v", err)
}
foundInterfaces := make(map[string]net.Interface)
newInterfaces := make(map[string]struct{})
for _, iface := range ifaces {
name := iface.Name
if _, ok := ignoredIPv4Interfaces[name]; !ok { // ignore certain interfaces
foundInterfaces[name] = iface
if _, ok := s.interfaces[name]; !ok {
newInterfaces[name] = struct{}{}
}
delete(s.interfaces, name) // unmark the interface - anything left once we're done has disappeared
}
}
if len(s.interfaces) > 0 {
names := make([]string, len(s.interfaces))
i := 0
for name := range s.interfaces {
names[i] = name
}
s.log.Warn("STUB: IPv4 interfaces have disappeared, but handling logic is unimplemented! Services on the missing interfaces may still be active", "deleted_interfaces", names)
}
s.interfaces = foundInterfaces
if len(newInterfaces) > 0 {
names := make([]string, len(newInterfaces))
i := 0
for name := range newInterfaces {
names[i] = name
i++
}
s.log.Debug("new IPv4 interfaces found", "interfaces", names)
}
return nil
}
// incrementIP increments an IPv4 address | func incrementIP(ip net.IP) {
for j := len(ip) - 1; j >= 0; j-- {
ip[j]++
if ip[j] > 0 { | random_line_split |
|
scanner.go | [string]net.Interface),
ilock: sync.RWMutex{},
descriptionsByID: make(map[string]ServiceDescription),
dlock: sync.RWMutex{},
activeServicesByIP: make(map[string]struct{}),
slock: &sync.RWMutex{},
log: Log.New("obj", "ipv4.scanner", "id", logext.RandId(8)),
}
err := s.refreshInterfaces()
if err != nil {
panic("ipv4.NewScanner(): scanner could not refresh interfaces: " + err.Error())
}
return s
}
// AddDescription adds a ServiceDescription to the Scanner. On following scans,
// the Scanner will find services which match the description.
func (s *Scanner) AddDescription(desc ServiceDescription) string {
s.dlock.Lock()
defer s.dlock.Unlock()
id := uuid.New()
s.descriptionsByID[id] = desc
return id
}
// Scan the IPv4 network for services matching given descriptions.
// Returns a map of IPs (string encoded) pointing to the IDs of those descriptions which matched
func (s *Scanner) Scan() map[string][]string {
if len(s.descriptionsByID) == 0 {
s.log.Debug("scanner has no descriptions, ignoring scan")
return map[string][]string{}
}
s.log.Debug("ip4v scanner beginning scan", "interfaces", s.interfaces, "target_descriptions", s.descriptionsByID)
foundServices := make(map[string][]string)
flock := sync.Mutex{} // protects foundServices
var wg sync.WaitGroup
var numChecked, numFound, numAlreadyInUse int
s.ilock.RLock()
defer s.ilock.RUnlock()
for name, intf := range s.interfaces {
addrs, err := intf.Addrs()
if err != nil {
panic("could not get addresses from " + name + ": " + err.Error())
}
s.log.Debug("ip4v scanner scanning interface", "interface", name, "num_addrs", len(addrs))
for _, a := range addrs {
switch v := a.(type) {
case *net.IPAddr:
s.log.Warn("ipv4 scanner got a *net.IPAddr, which isn't useful and maybe shoudln't happen?", "interface", intf.Name, "*net.IPAddr", v)
case *net.IPNet:
if v.IP.DefaultMask() != nil { // ignore IPs without default mask (IPv6?)
ip := v.IP
for ip := ip.Mask(v.Mask); v.Contains(ip); incrementIP(ip) {
wg.Add(1)
numChecked++
// To save space, try and only use 4 bytes
if x := ip.To4(); x != nil {
ip = x
}
dup := make(net.IP, len(ip)) // make a copy of the IP ([]byte)
copy(dup, ip)
go func() {
defer wg.Done()
s.slock.RLock()
_, ok := s.activeServicesByIP[dup.String()] // ignore IPs already in use
s.slock.RUnlock()
if ok { // ignore IPs already in use
s.log.Debug("scanner ignoring IP that is already in use", "ip", dup.String())
numAlreadyInUse++
} else {
ids := s.getMatchingDescriptions(dup)
if len(ids) > 0 { // At least one service matches
s.log.Debug("found possible matches for ipv4 service", "num_matches", len(ids), "matching_ids", ids)
numFound++
flock.Lock()
foundServices[dup.String()] = ids
flock.Unlock()
s.slock.Lock()
s.activeServicesByIP[dup.String()] = struct{}{} // mark IP as in use
s.slock.Unlock()
}
}
}()
}
}
default:
s.log.Warn("ipv4 scanner encountered address of unknown type", "type", fmt.Sprintf("%T", a))
}
}
}
s.log.Debug("ipv4 scanner waiting for waitgroup to finish")
wg.Wait()
s.log.Debug("ipv4 scanner done waiting (all waitgroup items completed)")
s.log.Info("ipv4 scan complete", "ips_checked", numChecked, "possibilities_found", numFound, "ips_already_in_use", numAlreadyInUse)
return foundServices
}
// Unlock unlocks the provided IP, such that it will no longer be ignored in
// future scans.
func (s *Scanner) Unlock(ip net.IP) {
s.slock.Lock()
defer s.slock.Unlock()
delete(s.activeServicesByIP, ip.String())
s.log.Debug("ipv4 scanner unlocked IP", "ip", ip.String())
}
func (s *Scanner) getMatchingDescriptions(ip net.IP) []string {
var matchedDrivers []string
matchedPorts := make(map[uint16]bool) // true if found open, false if not, nil key if untested
s.dlock.RLock()
defer s.dlock.RUnlock()
for id, desc := range s.descriptionsByID {
match := true
for _, port := range desc.OpenPorts {
// Try the cache first
if portIsOpen, ok := matchedPorts[port]; ok {
if !portIsOpen {
match = false
s.log.Debug("ipv4 scanner found a service description which is not a match for services available at the target IP, because a port which is expected to be open is closed (according to cache)", "ip", ip.String(), "description_id", id, "port", port, "desc_ports", desc.OpenPorts)
break
}
} else {
// No cached entry, try dialing
timeout := 1 * time.Second
url := ip.String() + ":" + strconv.Itoa(int(port))
conn, err := net.DialTimeout("tcp", url, timeout)
if err != nil {
match = false
matchedPorts[port] = false
s.log.Debug("ipv4 scanner found a service description which is not a match for the services available at the target IP, because a port which is expected to be open is closed (timed out trying)", "ip", ip.String(), "description_id", id, "port", port, "url", url, "timeout", timeout, "err", err, "desc_ports", desc.OpenPorts)
break
}
conn.Close()
}
}
if match {
matchedDrivers = append(matchedDrivers, id) // add
s.log.Debug("ipv4 scanner found a service description match", "ip", ip.String(), "service_desc", id)
}
}
return matchedDrivers
}
// refreshInterfaces searches the device for any new or removed network interfaces
func (s *Scanner) refreshInterfaces() error {
s.ilock.Lock() // Lock the interfaces for writing
defer s.ilock.Unlock()
ifaces, err := net.Interfaces()
if err != nil {
return fmt.Errorf("error while refreshing ipv4 interfaces: %v", err)
}
foundInterfaces := make(map[string]net.Interface)
newInterfaces := make(map[string]struct{})
for _, iface := range ifaces {
name := iface.Name
if _, ok := ignoredIPv4Interfaces[name]; !ok { // ignore certain interfaces
foundInterfaces[name] = iface
if _, ok := s.interfaces[name]; !ok {
newInterfaces[name] = struct{}{}
}
delete(s.interfaces, name) // unmark the interface - anything left once we're done has disappeared
}
}
if len(s.interfaces) > 0 {
names := make([]string, len(s.interfaces))
i := 0
for name := range s.interfaces {
names[i] = name
}
s.log.Warn("STUB: IPv4 interfaces have disappeared, but handling logic is unimplemented! Services on the missing interfaces may still be active", "deleted_interfaces", names)
}
s.interfaces = foundInterfaces
if len(newInterfaces) > 0 {
names := make([]string, len(newInterfaces))
i := 0
for name := range newInterfaces {
names[i] = name
i++
}
s.log.Debug("new IPv4 interfaces found", "interfaces", names)
}
return nil
}
// incrementIP increments an IPv4 address
func incrementIP(ip net.IP) {
for j := len(ip) - 1; j >= 0; j-- {
ip[j]++
if ip[j] > 0 {
break
}
}
}
// An IContinuousScanner is a Scanner that scans continuously. Scan results are
// passed to the channel provided by FoundServices()
type IContinuousScanner interface {
suture.Service
IScanner
FoundServices() chan ServiceFoundNotification
}
// ContinuousScanner implements IContinuousScanner. It scans continuously,
// putting results into the channel provided by FoundServices().
type ContinuousScanner struct {
*Scanner
foundIPChan chan ServiceFoundNotification
period time.Duration
stop chan struct{}
}
// NewContinousScanner properly instantiates a ContinuousScanner. The new
// Scanner will wait between scans for a time defined by `period`.
func NewContinousScanner(period time.Duration) *ContinuousScanner {
return &ContinuousScanner{
Scanner: NewScanner(),
foundIPChan: make(chan ServiceFoundNotification),
period: period,
stop: make(chan struct{}),
}
}
// FoundServices returns a channel which will be populated with services found
// by the ContinuousScanner
func (s *ContinuousScanner) | FoundServices | identifier_name |
|
menus.py | CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QKeySequence
from PyQt5.QtWidgets import (QAction, QActionGroup, QApplication, QFrame,
QLabel, QMainWindow, QMenu, QMessageBox, QSizePolicy, QVBoxLayout,
QWidget)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
widget = QWidget()
self.setCentralWidget(widget)
topFiller = QWidget()
topFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.infoLabel = QLabel(
"<i>Choose a menu option, or right-click to invoke a context menu</i>",
alignment=Qt.AlignCenter)
self.infoLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
bottomFiller = QWidget()
bottomFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
vbox = QVBoxLayout()
vbox.setContentsMargins(5, 5, 5, 5)
vbox.addWidget(topFiller)
vbox.addWidget(self.infoLabel)
vbox.addWidget(bottomFiller)
widget.setLayout(vbox)
self.createActions()
self.createMenus()
message = "A context menu is available by right-clicking"
self.statusBar().showMessage(message)
self.setWindowTitle("Menus")
self.setMinimumSize(160,160)
self.resize(480,320)
def contextMenuEvent(self, event):
menu = QMenu(self)
menu.addAction(self.cutAct)
menu.addAction(self.copyAct)
menu.addAction(self.pasteAct)
menu.exec_(event.globalPos())
def newFile(self):
self.infoLabel.setText("Invoked <b>File|New</b>")
def open(self):
self.infoLabel.setText("Invoked <b>File|Open</b>")
def save(self):
self.infoLabel.setText("Invoked <b>File|Save</b>")
def print_(self):
self.infoLabel.setText("Invoked <b>File|Print</b>")
def undo(self):
self.infoLabel.setText("Invoked <b>Edit|Undo</b>")
def redo(self):
self.infoLabel.setText("Invoked <b>Edit|Redo</b>")
def cut(self):
self.infoLabel.setText("Invoked <b>Edit|Cut</b>")
def copy(self):
self.infoLabel.setText("Invoked <b>Edit|Copy</b>")
def paste(self):
self.infoLabel.setText("Invoked <b>Edit|Paste</b>")
def bold(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Bold</b>")
def italic(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Italic</b>")
def leftAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Left Align</b>")
def rightAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Right Align</b>")
def justify(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Justify</b>")
def center(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Center</b>")
def setLineSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Line Spacing</b>")
def setParagraphSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Paragraph Spacing</b>")
def about(self):
self.infoLabel.setText("Invoked <b>Help|About</b>")
QMessageBox.about(self, "About Menu",
"The <b>Menu</b> example shows how to create menu-bar menus "
"and context menus.")
def aboutQt(self):
self.infoLabel.setText("Invoked <b>Help|About Qt</b>")
def createActions(self):
self.newAct = QAction("&New", self, shortcut=QKeySequence.New,
statusTip="Create a new file", triggered=self.newFile)
self.openAct = QAction("&Open...", self, shortcut=QKeySequence.Open,
statusTip="Open an existing file", triggered=self.open)
self.saveAct = QAction("&Save", self, shortcut=QKeySequence.Save,
statusTip="Save the document to disk", triggered=self.save)
self.printAct = QAction("&Print...", self, shortcut=QKeySequence.Print,
statusTip="Print the document", triggered=self.print_)
self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
statusTip="Exit the application", triggered=self.close)
self.undoAct = QAction("&Undo", self, shortcut=QKeySequence.Undo,
statusTip="Undo the last operation", triggered=self.undo)
self.redoAct = QAction("&Redo", self, shortcut=QKeySequence.Redo,
statusTip="Redo the last operation", triggered=self.redo)
self.cutAct = QAction("Cu&t", self, shortcut=QKeySequence.Cut,
statusTip="Cut the current selection's contents to the clipboard",
triggered=self.cut)
self.copyAct = QAction("&Copy", self, shortcut=QKeySequence.Copy,
statusTip="Copy the current selection's contents to the clipboard",
triggered=self.copy)
self.pasteAct = QAction("&Paste", self, shortcut=QKeySequence.Paste,
statusTip="Paste the clipboard's contents into the current selection",
triggered=self.paste)
self.boldAct = QAction("&Bold", self, checkable=True,
shortcut="Ctrl+B", statusTip="Make the text bold",
triggered=self.bold)
boldFont = self.boldAct.font()
boldFont.setBold(True)
self.boldAct.setFont(boldFont)
self.italicAct = QAction("&Italic", self, checkable=True,
shortcut="Ctrl+I", statusTip="Make the text italic",
triggered=self.italic)
italicFont = self.italicAct.font()
italicFont.setItalic(True)
self.italicAct.setFont(italicFont)
self.setLineSpacingAct = QAction("Set &Line Spacing...", self,
statusTip="Change the gap between the lines of a paragraph",
triggered=self.setLineSpacing)
self.setParagraphSpacingAct = QAction("Set &Paragraph Spacing...",
self, statusTip="Change the gap between paragraphs",
triggered=self.setParagraphSpacing)
self.aboutAct = QAction("&About", self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction("About &Qt", self,
statusTip="Show the Qt library's About box",
triggered=self.aboutQt)
self.aboutQtAct.triggered.connect(QApplication.instance().aboutQt)
self.leftAlignAct = QAction("&Left Align", self, checkable=True,
shortcut="Ctrl+L", statusTip="Left align the selected text",
triggered=self.leftAlign)
self.rightAlignAct = QAction("&Right Align", self, checkable=True,
shortcut="Ctrl+R", statusTip="Right align the selected text",
triggered=self.rightAlign)
self.justifyAct = QAction("&Justify", self, checkable=True,
shortcut="Ctrl+J", statusTip="Justify the selected text",
triggered=self.justify)
self.centerAct = QAction("&Center", self, checkable=True,
shortcut="Ctrl+C", statusTip="Center the selected text",
triggered=self.center)
self.alignmentGroup = QActionGroup(self)
self.alignmentGroup.addAction(self.leftAlignAct)
self.alignmentGroup.addAction(self.rightAlignAct)
self.alignmentGroup.addAction(self.justifyAct)
self.alignmentGroup.addAction(self.centerAct)
self.leftAlignAct.setChecked(True)
def createMenus(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.newAct)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.printAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
self.editMenu = self.menuBar().addMenu("&Edit")
self.editMenu.addAction(self.undoAct)
self.editMenu.addAction(self.redoAct)
self.editMenu.addSeparator()
self.editMenu.addAction(self.cutAct)
self.editMenu.addAction(self.copyAct)
self.editMenu.addAction(self.pasteAct)
self.editMenu.addSeparator()
self.helpMenu = self.menuBar().addMenu("&Help")
self.helpMenu.addAction(self.aboutAct)
self.helpMenu.addAction(self.aboutQtAct)
self.formatMenu = self.editMenu.addMenu("&Format")
self.formatMenu.addAction(self.boldAct)
self.formatMenu.addAction(self.italicAct)
self.formatMenu.addSeparator().setText("Alignment")
self.formatMenu.addAction(self.leftAlignAct)
self.formatMenu.addAction(self.rightAlignAct)
self.formatMenu.addAction(self.justifyAct)
self.formatMenu.addAction(self.centerAct)
self.formatMenu.addSeparator()
self.formatMenu.addAction(self.setLineSpacingAct)
self.formatMenu.addAction(self.setParagraphSpacingAct)
if __name__ == '__main__':
| import sys
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_()) | conditional_block |
|
menus.py | , are permitted provided that the following conditions are
## met:
## * Redistributions of source code must retain the above copyright
## notice, this list of conditions and the following disclaimer.
## * Redistributions in binary form must reproduce the above copyright
## notice, this list of conditions and the following disclaimer in
## the documentation and/or other materials provided with the
## distribution.
## * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
## the names of its contributors may be used to endorse or promote
## products derived from this software without specific prior written
## permission.
##
## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
## OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QKeySequence
from PyQt5.QtWidgets import (QAction, QActionGroup, QApplication, QFrame,
QLabel, QMainWindow, QMenu, QMessageBox, QSizePolicy, QVBoxLayout,
QWidget)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
widget = QWidget()
self.setCentralWidget(widget)
topFiller = QWidget()
topFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.infoLabel = QLabel(
"<i>Choose a menu option, or right-click to invoke a context menu</i>",
alignment=Qt.AlignCenter)
self.infoLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
bottomFiller = QWidget()
bottomFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
vbox = QVBoxLayout()
vbox.setContentsMargins(5, 5, 5, 5)
vbox.addWidget(topFiller)
vbox.addWidget(self.infoLabel)
vbox.addWidget(bottomFiller)
widget.setLayout(vbox)
self.createActions()
self.createMenus()
message = "A context menu is available by right-clicking"
self.statusBar().showMessage(message)
self.setWindowTitle("Menus")
self.setMinimumSize(160,160)
self.resize(480,320)
def contextMenuEvent(self, event):
menu = QMenu(self)
menu.addAction(self.cutAct)
menu.addAction(self.copyAct)
menu.addAction(self.pasteAct)
menu.exec_(event.globalPos())
def newFile(self):
self.infoLabel.setText("Invoked <b>File|New</b>")
def open(self):
self.infoLabel.setText("Invoked <b>File|Open</b>")
def save(self):
self.infoLabel.setText("Invoked <b>File|Save</b>")
def print_(self):
self.infoLabel.setText("Invoked <b>File|Print</b>")
def undo(self):
self.infoLabel.setText("Invoked <b>Edit|Undo</b>")
def redo(self):
self.infoLabel.setText("Invoked <b>Edit|Redo</b>")
def cut(self):
self.infoLabel.setText("Invoked <b>Edit|Cut</b>")
def copy(self):
self.infoLabel.setText("Invoked <b>Edit|Copy</b>")
def paste(self):
self.infoLabel.setText("Invoked <b>Edit|Paste</b>")
def bold(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Bold</b>")
def italic(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Italic</b>")
def leftAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Left Align</b>")
def rightAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Right Align</b>")
def justify(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Justify</b>")
def center(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Center</b>")
def setLineSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Line Spacing</b>")
def setParagraphSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Paragraph Spacing</b>")
def about(self):
self.infoLabel.setText("Invoked <b>Help|About</b>")
QMessageBox.about(self, "About Menu", | self.infoLabel.setText("Invoked <b>Help|About Qt</b>")
def createActions(self):
self.newAct = QAction("&New", self, shortcut=QKeySequence.New,
statusTip="Create a new file", triggered=self.newFile)
self.openAct = QAction("&Open...", self, shortcut=QKeySequence.Open,
statusTip="Open an existing file", triggered=self.open)
self.saveAct = QAction("&Save", self, shortcut=QKeySequence.Save,
statusTip="Save the document to disk", triggered=self.save)
self.printAct = QAction("&Print...", self, shortcut=QKeySequence.Print,
statusTip="Print the document", triggered=self.print_)
self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
statusTip="Exit the application", triggered=self.close)
self.undoAct = QAction("&Undo", self, shortcut=QKeySequence.Undo,
statusTip="Undo the last operation", triggered=self.undo)
self.redoAct = QAction("&Redo", self, shortcut=QKeySequence.Redo,
statusTip="Redo the last operation", triggered=self.redo)
self.cutAct = QAction("Cu&t", self, shortcut=QKeySequence.Cut,
statusTip="Cut the current selection's contents to the clipboard",
triggered=self.cut)
self.copyAct = QAction("&Copy", self, shortcut=QKeySequence.Copy,
statusTip="Copy the current selection's contents to the clipboard",
triggered=self.copy)
self.pasteAct = QAction("&Paste", self, shortcut=QKeySequence.Paste,
statusTip="Paste the clipboard's contents into the current selection",
triggered=self.paste)
self.boldAct = QAction("&Bold", self, checkable=True,
shortcut="Ctrl+B", statusTip="Make the text bold",
triggered=self.bold)
boldFont = self.boldAct.font()
boldFont.setBold(True)
self.boldAct.setFont(boldFont)
self.italicAct = QAction("&Italic", self, checkable=True,
shortcut="Ctrl+I", statusTip="Make the text italic",
triggered=self.italic)
italicFont = self.italicAct.font()
italicFont.setItalic(True)
self.italicAct.setFont(italicFont)
self.setLineSpacingAct = QAction("Set &Line Spacing...", self,
statusTip="Change the gap between the lines of a paragraph",
triggered=self.setLineSpacing)
self.setParagraphSpacingAct = QAction("Set &Paragraph Spacing...",
self, statusTip="Change the gap between paragraphs",
triggered=self.setParagraphSpacing)
self.aboutAct = QAction("&About", self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction("About &Qt", self,
statusTip="Show the Qt library's About box",
triggered=self.aboutQt)
self.aboutQtAct.triggered.connect(QApplication.instance().aboutQt)
self.leftAlignAct = QAction("&Left Align", self, checkable=True,
shortcut="Ctrl+L", statusTip="Left align the selected text",
triggered=self.leftAlign)
self.rightAlignAct = QAction("&Right Align", self, checkable=True,
shortcut="Ctrl+R", statusTip="Right align the selected text",
triggered=self.rightAlign)
self.justifyAct = QAction("&Justify", self, checkable=True,
shortcut="Ctrl+J", statusTip="Justify the selected text",
triggered=self.justify)
self.centerAct = QAction("&Center", self, checkable=True,
shortcut="Ctrl+C", statusTip="Center the selected text",
triggered=self.center)
self.alignmentGroup = QActionGroup(self)
self.alignmentGroup.addAction(self.leftAlignAct)
self.alignmentGroup.addAction(self.rightAlignAct)
self.alignmentGroup.addAction(self.justifyAct)
self.alignmentGroup.addAction(self.centerAct)
self.leftAlignAct.setChecked(True)
def createMenus(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.newAct)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.printAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
self.editMenu = self.menuBar().addMenu | "The <b>Menu</b> example shows how to create menu-bar menus "
"and context menus.")
def aboutQt(self): | random_line_split |
menus.py | , are permitted provided that the following conditions are
## met:
## * Redistributions of source code must retain the above copyright
## notice, this list of conditions and the following disclaimer.
## * Redistributions in binary form must reproduce the above copyright
## notice, this list of conditions and the following disclaimer in
## the documentation and/or other materials provided with the
## distribution.
## * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
## the names of its contributors may be used to endorse or promote
## products derived from this software without specific prior written
## permission.
##
## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
## OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QKeySequence
from PyQt5.QtWidgets import (QAction, QActionGroup, QApplication, QFrame,
QLabel, QMainWindow, QMenu, QMessageBox, QSizePolicy, QVBoxLayout,
QWidget)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
widget = QWidget()
self.setCentralWidget(widget)
topFiller = QWidget()
topFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.infoLabel = QLabel(
"<i>Choose a menu option, or right-click to invoke a context menu</i>",
alignment=Qt.AlignCenter)
self.infoLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
bottomFiller = QWidget()
bottomFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
vbox = QVBoxLayout()
vbox.setContentsMargins(5, 5, 5, 5)
vbox.addWidget(topFiller)
vbox.addWidget(self.infoLabel)
vbox.addWidget(bottomFiller)
widget.setLayout(vbox)
self.createActions()
self.createMenus()
message = "A context menu is available by right-clicking"
self.statusBar().showMessage(message)
self.setWindowTitle("Menus")
self.setMinimumSize(160,160)
self.resize(480,320)
def contextMenuEvent(self, event):
menu = QMenu(self)
menu.addAction(self.cutAct)
menu.addAction(self.copyAct)
menu.addAction(self.pasteAct)
menu.exec_(event.globalPos())
def newFile(self):
self.infoLabel.setText("Invoked <b>File|New</b>")
def | (self):
self.infoLabel.setText("Invoked <b>File|Open</b>")
def save(self):
self.infoLabel.setText("Invoked <b>File|Save</b>")
def print_(self):
self.infoLabel.setText("Invoked <b>File|Print</b>")
def undo(self):
self.infoLabel.setText("Invoked <b>Edit|Undo</b>")
def redo(self):
self.infoLabel.setText("Invoked <b>Edit|Redo</b>")
def cut(self):
self.infoLabel.setText("Invoked <b>Edit|Cut</b>")
def copy(self):
self.infoLabel.setText("Invoked <b>Edit|Copy</b>")
def paste(self):
self.infoLabel.setText("Invoked <b>Edit|Paste</b>")
def bold(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Bold</b>")
def italic(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Italic</b>")
def leftAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Left Align</b>")
def rightAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Right Align</b>")
def justify(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Justify</b>")
def center(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Center</b>")
def setLineSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Line Spacing</b>")
def setParagraphSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Paragraph Spacing</b>")
def about(self):
self.infoLabel.setText("Invoked <b>Help|About</b>")
QMessageBox.about(self, "About Menu",
"The <b>Menu</b> example shows how to create menu-bar menus "
"and context menus.")
def aboutQt(self):
self.infoLabel.setText("Invoked <b>Help|About Qt</b>")
def createActions(self):
self.newAct = QAction("&New", self, shortcut=QKeySequence.New,
statusTip="Create a new file", triggered=self.newFile)
self.openAct = QAction("&Open...", self, shortcut=QKeySequence.Open,
statusTip="Open an existing file", triggered=self.open)
self.saveAct = QAction("&Save", self, shortcut=QKeySequence.Save,
statusTip="Save the document to disk", triggered=self.save)
self.printAct = QAction("&Print...", self, shortcut=QKeySequence.Print,
statusTip="Print the document", triggered=self.print_)
self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
statusTip="Exit the application", triggered=self.close)
self.undoAct = QAction("&Undo", self, shortcut=QKeySequence.Undo,
statusTip="Undo the last operation", triggered=self.undo)
self.redoAct = QAction("&Redo", self, shortcut=QKeySequence.Redo,
statusTip="Redo the last operation", triggered=self.redo)
self.cutAct = QAction("Cu&t", self, shortcut=QKeySequence.Cut,
statusTip="Cut the current selection's contents to the clipboard",
triggered=self.cut)
self.copyAct = QAction("&Copy", self, shortcut=QKeySequence.Copy,
statusTip="Copy the current selection's contents to the clipboard",
triggered=self.copy)
self.pasteAct = QAction("&Paste", self, shortcut=QKeySequence.Paste,
statusTip="Paste the clipboard's contents into the current selection",
triggered=self.paste)
self.boldAct = QAction("&Bold", self, checkable=True,
shortcut="Ctrl+B", statusTip="Make the text bold",
triggered=self.bold)
boldFont = self.boldAct.font()
boldFont.setBold(True)
self.boldAct.setFont(boldFont)
self.italicAct = QAction("&Italic", self, checkable=True,
shortcut="Ctrl+I", statusTip="Make the text italic",
triggered=self.italic)
italicFont = self.italicAct.font()
italicFont.setItalic(True)
self.italicAct.setFont(italicFont)
self.setLineSpacingAct = QAction("Set &Line Spacing...", self,
statusTip="Change the gap between the lines of a paragraph",
triggered=self.setLineSpacing)
self.setParagraphSpacingAct = QAction("Set &Paragraph Spacing...",
self, statusTip="Change the gap between paragraphs",
triggered=self.setParagraphSpacing)
self.aboutAct = QAction("&About", self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction("About &Qt", self,
statusTip="Show the Qt library's About box",
triggered=self.aboutQt)
self.aboutQtAct.triggered.connect(QApplication.instance().aboutQt)
self.leftAlignAct = QAction("&Left Align", self, checkable=True,
shortcut="Ctrl+L", statusTip="Left align the selected text",
triggered=self.leftAlign)
self.rightAlignAct = QAction("&Right Align", self, checkable=True,
shortcut="Ctrl+R", statusTip="Right align the selected text",
triggered=self.rightAlign)
self.justifyAct = QAction("&Justify", self, checkable=True,
shortcut="Ctrl+J", statusTip="Justify the selected text",
triggered=self.justify)
self.centerAct = QAction("&Center", self, checkable=True,
shortcut="Ctrl+C", statusTip="Center the selected text",
triggered=self.center)
self.alignmentGroup = QActionGroup(self)
self.alignmentGroup.addAction(self.leftAlignAct)
self.alignmentGroup.addAction(self.rightAlignAct)
self.alignmentGroup.addAction(self.justifyAct)
self.alignmentGroup.addAction(self.centerAct)
self.leftAlignAct.setChecked(True)
def createMenus(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.newAct)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.printAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
self.editMenu = self.menuBar().add | open | identifier_name |
menus.py | , are permitted provided that the following conditions are
## met:
## * Redistributions of source code must retain the above copyright
## notice, this list of conditions and the following disclaimer.
## * Redistributions in binary form must reproduce the above copyright
## notice, this list of conditions and the following disclaimer in
## the documentation and/or other materials provided with the
## distribution.
## * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
## the names of its contributors may be used to endorse or promote
## products derived from this software without specific prior written
## permission.
##
## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
## OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QKeySequence
from PyQt5.QtWidgets import (QAction, QActionGroup, QApplication, QFrame,
QLabel, QMainWindow, QMenu, QMessageBox, QSizePolicy, QVBoxLayout,
QWidget)
class MainWindow(QMainWindow):
def __init__(self):
| vbox.addWidget(bottomFiller)
widget.setLayout(vbox)
self.createActions()
self.createMenus()
message = "A context menu is available by right-clicking"
self.statusBar().showMessage(message)
self.setWindowTitle("Menus")
self.setMinimumSize(160,160)
self.resize(480,320)
def contextMenuEvent(self, event):
menu = QMenu(self)
menu.addAction(self.cutAct)
menu.addAction(self.copyAct)
menu.addAction(self.pasteAct)
menu.exec_(event.globalPos())
def newFile(self):
self.infoLabel.setText("Invoked <b>File|New</b>")
def open(self):
self.infoLabel.setText("Invoked <b>File|Open</b>")
def save(self):
self.infoLabel.setText("Invoked <b>File|Save</b>")
def print_(self):
self.infoLabel.setText("Invoked <b>File|Print</b>")
def undo(self):
self.infoLabel.setText("Invoked <b>Edit|Undo</b>")
def redo(self):
self.infoLabel.setText("Invoked <b>Edit|Redo</b>")
def cut(self):
self.infoLabel.setText("Invoked <b>Edit|Cut</b>")
def copy(self):
self.infoLabel.setText("Invoked <b>Edit|Copy</b>")
def paste(self):
self.infoLabel.setText("Invoked <b>Edit|Paste</b>")
def bold(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Bold</b>")
def italic(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Italic</b>")
def leftAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Left Align</b>")
def rightAlign(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Right Align</b>")
def justify(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Justify</b>")
def center(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Center</b>")
def setLineSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Line Spacing</b>")
def setParagraphSpacing(self):
self.infoLabel.setText("Invoked <b>Edit|Format|Set Paragraph Spacing</b>")
def about(self):
self.infoLabel.setText("Invoked <b>Help|About</b>")
QMessageBox.about(self, "About Menu",
"The <b>Menu</b> example shows how to create menu-bar menus "
"and context menus.")
def aboutQt(self):
self.infoLabel.setText("Invoked <b>Help|About Qt</b>")
def createActions(self):
self.newAct = QAction("&New", self, shortcut=QKeySequence.New,
statusTip="Create a new file", triggered=self.newFile)
self.openAct = QAction("&Open...", self, shortcut=QKeySequence.Open,
statusTip="Open an existing file", triggered=self.open)
self.saveAct = QAction("&Save", self, shortcut=QKeySequence.Save,
statusTip="Save the document to disk", triggered=self.save)
self.printAct = QAction("&Print...", self, shortcut=QKeySequence.Print,
statusTip="Print the document", triggered=self.print_)
self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
statusTip="Exit the application", triggered=self.close)
self.undoAct = QAction("&Undo", self, shortcut=QKeySequence.Undo,
statusTip="Undo the last operation", triggered=self.undo)
self.redoAct = QAction("&Redo", self, shortcut=QKeySequence.Redo,
statusTip="Redo the last operation", triggered=self.redo)
self.cutAct = QAction("Cu&t", self, shortcut=QKeySequence.Cut,
statusTip="Cut the current selection's contents to the clipboard",
triggered=self.cut)
self.copyAct = QAction("&Copy", self, shortcut=QKeySequence.Copy,
statusTip="Copy the current selection's contents to the clipboard",
triggered=self.copy)
self.pasteAct = QAction("&Paste", self, shortcut=QKeySequence.Paste,
statusTip="Paste the clipboard's contents into the current selection",
triggered=self.paste)
self.boldAct = QAction("&Bold", self, checkable=True,
shortcut="Ctrl+B", statusTip="Make the text bold",
triggered=self.bold)
boldFont = self.boldAct.font()
boldFont.setBold(True)
self.boldAct.setFont(boldFont)
self.italicAct = QAction("&Italic", self, checkable=True,
shortcut="Ctrl+I", statusTip="Make the text italic",
triggered=self.italic)
italicFont = self.italicAct.font()
italicFont.setItalic(True)
self.italicAct.setFont(italicFont)
self.setLineSpacingAct = QAction("Set &Line Spacing...", self,
statusTip="Change the gap between the lines of a paragraph",
triggered=self.setLineSpacing)
self.setParagraphSpacingAct = QAction("Set &Paragraph Spacing...",
self, statusTip="Change the gap between paragraphs",
triggered=self.setParagraphSpacing)
self.aboutAct = QAction("&About", self,
statusTip="Show the application's About box",
triggered=self.about)
self.aboutQtAct = QAction("About &Qt", self,
statusTip="Show the Qt library's About box",
triggered=self.aboutQt)
self.aboutQtAct.triggered.connect(QApplication.instance().aboutQt)
self.leftAlignAct = QAction("&Left Align", self, checkable=True,
shortcut="Ctrl+L", statusTip="Left align the selected text",
triggered=self.leftAlign)
self.rightAlignAct = QAction("&Right Align", self, checkable=True,
shortcut="Ctrl+R", statusTip="Right align the selected text",
triggered=self.rightAlign)
self.justifyAct = QAction("&Justify", self, checkable=True,
shortcut="Ctrl+J", statusTip="Justify the selected text",
triggered=self.justify)
self.centerAct = QAction("&Center", self, checkable=True,
shortcut="Ctrl+C", statusTip="Center the selected text",
triggered=self.center)
self.alignmentGroup = QActionGroup(self)
self.alignmentGroup.addAction(self.leftAlignAct)
self.alignmentGroup.addAction(self.rightAlignAct)
self.alignmentGroup.addAction(self.justifyAct)
self.alignmentGroup.addAction(self.centerAct)
self.leftAlignAct.setChecked(True)
def createMenus(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.newAct)
self.fileMenu.addAction(self.openAct)
self.fileMenu.addAction(self.saveAct)
self.fileMenu.addAction(self.printAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
self.editMenu = self.menuBar().addMenu | super(MainWindow, self).__init__()
widget = QWidget()
self.setCentralWidget(widget)
topFiller = QWidget()
topFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.infoLabel = QLabel(
"<i>Choose a menu option, or right-click to invoke a context menu</i>",
alignment=Qt.AlignCenter)
self.infoLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
bottomFiller = QWidget()
bottomFiller.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
vbox = QVBoxLayout()
vbox.setContentsMargins(5, 5, 5, 5)
vbox.addWidget(topFiller)
vbox.addWidget(self.infoLabel) | identifier_body |
wasm.rs | }
pub fn extra_rust_options(self) -> Vec<String> {
match self {
// Profile::Production => ["-Clto=fat", "-Ccodegen-units=1", "-Cincremental=false"]
// .into_iter()
// .map(ToString::to_string)
// .collect(),
Profile::Dev | Profile::Profile | Profile::Release => vec![],
}
}
pub fn optimization_level(self) -> wasm_opt::OptimizationLevel {
match self {
Profile::Dev => wasm_opt::OptimizationLevel::O0,
Profile::Profile => wasm_opt::OptimizationLevel::O,
Profile::Release => wasm_opt::OptimizationLevel::O3,
}
}
}
#[derive(Clone, Derivative)]
#[derivative(Debug)]
pub struct BuildInput {
/// Path to the crate to be compiled to WAM. Relative to the repository root.
pub crate_path: PathBuf,
pub wasm_opt_options: Vec<String>,
pub skip_wasm_opt: bool,
pub extra_cargo_options: Vec<String>,
pub profile: Profile,
pub profiling_level: Option<ProfilingLevel>,
pub log_level: LogLevel,
pub uncollapsed_log_level: LogLevel,
pub wasm_size_limit: Option<byte_unit::Byte>,
pub system_shader_tools: bool,
}
impl BuildInput {
pub async fn perhaps_check_size(&self, wasm_path: impl AsRef<Path>) -> Result {
let compressed_size = compressed_size(&wasm_path).await?.get_appropriate_unit(true);
info!("Compressed size of {} is {}.", wasm_path.as_ref().display(), compressed_size);
if let Some(wasm_size_limit) = self.wasm_size_limit {
let wasm_size_limit = wasm_size_limit.get_appropriate_unit(true);
if !self.profile.should_check_size() {
warn!("Skipping size check because profile is '{}'.", self.profile,);
} else if self.profiling_level.unwrap_or_default() != ProfilingLevel::Objective {
// TODO? additional leeway as sanity check
warn!(
"Skipping size check because profiling level is {:?} rather than {}.",
self.profiling_level,
ProfilingLevel::Objective
);
} else {
ensure!(
compressed_size < wasm_size_limit,
"Compressed WASM size ~{} ({} bytes) exceeds the limit of {} ({} bytes).",
compressed_size,
compressed_size.get_byte(),
wasm_size_limit,
wasm_size_limit.get_byte(),
)
}
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Wasm;
#[async_trait]
impl IsTarget for Wasm {
type BuildInput = BuildInput;
type Artifact = Artifact;
fn artifact_name(&self) -> String {
WASM_ARTIFACT_NAME.into()
}
fn adapt_artifact(self, path: impl AsRef<Path>) -> BoxFuture<'static, Result<Self::Artifact>> {
ready(Ok(Artifact::new(path.as_ref()))).boxed()
}
fn build_internal(
&self,
context: Context,
job: BuildTargetJob<Self>,
) -> BoxFuture<'static, Result<Self::Artifact>> | log_level,
uncollapsed_log_level,
wasm_size_limit: _wasm_size_limit,
system_shader_tools,
} = &inner;
// NOTE: We cannot trust locally installed version of shader tools to be correct.
// Those binaries have no reliable versioning, and existing common distributions (e.g.
// Vulkan SDK) contain old builds with bugs that impact our shaders. By default, we have
// to force usage of our own distribution built on our CI.
if *system_shader_tools {
ShaderTools.install_if_missing(&cache).await?;
} else {
ShaderTools.install(&cache).await?;
}
cache::goodie::binaryen::Binaryen { version: BINARYEN_VERSION_TO_INSTALL }
.install_if_missing(&cache)
.await?;
info!("Building wasm.");
let temp_dir = tempdir()?;
let temp_dist = RepoRootDistWasm::new_root(temp_dir.path());
ensogl_pack::build(
ensogl_pack::WasmPackOutputs {
out_dir: temp_dist.path.clone(),
out_name: OUTPUT_NAME.into(),
},
|args| {
let mut command = WasmPack.cmd()?;
command
.current_dir(&repo_root)
.kill_on_drop(true)
.env_remove(ide_ci::programs::rustup::env::RUSTUP_TOOLCHAIN.name())
.build()
.arg(wasm_pack::Profile::from(*profile))
.target(wasm_pack::Target::Web)
.output_directory(args.out_dir)
.output_name(args.out_name)
.arg(crate_path)
.arg("--")
.apply(&cargo::Color::Always)
.args(extra_cargo_options);
if let Some(profiling_level) = profiling_level {
command.set_env(env::ENSO_MAX_PROFILING_LEVEL, &profiling_level)?;
}
command.set_env(env::ENSO_MAX_LOG_LEVEL, &log_level)?;
command.set_env(env::ENSO_MAX_UNCOLLAPSED_LOG_LEVEL, &uncollapsed_log_level)?;
Ok(command)
},
)
.await?;
Self::finalize_wasm(wasm_opt_options, *skip_wasm_opt, *profile, &temp_dist).await?;
ide_ci::fs::create_dir_if_missing(&destination)?;
let ret = RepoRootDistWasm::new_root(&destination);
ide_ci::fs::copy(&temp_dist, &ret)?;
inner.perhaps_check_size(&ret.pkg_opt_wasm).await?;
Ok(Artifact(ret))
}
.instrument(span)
.boxed()
}
}
#[derive(Clone, Derivative)]
#[derivative(Debug)]
pub struct WatchInput {
pub cargo_watch_options: Vec<String>,
}
impl IsWatchable for Wasm {
type Watcher = crate::project::Watcher<Self, Child>;
type WatchInput = WatchInput;
fn watch(
&self,
context: Context,
job: WatchTargetJob<Self>,
) -> BoxFuture<'static, Result<Self::Watcher>> {
let span = debug_span!("Watching WASM.", ?job).entered();
// The esbuild watcher must succeed in its first build, or it will prematurely exit.
// See the issue: https://github.com/evanw/esbuild/issues/1063
//
// Because of this, we run first build of wasm manually, rather through cargo-watch.
// After it is completed, the cargo-watch gets spawned and this method yields the watcher.
// This forces esbuild watcher (whose setup requires the watcher artifacts) to wait until
// all wasm build outputs are in place, so the build won't crash.
//
// In general, much neater workaround should be possible, if we stop relying on cargo-watch
// and do the WASM watch directly in the build script.
let first_build_job = self
.build(context.clone(), job.build.clone())
.instrument(debug_span!("Initial single build of WASM before setting up cargo-watch."));
async move {
let first_build_output = first_build_job.await?;
let WatchTargetJob {
watch_input: WatchInput { cargo_watch_options: cargo_watch_flags },
build: WithDestination { inner, destination },
} = job;
let BuildInput {
crate_path,
wasm_opt_options,
skip_wasm_opt,
extra_cargo_options,
profile,
profiling_level,
log_level,
uncollapsed_log_level,
wasm_size_limit,
system_shader_tools: _,
} = inner;
let current_exe = std::env::current_exe()?;
// cargo-watch apparently cannot handle verbatim path prefix. We remove it and hope for
// the best.
let current_exe = current_exe.without_verbatim_prefix();
let mut watch_cmd = Cargo.cmd()?;
let (watch_cmd_name, mut watch_cmd_opts) = match std::env::var("USE_CARGO_WATCH_PLUS") {
Ok(_) => ("watch-plus", vec!["--why"]),
Err(_) => ("watch", vec![]),
};
watch_cmd_opts.push("--ignore");
watch_cmd_opts.push("README.md");
watch_cmd
.kill_on_drop(true)
.current_dir(&context.repo_root)
.arg(watch_cmd_name)
.args(watch_cmd_opts)
.args(cargo_watch_flags)
.arg("--");
// === Build Script top-level options ===
watch_cmd
// TODO [mwu]
// This is not nice, as this module should not be aware of the CLI
// parsing | {
let Context { octocrab: _, cache, upload_artifacts: _, repo_root } = context;
let WithDestination { inner, destination } = job;
let span = info_span!("Building WASM.",
repo = %repo_root.display(),
crate = %inner.crate_path.display(),
cargo_opts = ?inner.extra_cargo_options
);
async move {
// Old wasm-pack does not pass trailing `build` command arguments to the Cargo.
// We want to be able to pass --profile this way.
WasmPack.require_present_that(VersionReq::parse(">=0.10.1")?).await?;
let BuildInput {
crate_path,
wasm_opt_options,
skip_wasm_opt,
extra_cargo_options,
profile,
profiling_level, | identifier_body |
wasm.rs | }
pub fn extra_rust_options(self) -> Vec<String> {
match self {
// Profile::Production => ["-Clto=fat", "-Ccodegen-units=1", "-Cincremental=false"]
// .into_iter()
// .map(ToString::to_string)
// .collect(),
Profile::Dev | Profile::Profile | Profile::Release => vec![],
}
}
pub fn optimization_level(self) -> wasm_opt::OptimizationLevel {
match self {
Profile::Dev => wasm_opt::OptimizationLevel::O0,
Profile::Profile => wasm_opt::OptimizationLevel::O,
Profile::Release => wasm_opt::OptimizationLevel::O3,
}
}
}
#[derive(Clone, Derivative)]
#[derivative(Debug)]
pub struct BuildInput {
/// Path to the crate to be compiled to WAM. Relative to the repository root.
pub crate_path: PathBuf,
pub wasm_opt_options: Vec<String>,
pub skip_wasm_opt: bool,
pub extra_cargo_options: Vec<String>,
pub profile: Profile,
pub profiling_level: Option<ProfilingLevel>,
pub log_level: LogLevel,
pub uncollapsed_log_level: LogLevel,
pub wasm_size_limit: Option<byte_unit::Byte>,
pub system_shader_tools: bool,
}
impl BuildInput {
pub async fn perhaps_check_size(&self, wasm_path: impl AsRef<Path>) -> Result {
let compressed_size = compressed_size(&wasm_path).await?.get_appropriate_unit(true); | if !self.profile.should_check_size() {
warn!("Skipping size check because profile is '{}'.", self.profile,);
} else if self.profiling_level.unwrap_or_default() != ProfilingLevel::Objective {
// TODO? additional leeway as sanity check
warn!(
"Skipping size check because profiling level is {:?} rather than {}.",
self.profiling_level,
ProfilingLevel::Objective
);
} else {
ensure!(
compressed_size < wasm_size_limit,
"Compressed WASM size ~{} ({} bytes) exceeds the limit of {} ({} bytes).",
compressed_size,
compressed_size.get_byte(),
wasm_size_limit,
wasm_size_limit.get_byte(),
)
}
}
Ok(())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Wasm;
#[async_trait]
impl IsTarget for Wasm {
type BuildInput = BuildInput;
type Artifact = Artifact;
fn artifact_name(&self) -> String {
WASM_ARTIFACT_NAME.into()
}
fn adapt_artifact(self, path: impl AsRef<Path>) -> BoxFuture<'static, Result<Self::Artifact>> {
ready(Ok(Artifact::new(path.as_ref()))).boxed()
}
fn build_internal(
&self,
context: Context,
job: BuildTargetJob<Self>,
) -> BoxFuture<'static, Result<Self::Artifact>> {
let Context { octocrab: _, cache, upload_artifacts: _, repo_root } = context;
let WithDestination { inner, destination } = job;
let span = info_span!("Building WASM.",
repo = %repo_root.display(),
crate = %inner.crate_path.display(),
cargo_opts = ?inner.extra_cargo_options
);
async move {
// Old wasm-pack does not pass trailing `build` command arguments to the Cargo.
// We want to be able to pass --profile this way.
WasmPack.require_present_that(VersionReq::parse(">=0.10.1")?).await?;
let BuildInput {
crate_path,
wasm_opt_options,
skip_wasm_opt,
extra_cargo_options,
profile,
profiling_level,
log_level,
uncollapsed_log_level,
wasm_size_limit: _wasm_size_limit,
system_shader_tools,
} = &inner;
// NOTE: We cannot trust locally installed version of shader tools to be correct.
// Those binaries have no reliable versioning, and existing common distributions (e.g.
// Vulkan SDK) contain old builds with bugs that impact our shaders. By default, we have
// to force usage of our own distribution built on our CI.
if *system_shader_tools {
ShaderTools.install_if_missing(&cache).await?;
} else {
ShaderTools.install(&cache).await?;
}
cache::goodie::binaryen::Binaryen { version: BINARYEN_VERSION_TO_INSTALL }
.install_if_missing(&cache)
.await?;
info!("Building wasm.");
let temp_dir = tempdir()?;
let temp_dist = RepoRootDistWasm::new_root(temp_dir.path());
ensogl_pack::build(
ensogl_pack::WasmPackOutputs {
out_dir: temp_dist.path.clone(),
out_name: OUTPUT_NAME.into(),
},
|args| {
let mut command = WasmPack.cmd()?;
command
.current_dir(&repo_root)
.kill_on_drop(true)
.env_remove(ide_ci::programs::rustup::env::RUSTUP_TOOLCHAIN.name())
.build()
.arg(wasm_pack::Profile::from(*profile))
.target(wasm_pack::Target::Web)
.output_directory(args.out_dir)
.output_name(args.out_name)
.arg(crate_path)
.arg("--")
.apply(&cargo::Color::Always)
.args(extra_cargo_options);
if let Some(profiling_level) = profiling_level {
command.set_env(env::ENSO_MAX_PROFILING_LEVEL, &profiling_level)?;
}
command.set_env(env::ENSO_MAX_LOG_LEVEL, &log_level)?;
command.set_env(env::ENSO_MAX_UNCOLLAPSED_LOG_LEVEL, &uncollapsed_log_level)?;
Ok(command)
},
)
.await?;
Self::finalize_wasm(wasm_opt_options, *skip_wasm_opt, *profile, &temp_dist).await?;
ide_ci::fs::create_dir_if_missing(&destination)?;
let ret = RepoRootDistWasm::new_root(&destination);
ide_ci::fs::copy(&temp_dist, &ret)?;
inner.perhaps_check_size(&ret.pkg_opt_wasm).await?;
Ok(Artifact(ret))
}
.instrument(span)
.boxed()
}
}
#[derive(Clone, Derivative)]
#[derivative(Debug)]
pub struct WatchInput {
pub cargo_watch_options: Vec<String>,
}
impl IsWatchable for Wasm {
type Watcher = crate::project::Watcher<Self, Child>;
type WatchInput = WatchInput;
fn watch(
&self,
context: Context,
job: WatchTargetJob<Self>,
) -> BoxFuture<'static, Result<Self::Watcher>> {
let span = debug_span!("Watching WASM.", ?job).entered();
// The esbuild watcher must succeed in its first build, or it will prematurely exit.
// See the issue: https://github.com/evanw/esbuild/issues/1063
//
// Because of this, we run first build of wasm manually, rather through cargo-watch.
// After it is completed, the cargo-watch gets spawned and this method yields the watcher.
// This forces esbuild watcher (whose setup requires the watcher artifacts) to wait until
// all wasm build outputs are in place, so the build won't crash.
//
// In general, much neater workaround should be possible, if we stop relying on cargo-watch
// and do the WASM watch directly in the build script.
let first_build_job = self
.build(context.clone(), job.build.clone())
.instrument(debug_span!("Initial single build of WASM before setting up cargo-watch."));
async move {
let first_build_output = first_build_job.await?;
let WatchTargetJob {
watch_input: WatchInput { cargo_watch_options: cargo_watch_flags },
build: WithDestination { inner, destination },
} = job;
let BuildInput {
crate_path,
wasm_opt_options,
skip_wasm_opt,
extra_cargo_options,
profile,
profiling_level,
log_level,
uncollapsed_log_level,
wasm_size_limit,
system_shader_tools: _,
} = inner;
let current_exe = std::env::current_exe()?;
// cargo-watch apparently cannot handle verbatim path prefix. We remove it and hope for
// the best.
let current_exe = current_exe.without_verbatim_prefix();
let mut watch_cmd = Cargo.cmd()?;
let (watch_cmd_name, mut watch_cmd_opts) = match std::env::var("USE_CARGO_WATCH_PLUS") {
Ok(_) => ("watch-plus", vec!["--why"]),
Err(_) => ("watch", vec![]),
};
watch_cmd_opts.push("--ignore");
watch_cmd_opts.push("README.md");
watch_cmd
.kill_on_drop(true)
.current_dir(&context.repo_root)
.arg(watch_cmd_name)
.args(watch_cmd_opts)
.args(cargo_watch_flags)
.arg("--");
// === Build Script top-level options ===
watch_cmd
// TODO [mwu]
// This is not nice, as this module should not be aware of the CLI
// parsing/g | info!("Compressed size of {} is {}.", wasm_path.as_ref().display(), compressed_size);
if let Some(wasm_size_limit) = self.wasm_size_limit {
let wasm_size_limit = wasm_size_limit.get_appropriate_unit(true); | random_line_split |
wasm.rs | .10.1")?).await?;
let BuildInput {
crate_path,
wasm_opt_options,
skip_wasm_opt,
extra_cargo_options,
profile,
profiling_level,
log_level,
uncollapsed_log_level,
wasm_size_limit: _wasm_size_limit,
system_shader_tools,
} = &inner;
// NOTE: We cannot trust locally installed version of shader tools to be correct.
// Those binaries have no reliable versioning, and existing common distributions (e.g.
// Vulkan SDK) contain old builds with bugs that impact our shaders. By default, we have
// to force usage of our own distribution built on our CI.
if *system_shader_tools {
ShaderTools.install_if_missing(&cache).await?;
} else {
ShaderTools.install(&cache).await?;
}
cache::goodie::binaryen::Binaryen { version: BINARYEN_VERSION_TO_INSTALL }
.install_if_missing(&cache)
.await?;
info!("Building wasm.");
let temp_dir = tempdir()?;
let temp_dist = RepoRootDistWasm::new_root(temp_dir.path());
ensogl_pack::build(
ensogl_pack::WasmPackOutputs {
out_dir: temp_dist.path.clone(),
out_name: OUTPUT_NAME.into(),
},
|args| {
let mut command = WasmPack.cmd()?;
command
.current_dir(&repo_root)
.kill_on_drop(true)
.env_remove(ide_ci::programs::rustup::env::RUSTUP_TOOLCHAIN.name())
.build()
.arg(wasm_pack::Profile::from(*profile))
.target(wasm_pack::Target::Web)
.output_directory(args.out_dir)
.output_name(args.out_name)
.arg(crate_path)
.arg("--")
.apply(&cargo::Color::Always)
.args(extra_cargo_options);
if let Some(profiling_level) = profiling_level {
command.set_env(env::ENSO_MAX_PROFILING_LEVEL, &profiling_level)?;
}
command.set_env(env::ENSO_MAX_LOG_LEVEL, &log_level)?;
command.set_env(env::ENSO_MAX_UNCOLLAPSED_LOG_LEVEL, &uncollapsed_log_level)?;
Ok(command)
},
)
.await?;
Self::finalize_wasm(wasm_opt_options, *skip_wasm_opt, *profile, &temp_dist).await?;
ide_ci::fs::create_dir_if_missing(&destination)?;
let ret = RepoRootDistWasm::new_root(&destination);
ide_ci::fs::copy(&temp_dist, &ret)?;
inner.perhaps_check_size(&ret.pkg_opt_wasm).await?;
Ok(Artifact(ret))
}
.instrument(span)
.boxed()
}
}
#[derive(Clone, Derivative)]
#[derivative(Debug)]
pub struct WatchInput {
pub cargo_watch_options: Vec<String>,
}
impl IsWatchable for Wasm {
type Watcher = crate::project::Watcher<Self, Child>;
type WatchInput = WatchInput;
fn watch(
&self,
context: Context,
job: WatchTargetJob<Self>,
) -> BoxFuture<'static, Result<Self::Watcher>> {
let span = debug_span!("Watching WASM.", ?job).entered();
// The esbuild watcher must succeed in its first build, or it will prematurely exit.
// See the issue: https://github.com/evanw/esbuild/issues/1063
//
// Because of this, we run first build of wasm manually, rather through cargo-watch.
// After it is completed, the cargo-watch gets spawned and this method yields the watcher.
// This forces esbuild watcher (whose setup requires the watcher artifacts) to wait until
// all wasm build outputs are in place, so the build won't crash.
//
// In general, much neater workaround should be possible, if we stop relying on cargo-watch
// and do the WASM watch directly in the build script.
let first_build_job = self
.build(context.clone(), job.build.clone())
.instrument(debug_span!("Initial single build of WASM before setting up cargo-watch."));
async move {
let first_build_output = first_build_job.await?;
let WatchTargetJob {
watch_input: WatchInput { cargo_watch_options: cargo_watch_flags },
build: WithDestination { inner, destination },
} = job;
let BuildInput {
crate_path,
wasm_opt_options,
skip_wasm_opt,
extra_cargo_options,
profile,
profiling_level,
log_level,
uncollapsed_log_level,
wasm_size_limit,
system_shader_tools: _,
} = inner;
let current_exe = std::env::current_exe()?;
// cargo-watch apparently cannot handle verbatim path prefix. We remove it and hope for
// the best.
let current_exe = current_exe.without_verbatim_prefix();
let mut watch_cmd = Cargo.cmd()?;
let (watch_cmd_name, mut watch_cmd_opts) = match std::env::var("USE_CARGO_WATCH_PLUS") {
Ok(_) => ("watch-plus", vec!["--why"]),
Err(_) => ("watch", vec![]),
};
watch_cmd_opts.push("--ignore");
watch_cmd_opts.push("README.md");
watch_cmd
.kill_on_drop(true)
.current_dir(&context.repo_root)
.arg(watch_cmd_name)
.args(watch_cmd_opts)
.args(cargo_watch_flags)
.arg("--");
// === Build Script top-level options ===
watch_cmd
// TODO [mwu]
// This is not nice, as this module should not be aware of the CLI
// parsing/generation. Rather than using `cargo watch` this should
// be implemented directly in Rust.
.arg(current_exe)
.arg("--skip-version-check") // We already checked in the parent process.
.args(["--cache-path", context.cache.path().as_str()])
.args(["--upload-artifacts", context.upload_artifacts.to_string().as_str()])
.args(["--repo-path", context.repo_root.as_str()]);
// === Build Script command and its options ===
watch_cmd
.arg("wasm")
.arg("build")
.args(["--crate-path", crate_path.as_str()])
.args(["--wasm-output-path", destination.as_str()])
.args(["--wasm-profile", profile.as_ref()]);
if let Some(profiling_level) = profiling_level {
watch_cmd.args(["--profiling-level", profiling_level.to_string().as_str()]);
}
watch_cmd.args(["--wasm-log-level", log_level.to_string().as_str()]);
watch_cmd
.args(["--wasm-uncollapsed-log-level", uncollapsed_log_level.to_string().as_str()]);
for wasm_opt_option in wasm_opt_options {
watch_cmd.args(["--wasm-opt-option", &wasm_opt_option]);
}
if skip_wasm_opt {
watch_cmd.args(["--skip-wasm-opt"]);
}
if let Some(wasm_size_limit) = wasm_size_limit {
watch_cmd.args(["--wasm-size-limit", wasm_size_limit.to_string().as_str()]);
} else {
watch_cmd.args(["--wasm-size-limit", "0"]);
}
// === cargo-watch options ===
watch_cmd.arg("--").args(extra_cargo_options);
let watch_process = watch_cmd.spawn_intercepting()?;
let artifact = Artifact(RepoRootDistWasm::new_root(&destination));
ensure!(
artifact == first_build_output,
"First build output does not match general watch build output. First build output: \
{first_build_output:?}, general watch build output: {artifact:?}",
);
Ok(Self::Watcher { artifact, watch_process })
}
.instrument(span.exit())
.boxed()
}
}
#[derive(Clone, Debug, Display, PartialEq, Eq)]
pub struct Artifact(pub RepoRootDistWasm);
impl Artifact {
pub fn new(path: impl Into<PathBuf>) -> Self {
Self(RepoRootDistWasm::new_root(path))
}
/// The main JS bundle to load WASM and JS wasm-pack bundles.
pub fn ensogl_app(&self) -> &Path {
&self.0.index_js
}
/// Files that should be shipped in the Gui bundle.
pub fn files_to_ship(&self) -> Vec<&Path> {
// We explicitly deconstruct object, so when new fields are added, we will be forced to
// consider whether they should be shipped or not.
let RepoRootDistWasm {
path: _,
dynamic_assets,
index_js: _,
index_d_ts: _,
index_js_map: _,
pkg_js,
pkg_js_map,
pkg_wasm: _,
pkg_opt_wasm,
} = &self.0;
vec![
dynamic_assets.as_path(),
pkg_js.as_path(),
pkg_js_map.as_path(),
pkg_opt_wasm.as_path(),
]
}
pub fn symlink_ensogl_dist(&self, linked_dist: &RepoRootTargetEnsoglPackLinkedDist) -> Result {
ide_ci::fs::remove_symlink_dir_if_exists(linked_dist)?;
ide_ci::fs::symlink_auto(self, linked_dist)
}
}
impl AsRef<Path> for Artifact {
fn as_ref(&self) -> &Path {
self.0.as_path()
}
}
impl IsArtifact for Artifact {}
impl Wasm {
pub async fn | check | identifier_name |
|
wasm.rs | artifacts) to wait until
// all wasm build outputs are in place, so the build won't crash.
//
// In general, much neater workaround should be possible, if we stop relying on cargo-watch
// and do the WASM watch directly in the build script.
let first_build_job = self
.build(context.clone(), job.build.clone())
.instrument(debug_span!("Initial single build of WASM before setting up cargo-watch."));
async move {
let first_build_output = first_build_job.await?;
let WatchTargetJob {
watch_input: WatchInput { cargo_watch_options: cargo_watch_flags },
build: WithDestination { inner, destination },
} = job;
let BuildInput {
crate_path,
wasm_opt_options,
skip_wasm_opt,
extra_cargo_options,
profile,
profiling_level,
log_level,
uncollapsed_log_level,
wasm_size_limit,
system_shader_tools: _,
} = inner;
let current_exe = std::env::current_exe()?;
// cargo-watch apparently cannot handle verbatim path prefix. We remove it and hope for
// the best.
let current_exe = current_exe.without_verbatim_prefix();
let mut watch_cmd = Cargo.cmd()?;
let (watch_cmd_name, mut watch_cmd_opts) = match std::env::var("USE_CARGO_WATCH_PLUS") {
Ok(_) => ("watch-plus", vec!["--why"]),
Err(_) => ("watch", vec![]),
};
watch_cmd_opts.push("--ignore");
watch_cmd_opts.push("README.md");
watch_cmd
.kill_on_drop(true)
.current_dir(&context.repo_root)
.arg(watch_cmd_name)
.args(watch_cmd_opts)
.args(cargo_watch_flags)
.arg("--");
// === Build Script top-level options ===
watch_cmd
// TODO [mwu]
// This is not nice, as this module should not be aware of the CLI
// parsing/generation. Rather than using `cargo watch` this should
// be implemented directly in Rust.
.arg(current_exe)
.arg("--skip-version-check") // We already checked in the parent process.
.args(["--cache-path", context.cache.path().as_str()])
.args(["--upload-artifacts", context.upload_artifacts.to_string().as_str()])
.args(["--repo-path", context.repo_root.as_str()]);
// === Build Script command and its options ===
watch_cmd
.arg("wasm")
.arg("build")
.args(["--crate-path", crate_path.as_str()])
.args(["--wasm-output-path", destination.as_str()])
.args(["--wasm-profile", profile.as_ref()]);
if let Some(profiling_level) = profiling_level {
watch_cmd.args(["--profiling-level", profiling_level.to_string().as_str()]);
}
watch_cmd.args(["--wasm-log-level", log_level.to_string().as_str()]);
watch_cmd
.args(["--wasm-uncollapsed-log-level", uncollapsed_log_level.to_string().as_str()]);
for wasm_opt_option in wasm_opt_options {
watch_cmd.args(["--wasm-opt-option", &wasm_opt_option]);
}
if skip_wasm_opt {
watch_cmd.args(["--skip-wasm-opt"]);
}
if let Some(wasm_size_limit) = wasm_size_limit {
watch_cmd.args(["--wasm-size-limit", wasm_size_limit.to_string().as_str()]);
} else {
watch_cmd.args(["--wasm-size-limit", "0"]);
}
// === cargo-watch options ===
watch_cmd.arg("--").args(extra_cargo_options);
let watch_process = watch_cmd.spawn_intercepting()?;
let artifact = Artifact(RepoRootDistWasm::new_root(&destination));
ensure!(
artifact == first_build_output,
"First build output does not match general watch build output. First build output: \
{first_build_output:?}, general watch build output: {artifact:?}",
);
Ok(Self::Watcher { artifact, watch_process })
}
.instrument(span.exit())
.boxed()
}
}
#[derive(Clone, Debug, Display, PartialEq, Eq)]
pub struct Artifact(pub RepoRootDistWasm);
impl Artifact {
pub fn new(path: impl Into<PathBuf>) -> Self {
Self(RepoRootDistWasm::new_root(path))
}
/// The main JS bundle to load WASM and JS wasm-pack bundles.
pub fn ensogl_app(&self) -> &Path {
&self.0.index_js
}
/// Files that should be shipped in the Gui bundle.
pub fn files_to_ship(&self) -> Vec<&Path> {
// We explicitly deconstruct object, so when new fields are added, we will be forced to
// consider whether they should be shipped or not.
let RepoRootDistWasm {
path: _,
dynamic_assets,
index_js: _,
index_d_ts: _,
index_js_map: _,
pkg_js,
pkg_js_map,
pkg_wasm: _,
pkg_opt_wasm,
} = &self.0;
vec![
dynamic_assets.as_path(),
pkg_js.as_path(),
pkg_js_map.as_path(),
pkg_opt_wasm.as_path(),
]
}
pub fn symlink_ensogl_dist(&self, linked_dist: &RepoRootTargetEnsoglPackLinkedDist) -> Result {
ide_ci::fs::remove_symlink_dir_if_exists(linked_dist)?;
ide_ci::fs::symlink_auto(self, linked_dist)
}
}
impl AsRef<Path> for Artifact {
fn as_ref(&self) -> &Path {
self.0.as_path()
}
}
impl IsArtifact for Artifact {}
impl Wasm {
pub async fn check(&self) -> Result {
Cargo
.cmd()?
.apply(&cargo::Command::Check)
.apply(&cargo::Options::Workspace)
.apply(&cargo::Options::Package(INTEGRATION_TESTS_CRATE_NAME.into()))
.apply(&cargo::Options::AllTargets)
.run_ok()
.await
}
pub async fn test(&self, repo_root: PathBuf, wasm: &[test::Browser], native: bool) -> Result {
async fn maybe_run<Fut: Future<Output = Result>>(
name: &str,
enabled: bool,
f: impl (FnOnce() -> Fut),
) -> Result {
if enabled {
info!("Will run {name} tests.");
f().await.context(format!("Running {name} tests."))
} else {
info!("Skipping {name} tests.");
Ok(())
}
}
maybe_run("native", native, async || {
Cargo
.cmd()?
.current_dir(repo_root.clone())
.apply(&cargo::Command::Test)
.apply(&cargo::Options::Workspace)
// Color needs to be passed to tests themselves separately.
// See: https://github.com/rust-lang/cargo/issues/1983
.arg("--")
.apply(&cargo::Color::Always)
.run_ok()
.await
})
.await?;
maybe_run("wasm", !wasm.is_empty(), || test::test_all(repo_root.clone(), wasm)).await?;
Ok(())
}
pub async fn integration_test(
&self,
source_root: PathBuf,
_project_manager: Option<Child>,
headless: bool,
additional_options: Vec<String>,
wasm_timeout: Option<Duration>,
) -> Result {
info!("Running Rust WASM test suite.");
use wasm_pack::TestFlags::*;
WasmPack
.cmd()?
.current_dir(source_root)
.set_env_opt(
env::WASM_BINDGEN_TEST_TIMEOUT,
wasm_timeout.map(|d| d.as_secs()).as_ref(),
)?
.test()
.apply_opt(headless.then_some(&Headless))
.apply(&test::BROWSER_FOR_WASM_TESTS)
.arg("integration-test")
.arg("--profile=integration-test")
.args(additional_options)
.run_ok()
.await
// PM will be automatically killed by dropping the handle.
}
/// Process "raw" WASM (as compiled) by optionally invoking wasm-opt.
pub async fn finalize_wasm(
wasm_opt_options: &[String],
skip_wasm_opt: bool,
profile: Profile,
temp_dist: &RepoRootDistWasm,
) -> Result {
let should_call_wasm_opt = {
if profile == Profile::Dev {
debug!("Skipping wasm-opt invocation, as it is not part of profile {profile}.");
false
} else if skip_wasm_opt {
debug!("Skipping wasm-opt invocation, as it was explicitly requested.");
false
} else {
true
}
};
if should_call_wasm_opt | {
let mut wasm_opt_command = WasmOpt.cmd()?;
let has_custom_opt_level = wasm_opt_options.iter().any(|opt| {
wasm_opt::OptimizationLevel::from_str(opt.trim_start_matches('-')).is_ok()
});
if !has_custom_opt_level {
wasm_opt_command.apply(&profile.optimization_level());
}
wasm_opt_command
.args(wasm_opt_options)
.arg(&temp_dist.pkg_wasm)
.apply(&wasm_opt::Output(&temp_dist.pkg_opt_wasm))
.run_ok()
.await?;
} | conditional_block |
|
server.rs | state (which can be safely lost) and persistent
/// state (which must be carefully stored and kept safe).
///
/// Currently, the `Server` API is not well defined. **We are looking for feedback and suggestions.**
pub struct Server<S, M> where S: Store, M: StateMachine {
replica: Replica<S, M>,
// Channels and Sockets
listener: NonBlock<TcpListener>,
connections: Slab<Connection>,
}
/// The implementation of the Server. In most use cases, creating a `Server` should just be
/// done via `::new()`.
impl<S, M> Server<S, M> where S: Store, M: StateMachine {
/// Creates a new Raft node with the cluster members specified.
///
/// # Arguments
///
/// * `addr` - The address of the new node.
/// * `peers` - The address of all peers in the Raft cluster.
/// * `store` - The persitent log store.
/// * `state_machine` - The client state machine to which client commands will be applied.
pub fn spawn(addr: SocketAddr,
peers: HashSet<SocketAddr>,
store: S,
state_machine: M) {
debug!("Spawning Server");
// Create an event loop
let mut event_loop = EventLoop::<Server<S, M>>::new().unwrap();
// Setup the socket, make it not block.
let listener = listen(&addr).unwrap();
listener.set_reuseaddr(true).unwrap();
event_loop.register(&listener, LISTENER).unwrap();
let timeout = rand::thread_rng().gen_range::<u64>(ELECTION_MIN, ELECTION_MAX);
event_loop.timeout_ms(ELECTION_TIMEOUT, timeout).unwrap();
event_loop.timeout_ms(HEARTBEAT_TIMEOUT, HEARTBEAT_DURATION).unwrap();
let replica = Replica::new(addr, peers, store, state_machine);
// Fire up the thread.
thread::Builder::new().name(format!("Server {}", addr)).spawn(move || {
let mut raft_node = Server {
listener: listener,
replica: replica,
connections: Slab::new_starting_at(Token(2), 128),
};
event_loop.run(&mut raft_node).unwrap();
}).unwrap();
}
}
impl<S, M> Handler for Server<S, M> where S: Store, M: StateMachine {
type Message = RingBuf;
type Timeout = Token;
/// A registered IoHandle has available writing space.
fn writable(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token) {
debug!("Writeable");
match token {
ELECTION_TIMEOUT => unreachable!(),
HEARTBEAT_TIMEOUT => unreachable!(),
LISTENER => unreachable!(),
tok => {
self.connections[tok].writable(reactor, &mut self.replica).unwrap();
}
}
}
/// A registered IoHandle has available data to read
fn readable(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token, _hint: ReadHint) {
debug!("Readable");
match token {
ELECTION_TIMEOUT => unreachable!(),
HEARTBEAT_TIMEOUT => unreachable!(),
LISTENER => {
let stream = match self.listener.accept().unwrap() {
Some(s) => s,
None => return, // Socket isn't quite ready.
}; // Result<Option<_>,_>
let conn = Connection::new(stream);
let tok = self.connections.insert(conn)
.ok().expect("Could not add connection to slab.");
// Register the connection
self.connections[tok].token = tok;
reactor.register_opt(&self.connections[tok].stream, tok, Interest::readable(), PollOpt::edge() | PollOpt::oneshot())
.ok().expect("Could not register socket with event loop.");
},
tok => {
self.connections[tok].readable(reactor, &mut self.replica).unwrap();
}
}
}
/// A registered timer has expired. This is either:
///
/// * An election timeout, when a `Follower` node has waited too long for a heartbeat and doing
/// to become a `Candidate`.
/// * A heartbeat timeout, when the `Leader` node needs to refresh it's authority over the
/// followers. Initializes and sends an `AppendEntries` request to all followers.
fn timeout(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token) {
debug!("Timeout");
let mut message = MallocMessageBuilder::new_default();
let mut send_message = None;
match token {
ELECTION_TIMEOUT => {
let request = message.init_root::<rpc_request::Builder>();
send_message = self.replica.election_timeout(request.init_request_vote());
// Set timeout.
let timeout = rand::thread_rng().gen_range::<u64>(ELECTION_MIN, ELECTION_MAX);
reactor.timeout_ms(ELECTION_TIMEOUT, timeout).unwrap();
},
HEARTBEAT_TIMEOUT => {
let request = message.init_root::<rpc_request::Builder>();
send_message = self.replica.heartbeat_timeout(request.init_append_entries());
// Set Timeout
reactor.timeout_ms(HEARTBEAT_TIMEOUT, HEARTBEAT_DURATION).unwrap();
},
_ => unreachable!(),
}
// Send if necessary.
match send_message {
Some(Broadcast) => {
let mut buf = RingBuf::new(RINGBUF_SIZE);
serialize_packed::write_message(
&mut buf,
&mut message
).unwrap();
for connection in self.connections.iter_mut() {
connection.add_write(buf.clone());
}
},
None => (),
}
}
}
struct Connection {
stream: NonBlock<TcpStream>,
token: Token,
interest: Interest,
current_read: BufReader<RingBuf>,
current_write: BufReader<RingBuf>,
next_write: VecDeque<RingBuf>,
}
impl Connection {
/// Note: The caller must manually assign `token` to what is desired.
fn new(sock: NonBlock<TcpStream>) -> Connection {
Connection {
stream: sock,
token: Token(0), // Effectively a `null`. This needs to be assigned by the caller.
interest: Interest::hup(),
current_read: BufReader::new(RingBuf::new(4096)),
current_write: BufReader::new(RingBuf::new(4096)),
next_write: VecDeque::with_capacity(10),
}
}
/// A registered IoHandle has available writing space.
fn | <S, M>(&mut self, event_loop: &mut EventLoop<Server<S, M>>, replica: &mut Replica<S,M>)
-> Result<()>
where S: Store, M: StateMachine {
// Attempt to write data.
// The `current_write` buffer will be advanced based on how much we wrote.
match self.stream.write(self.current_write.get_mut()) {
Ok(None) => {
// This is a buffer flush. WOULDBLOCK
self.interest.insert(Interest::writable());
},
Ok(Some(r)) => {
// We managed to write data!
match (self.current_write.get_ref().has_remaining(), self.next_write.is_empty()) {
// Need to write more of what we have.
(true, _) => (),
// Need to roll over.
(false, false) => self.current_write = BufReader::new(self.next_write.pop_front().unwrap()),
// We're done writing for now.
(false, true) => self.interest.remove(Interest::writable()),
}
},
Err(e) => return Err(Error::from(e)),
}
match event_loop.reregister(&self.stream, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) {
Ok(()) => Ok(()),
Err(e) => Err(Error::from(e)),
}
}
/// A registered IoHandle has available data to read.
/// This does not necessarily mean that there is an entire packed item on the stream. We could
/// get some, all of it, or none. We'll use the buffer to read in until we can find one.
fn readable<S, M>(&mut self, event_loop: &mut EventLoop<Server<S, M>>, replica: &mut Replica<S,M>)
-> Result<()>
where S: Store, M: StateMachine {
let mut read = 0;
match self.stream.read(self.current_read.get_mut()) {
Ok(Some(r)) => {
// Just read `r` bytes.
read = r;
},
Ok(None) => panic!("We just got readable, but were unable to read from the socket?"),
Err(e) => return Err(Error::from(e)),
};
if read > 0 {
match serialize_packed::read_message(&mut self.current_read, ReaderOptions::new()) {
// We have something reasonably interesting in the buffer!
Ok(reader) => {
self.handle_reader(reader, event_loop, replica);
},
// It's not read entirely yet.
// Should roll back, pending changes to bytes upstream.
// TODO: This was fixed.
Err(_) => unimplemented!(),
}
}
match event_loop.reregister(&self.stream, self.token, self.interest, PollOpt::edge()) {
Ok(()) => Ok(()),
Err(e | writable | identifier_name |
server.rs | state (which can be safely lost) and persistent
/// state (which must be carefully stored and kept safe).
///
/// Currently, the `Server` API is not well defined. **We are looking for feedback and suggestions.**
pub struct Server<S, M> where S: Store, M: StateMachine {
replica: Replica<S, M>,
// Channels and Sockets
listener: NonBlock<TcpListener>,
connections: Slab<Connection>,
}
/// The implementation of the Server. In most use cases, creating a `Server` should just be
/// done via `::new()`.
impl<S, M> Server<S, M> where S: Store, M: StateMachine {
/// Creates a new Raft node with the cluster members specified.
///
/// # Arguments
///
/// * `addr` - The address of the new node.
/// * `peers` - The address of all peers in the Raft cluster.
/// * `store` - The persitent log store.
/// * `state_machine` - The client state machine to which client commands will be applied.
pub fn spawn(addr: SocketAddr,
peers: HashSet<SocketAddr>,
store: S,
state_machine: M) {
debug!("Spawning Server");
// Create an event loop
let mut event_loop = EventLoop::<Server<S, M>>::new().unwrap();
// Setup the socket, make it not block.
let listener = listen(&addr).unwrap();
listener.set_reuseaddr(true).unwrap();
event_loop.register(&listener, LISTENER).unwrap();
let timeout = rand::thread_rng().gen_range::<u64>(ELECTION_MIN, ELECTION_MAX);
event_loop.timeout_ms(ELECTION_TIMEOUT, timeout).unwrap();
event_loop.timeout_ms(HEARTBEAT_TIMEOUT, HEARTBEAT_DURATION).unwrap();
let replica = Replica::new(addr, peers, store, state_machine);
// Fire up the thread.
thread::Builder::new().name(format!("Server {}", addr)).spawn(move || {
let mut raft_node = Server {
listener: listener,
replica: replica,
connections: Slab::new_starting_at(Token(2), 128),
};
event_loop.run(&mut raft_node).unwrap();
}).unwrap();
}
}
impl<S, M> Handler for Server<S, M> where S: Store, M: StateMachine {
type Message = RingBuf;
type Timeout = Token;
/// A registered IoHandle has available writing space.
fn writable(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token) {
debug!("Writeable");
match token {
ELECTION_TIMEOUT => unreachable!(),
HEARTBEAT_TIMEOUT => unreachable!(),
LISTENER => unreachable!(),
tok => {
self.connections[tok].writable(reactor, &mut self.replica).unwrap();
}
}
}
/// A registered IoHandle has available data to read
fn readable(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token, _hint: ReadHint) {
debug!("Readable");
match token {
ELECTION_TIMEOUT => unreachable!(),
HEARTBEAT_TIMEOUT => unreachable!(),
LISTENER => {
let stream = match self.listener.accept().unwrap() {
Some(s) => s,
None => return, // Socket isn't quite ready.
}; // Result<Option<_>,_>
let conn = Connection::new(stream);
let tok = self.connections.insert(conn)
.ok().expect("Could not add connection to slab.");
// Register the connection
self.connections[tok].token = tok;
reactor.register_opt(&self.connections[tok].stream, tok, Interest::readable(), PollOpt::edge() | PollOpt::oneshot())
.ok().expect("Could not register socket with event loop.");
},
tok => {
self.connections[tok].readable(reactor, &mut self.replica).unwrap();
}
}
}
/// A registered timer has expired. This is either:
///
/// * An election timeout, when a `Follower` node has waited too long for a heartbeat and doing
/// to become a `Candidate`.
/// * A heartbeat timeout, when the `Leader` node needs to refresh it's authority over the
/// followers. Initializes and sends an `AppendEntries` request to all followers.
fn timeout(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token) {
debug!("Timeout");
let mut message = MallocMessageBuilder::new_default();
let mut send_message = None;
match token {
ELECTION_TIMEOUT => {
let request = message.init_root::<rpc_request::Builder>();
send_message = self.replica.election_timeout(request.init_request_vote());
// Set timeout.
let timeout = rand::thread_rng().gen_range::<u64>(ELECTION_MIN, ELECTION_MAX);
reactor.timeout_ms(ELECTION_TIMEOUT, timeout).unwrap();
},
HEARTBEAT_TIMEOUT => {
let request = message.init_root::<rpc_request::Builder>();
send_message = self.replica.heartbeat_timeout(request.init_append_entries());
// Set Timeout
reactor.timeout_ms(HEARTBEAT_TIMEOUT, HEARTBEAT_DURATION).unwrap();
},
_ => unreachable!(),
}
// Send if necessary.
match send_message {
Some(Broadcast) => {
let mut buf = RingBuf::new(RINGBUF_SIZE);
serialize_packed::write_message(
&mut buf,
&mut message
).unwrap();
for connection in self.connections.iter_mut() {
connection.add_write(buf.clone());
}
},
None => (),
}
}
}
struct Connection {
stream: NonBlock<TcpStream>,
token: Token,
interest: Interest,
current_read: BufReader<RingBuf>,
current_write: BufReader<RingBuf>,
next_write: VecDeque<RingBuf>,
}
impl Connection {
/// Note: The caller must manually assign `token` to what is desired.
fn new(sock: NonBlock<TcpStream>) -> Connection {
Connection {
stream: sock,
token: Token(0), // Effectively a `null`. This needs to be assigned by the caller.
interest: Interest::hup(),
current_read: BufReader::new(RingBuf::new(4096)),
current_write: BufReader::new(RingBuf::new(4096)),
next_write: VecDeque::with_capacity(10),
}
}
/// A registered IoHandle has available writing space.
fn writable<S, M>(&mut self, event_loop: &mut EventLoop<Server<S, M>>, replica: &mut Replica<S,M>)
-> Result<()>
where S: Store, M: StateMachine {
// Attempt to write data.
// The `current_write` buffer will be advanced based on how much we wrote.
match self.stream.write(self.current_write.get_mut()) {
Ok(None) => {
// This is a buffer flush. WOULDBLOCK
self.interest.insert(Interest::writable());
},
Ok(Some(r)) => {
// We managed to write data!
match (self.current_write.get_ref().has_remaining(), self.next_write.is_empty()) {
// Need to write more of what we have.
(true, _) => (),
// Need to roll over.
(false, false) => self.current_write = BufReader::new(self.next_write.pop_front().unwrap()),
// We're done writing for now.
(false, true) => self.interest.remove(Interest::writable()),
}
},
Err(e) => return Err(Error::from(e)),
}
match event_loop.reregister(&self.stream, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) {
Ok(()) => Ok(()),
Err(e) => Err(Error::from(e)),
}
}
/// A registered IoHandle has available data to read.
/// This does not necessarily mean that there is an entire packed item on the stream. We could
/// get some, all of it, or none. We'll use the buffer to read in until we can find one. | -> Result<()>
where S: Store, M: StateMachine {
let mut read = 0;
match self.stream.read(self.current_read.get_mut()) {
Ok(Some(r)) => {
// Just read `r` bytes.
read = r;
},
Ok(None) => panic!("We just got readable, but were unable to read from the socket?"),
Err(e) => return Err(Error::from(e)),
};
if read > 0 {
match serialize_packed::read_message(&mut self.current_read, ReaderOptions::new()) {
// We have something reasonably interesting in the buffer!
Ok(reader) => {
self.handle_reader(reader, event_loop, replica);
},
// It's not read entirely yet.
// Should roll back, pending changes to bytes upstream.
// TODO: This was fixed.
Err(_) => unimplemented!(),
}
}
match event_loop.reregister(&self.stream, self.token, self.interest, PollOpt::edge()) {
Ok(()) => Ok(()),
Err(e) => | fn readable<S, M>(&mut self, event_loop: &mut EventLoop<Server<S, M>>, replica: &mut Replica<S,M>) | random_line_split |
server.rs | Handler for Server<S, M> where S: Store, M: StateMachine {
type Message = RingBuf;
type Timeout = Token;
/// A registered IoHandle has available writing space.
fn writable(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token) {
debug!("Writeable");
match token {
ELECTION_TIMEOUT => unreachable!(),
HEARTBEAT_TIMEOUT => unreachable!(),
LISTENER => unreachable!(),
tok => {
self.connections[tok].writable(reactor, &mut self.replica).unwrap();
}
}
}
/// A registered IoHandle has available data to read
fn readable(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token, _hint: ReadHint) {
debug!("Readable");
match token {
ELECTION_TIMEOUT => unreachable!(),
HEARTBEAT_TIMEOUT => unreachable!(),
LISTENER => {
let stream = match self.listener.accept().unwrap() {
Some(s) => s,
None => return, // Socket isn't quite ready.
}; // Result<Option<_>,_>
let conn = Connection::new(stream);
let tok = self.connections.insert(conn)
.ok().expect("Could not add connection to slab.");
// Register the connection
self.connections[tok].token = tok;
reactor.register_opt(&self.connections[tok].stream, tok, Interest::readable(), PollOpt::edge() | PollOpt::oneshot())
.ok().expect("Could not register socket with event loop.");
},
tok => {
self.connections[tok].readable(reactor, &mut self.replica).unwrap();
}
}
}
/// A registered timer has expired. This is either:
///
/// * An election timeout, when a `Follower` node has waited too long for a heartbeat and doing
/// to become a `Candidate`.
/// * A heartbeat timeout, when the `Leader` node needs to refresh it's authority over the
/// followers. Initializes and sends an `AppendEntries` request to all followers.
fn timeout(&mut self, reactor: &mut EventLoop<Server<S, M>>, token: Token) {
debug!("Timeout");
let mut message = MallocMessageBuilder::new_default();
let mut send_message = None;
match token {
ELECTION_TIMEOUT => {
let request = message.init_root::<rpc_request::Builder>();
send_message = self.replica.election_timeout(request.init_request_vote());
// Set timeout.
let timeout = rand::thread_rng().gen_range::<u64>(ELECTION_MIN, ELECTION_MAX);
reactor.timeout_ms(ELECTION_TIMEOUT, timeout).unwrap();
},
HEARTBEAT_TIMEOUT => {
let request = message.init_root::<rpc_request::Builder>();
send_message = self.replica.heartbeat_timeout(request.init_append_entries());
// Set Timeout
reactor.timeout_ms(HEARTBEAT_TIMEOUT, HEARTBEAT_DURATION).unwrap();
},
_ => unreachable!(),
}
// Send if necessary.
match send_message {
Some(Broadcast) => {
let mut buf = RingBuf::new(RINGBUF_SIZE);
serialize_packed::write_message(
&mut buf,
&mut message
).unwrap();
for connection in self.connections.iter_mut() {
connection.add_write(buf.clone());
}
},
None => (),
}
}
}
struct Connection {
stream: NonBlock<TcpStream>,
token: Token,
interest: Interest,
current_read: BufReader<RingBuf>,
current_write: BufReader<RingBuf>,
next_write: VecDeque<RingBuf>,
}
impl Connection {
/// Note: The caller must manually assign `token` to what is desired.
fn new(sock: NonBlock<TcpStream>) -> Connection {
Connection {
stream: sock,
token: Token(0), // Effectively a `null`. This needs to be assigned by the caller.
interest: Interest::hup(),
current_read: BufReader::new(RingBuf::new(4096)),
current_write: BufReader::new(RingBuf::new(4096)),
next_write: VecDeque::with_capacity(10),
}
}
/// A registered IoHandle has available writing space.
fn writable<S, M>(&mut self, event_loop: &mut EventLoop<Server<S, M>>, replica: &mut Replica<S,M>)
-> Result<()>
where S: Store, M: StateMachine {
// Attempt to write data.
// The `current_write` buffer will be advanced based on how much we wrote.
match self.stream.write(self.current_write.get_mut()) {
Ok(None) => {
// This is a buffer flush. WOULDBLOCK
self.interest.insert(Interest::writable());
},
Ok(Some(r)) => {
// We managed to write data!
match (self.current_write.get_ref().has_remaining(), self.next_write.is_empty()) {
// Need to write more of what we have.
(true, _) => (),
// Need to roll over.
(false, false) => self.current_write = BufReader::new(self.next_write.pop_front().unwrap()),
// We're done writing for now.
(false, true) => self.interest.remove(Interest::writable()),
}
},
Err(e) => return Err(Error::from(e)),
}
match event_loop.reregister(&self.stream, self.token, self.interest, PollOpt::edge() | PollOpt::oneshot()) {
Ok(()) => Ok(()),
Err(e) => Err(Error::from(e)),
}
}
/// A registered IoHandle has available data to read.
/// This does not necessarily mean that there is an entire packed item on the stream. We could
/// get some, all of it, or none. We'll use the buffer to read in until we can find one.
fn readable<S, M>(&mut self, event_loop: &mut EventLoop<Server<S, M>>, replica: &mut Replica<S,M>)
-> Result<()>
where S: Store, M: StateMachine {
let mut read = 0;
match self.stream.read(self.current_read.get_mut()) {
Ok(Some(r)) => {
// Just read `r` bytes.
read = r;
},
Ok(None) => panic!("We just got readable, but were unable to read from the socket?"),
Err(e) => return Err(Error::from(e)),
};
if read > 0 {
match serialize_packed::read_message(&mut self.current_read, ReaderOptions::new()) {
// We have something reasonably interesting in the buffer!
Ok(reader) => {
self.handle_reader(reader, event_loop, replica);
},
// It's not read entirely yet.
// Should roll back, pending changes to bytes upstream.
// TODO: This was fixed.
Err(_) => unimplemented!(),
}
}
match event_loop.reregister(&self.stream, self.token, self.interest, PollOpt::edge()) {
Ok(()) => Ok(()),
Err(e) => Err(Error::from(e)),
}
}
/// This is called when there is a full reader available in the buffer.
/// It handles what to do with the data.
fn handle_reader<S, M>(&mut self, reader: OwnedSpaceMessageReader,
event_loop: &mut EventLoop<Server<S, M>>, replica: &mut Replica<S,M>)
where S: Store, M: StateMachine {
let mut builder_message = MallocMessageBuilder::new_default();
let from = self.stream.peer_addr().unwrap();
if let Ok(request) = reader.get_root::<rpc_request::Reader>() {
match request.which().unwrap() {
// TODO: Move these into replica?
rpc_request::Which::AppendEntries(Ok(call)) => {
let builder = builder_message.init_root::<append_entries_response::Builder>();
match replica.append_entries_request(from, call, builder) {
Some(Emit) => {
// Special Cirsumstance Detection
unimplemented!();
},
None => (),
}
},
rpc_request::Which::RequestVote(Ok(call)) => {
let respond = {
let builder = builder_message.init_root::<request_vote_response::Builder>();
replica.request_vote_request(from, call, builder)
};
match respond {
Some(Emit) => {
// TODO
self.emit(builder_message);
},
None => (),
}
},
_ => unimplemented!(),
};
} else if let Ok(response) = reader.get_root::<rpc_response::Reader>() {
// We won't be responding. This is already a response.
match response.which().unwrap() {
rpc_response::Which::AppendEntries(Ok(call)) => {
let respond = {
let builder = builder_message.init_root::<append_entries_request::Builder>();
replica.append_entries_response(from, call, builder)
};
match respond {
Some(Emit) => {
// TODO
self.emit(builder_message);
},
None => (),
}
},
rpc_response::Which::RequestVote(Ok(call)) => {
let respond = {
let builder = builder_message.init_root::<append_entries_request::Builder>();
replica.request_vote_response(from, call, builder)
};
match respond {
Some(Broadcast) => | {
// Won an election!
self.broadcast(builder_message);
} | conditional_block |
|
group.rs | 't contain central inversion.
fn quaternions(self, left: bool) -> Box<dyn GroupIter> {
if self.dim != 3 {
panic!("Quaternions can only be generated from 3D matrices.");
}
Box::new(
self.rotations()
.map(move |el| quat_to_mat(mat_to_quat(el), left)),
)
}
/// Returns the swirl symmetry group of two 3D groups.
pub fn swirl(g: Self, h: Self) -> Self {
if g.dim != 3 {
panic!("g must be a group of 3D matrices.");
}
if h.dim != 3 {
panic!("h must be a group of 3D matrices.");
}
Self {
dim: 4,
iter: Box::new(
itertools::iproduct!(g.quaternions(true), h.quaternions(false))
.map(|(mat1, mat2)| {
let mat = mat1 * mat2;
std::iter::once(mat.clone()).chain(std::iter::once(-mat))
})
.flatten(),
),
}
}
/// Returns a new group whose elements have all been generated already, so
/// that they can be used multiple times quickly.
pub fn cache(self) -> Self {
self.elements().into()
}
/// Returns the exact same group, but now asserts that each generated
/// element has the appropriate dimension. Used for debugging purposes.
pub fn debug(self) -> Self |
/// Generates the trivial group of a certain dimension.
pub fn trivial(dim: usize) -> Self {
Self {
dim,
iter: Box::new(std::iter::once(Matrix::identity(dim, dim))),
}
}
/// Generates the group with the identity and a central inversion of a
/// certain dimension.
pub fn central_inv(dim: usize) -> Self {
Self {
dim,
iter: Box::new(
vec![Matrix::identity(dim, dim), -Matrix::identity(dim, dim)].into_iter(),
),
}
}
/// Generates a step prism group from a base group and a homomorphism into
/// another group.
pub fn step(g: Self, f: impl Fn(Matrix<f64>) -> Matrix<f64> + Clone + 'static) -> Self {
let dim = g.dim * 2;
Self {
dim,
iter: Box::new(g.map(move |mat| {
let clone = mat.clone();
direct_sum(clone, f(mat))
})),
}
}
/// Generates a Coxeter group from its [`CoxMatrix`], or returns `None` if
/// the group doesn't fit as a matrix group in spherical space.
pub fn cox_group(cox: CoxMatrix) -> Option<Self> {
Some(Self {
dim: cox.nrows(),
iter: Box::new(GenIter::from_cox_mat(cox)?),
})
}
/// Generates the direct product of two groups. Uses the specified function
/// to uniquely map the ordered pairs of matrices into other matrices.
pub fn fn_product(
g: Self,
h: Self,
dim: usize,
product: (impl Fn((Matrix<f64>, Matrix<f64>)) -> Matrix<f64> + Clone + 'static),
) -> Self {
Self {
dim,
iter: Box::new(itertools::iproduct!(g, h).map(product)),
}
}
/// Returns the group determined by all products between elements of the
/// first and the second group. **Is meant only for groups that commute with
/// one another.**
pub fn matrix_product(g: Self, h: Self) -> Option<Self> {
// The two matrices must have the same size.
if g.dim != h.dim {
return None;
}
let dim = g.dim;
Some(Self::fn_product(g, h, dim, |(mat1, mat2)| mat1 * mat2))
}
/// Calculates the direct product of two groups. Pairs of matrices are then
/// mapped to their direct sum.
pub fn direct_product(g: Self, h: Self) -> Self {
let dim = g.dim + h.dim;
Self::fn_product(g, h, dim, |(mat1, mat2)| direct_sum(mat1, mat2))
}
/// Generates the [wreath product](https://en.wikipedia.org/wiki/Wreath_product)
/// of two symmetry groups.
pub fn wreath(g: Self, h: Self) -> Self {
let h = h.elements();
let h_len = h.len();
let g_dim = g.dim;
let dim = g_dim * h_len;
// Indexes each element in h.
let mut h_indices = BTreeMap::new();
for (i, h_el) in h.iter().enumerate() {
h_indices.insert(OrdMatrix::new(h_el.clone()), i);
}
// Converts h into a permutation group.
let mut permutations = Vec::with_capacity(h_len);
for h_el_1 in &h {
let mut perm = Vec::with_capacity(h.len());
for h_el_2 in &h {
perm.push(
*h_indices
.get(&OrdMatrix::new(h_el_1 * h_el_2))
.expect("h is not a valid group!"),
);
}
permutations.push(perm);
}
// Computes the direct product of g with itself |h| times.
let g_prod = vec![&g; h_len - 1]
.into_iter()
.cloned()
.fold(g.clone(), |acc, g| Group::direct_product(g, acc));
Self {
dim,
iter: Box::new(
g_prod
.map(move |g_el| {
let mut matrices = Vec::new();
for perm in &permutations {
let mut new_el = Matrix::zeros(dim, dim);
// Permutes the blocks on the diagonal of g_el.
for (i, &j) in perm.iter().enumerate() {
for x in 0..g_dim {
for y in 0..g_dim {
new_el[(i * g_dim + x, j * g_dim + y)] =
g_el[(i * g_dim + x, i * g_dim + y)];
}
}
}
matrices.push(new_el);
}
matrices.into_iter()
})
.flatten(),
),
}
}
/// Generates the orbit of a point under a given symmetry group.
pub fn orbit(self, p: Point) -> Vec<Point> {
let mut points = BTreeSet::new();
for m in self {
points.insert(OrdPoint::new(m * &p));
}
points.into_iter().map(|x| x.0).collect()
}
/// Generates a polytope as the convex hull of the orbit of a point under a
/// given symmetry group.
pub fn into_polytope(self, p: Point) -> Concrete {
convex::convex_hull(self.orbit(p))
}
}
impl From<Vec<Matrix<f64>>> for Group {
fn from(elements: Vec<Matrix<f64>>) -> Self {
Self {
dim: elements
.get(0)
.expect("Group must have at least one element.")
.nrows(),
iter: Box::new(elements.into_iter()),
}
}
}
/// The result of trying to get the next element in a group.
pub enum GroupNext {
/// We've already found all elements of the group.
None,
/// We found an element we had found previously.
Repeat,
/// We found a new element.
New(Matrix<f64>),
}
#[allow(clippy::upper_case_acronyms)]
type MatrixMN<R, C> = nalgebra::Matrix<f64, R, C, VecStorage<f64, R, C>>;
#[derive(Clone, Debug)]
#[allow(clippy::upper_case_acronyms)]
/// A matrix ordered by fuzzy lexicographic ordering. Used to quickly
/// determine whether an element in a [`GenIter`](GenIter) is a
/// duplicate.
pub struct OrdMatrixMN<R: Dim, C: Dim>(pub MatrixMN<R, C>)
where
VecStorage<f64, R, C>: Storage<f64, R, C>;
impl<R: Dim, C: Dim> std::ops::Deref for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
type Target = MatrixMN<R, C>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<R: Dim, C: Dim> std::ops::DerefMut for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
fn deref_mut(&mut self) -> &mut Self::Target {
&mut | {
let dim = self.dim;
Self {
dim,
iter: Box::new(self.map(move |x| {
let msg = "Size of matrix does not match expected dimension.";
assert_eq!(x.nrows(), dim, "{}", msg);
assert_eq!(x.ncols(), dim, "{}", msg);
x
})),
}
} | identifier_body |
group.rs | mat1 * mat2))
}
/// Calculates the direct product of two groups. Pairs of matrices are then
/// mapped to their direct sum.
pub fn direct_product(g: Self, h: Self) -> Self {
let dim = g.dim + h.dim;
Self::fn_product(g, h, dim, |(mat1, mat2)| direct_sum(mat1, mat2))
}
/// Generates the [wreath product](https://en.wikipedia.org/wiki/Wreath_product)
/// of two symmetry groups.
pub fn wreath(g: Self, h: Self) -> Self {
let h = h.elements();
let h_len = h.len();
let g_dim = g.dim;
let dim = g_dim * h_len;
// Indexes each element in h.
let mut h_indices = BTreeMap::new();
for (i, h_el) in h.iter().enumerate() {
h_indices.insert(OrdMatrix::new(h_el.clone()), i);
}
// Converts h into a permutation group.
let mut permutations = Vec::with_capacity(h_len);
for h_el_1 in &h {
let mut perm = Vec::with_capacity(h.len());
for h_el_2 in &h {
perm.push(
*h_indices
.get(&OrdMatrix::new(h_el_1 * h_el_2))
.expect("h is not a valid group!"),
);
}
permutations.push(perm);
}
// Computes the direct product of g with itself |h| times.
let g_prod = vec![&g; h_len - 1]
.into_iter()
.cloned()
.fold(g.clone(), |acc, g| Group::direct_product(g, acc));
Self {
dim,
iter: Box::new(
g_prod
.map(move |g_el| {
let mut matrices = Vec::new();
for perm in &permutations {
let mut new_el = Matrix::zeros(dim, dim);
// Permutes the blocks on the diagonal of g_el.
for (i, &j) in perm.iter().enumerate() {
for x in 0..g_dim {
for y in 0..g_dim {
new_el[(i * g_dim + x, j * g_dim + y)] =
g_el[(i * g_dim + x, i * g_dim + y)];
}
}
}
matrices.push(new_el);
}
matrices.into_iter()
})
.flatten(),
),
}
}
/// Generates the orbit of a point under a given symmetry group.
pub fn orbit(self, p: Point) -> Vec<Point> {
let mut points = BTreeSet::new();
for m in self {
points.insert(OrdPoint::new(m * &p));
}
points.into_iter().map(|x| x.0).collect()
}
/// Generates a polytope as the convex hull of the orbit of a point under a
/// given symmetry group.
pub fn into_polytope(self, p: Point) -> Concrete {
convex::convex_hull(self.orbit(p))
}
}
impl From<Vec<Matrix<f64>>> for Group {
fn from(elements: Vec<Matrix<f64>>) -> Self {
Self {
dim: elements
.get(0)
.expect("Group must have at least one element.")
.nrows(),
iter: Box::new(elements.into_iter()),
}
}
}
/// The result of trying to get the next element in a group.
pub enum GroupNext {
/// We've already found all elements of the group.
None,
/// We found an element we had found previously.
Repeat,
/// We found a new element.
New(Matrix<f64>),
}
#[allow(clippy::upper_case_acronyms)]
type MatrixMN<R, C> = nalgebra::Matrix<f64, R, C, VecStorage<f64, R, C>>;
#[derive(Clone, Debug)]
#[allow(clippy::upper_case_acronyms)]
/// A matrix ordered by fuzzy lexicographic ordering. Used to quickly
/// determine whether an element in a [`GenIter`](GenIter) is a
/// duplicate.
pub struct OrdMatrixMN<R: Dim, C: Dim>(pub MatrixMN<R, C>)
where
VecStorage<f64, R, C>: Storage<f64, R, C>;
impl<R: Dim, C: Dim> std::ops::Deref for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
type Target = MatrixMN<R, C>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<R: Dim, C: Dim> std::ops::DerefMut for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl<R: Dim, C: Dim> PartialEq for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
fn eq(&self, other: &Self) -> bool {
let mut other = other.iter();
for x in self.iter() {
let y = other.next().unwrap();
if abs_diff_ne!(x, y, epsilon = EPS) {
return false;
}
}
true
}
}
impl<R: Dim, C: Dim> Eq for OrdMatrixMN<R, C> where VecStorage<f64, R, C>: Storage<f64, R, C> {}
impl<R: Dim, C: Dim> PartialOrd for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
let mut other = other.iter();
for x in self.iter() {
let y = other.next().unwrap();
if abs_diff_ne!(x, y, epsilon = EPS) {
return x.partial_cmp(y);
}
}
Some(std::cmp::Ordering::Equal)
}
}
impl<R: Dim, C: Dim> Ord for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
self.partial_cmp(other).unwrap()
}
}
impl<R: Dim, C: Dim> OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
pub fn new(mat: MatrixMN<R, C>) -> Self {
Self(mat)
}
}
type OrdMatrix = OrdMatrixMN<Dynamic, Dynamic>;
type OrdPoint = OrdMatrixMN<Dynamic, U1>;
/// An iterator for a `Group` [generated](https://en.wikipedia.org/wiki/Generator_(mathematics))
/// by a set of floating point matrices. Its elements are built in a BFS order.
/// It contains a lookup table, used to figure out whether an element has
/// already been found or not, as well as a queue to store the next elements.
#[derive(Clone)]
pub struct GenIter {
/// The number of dimensions the group acts on.
pub dim: usize,
/// The generators for the group.
pub gens: Vec<Matrix<f64>>,
/// Stores the elements that have been generated and that can still be
/// generated again. Is integral for the algorithm to work, as without it,
/// duplicate group elements will just keep generating forever.
elements: BTreeMap<OrdMatrix, usize>,
/// Stores the elements that haven't yet been processed.
queue: VecDeque<OrdMatrix>,
/// Stores the index in (`generators`)[GenGroup.generators] of the generator
/// that's being checked. All previous once will have already been
/// multiplied to the right of the current element. Quirk of the current
/// data structure, subject to change.
gen_idx: usize,
}
impl Iterator for GenIter {
type Item = Matrix<f64>;
fn next(&mut self) -> Option<Self::Item> {
loop {
match self.try_next() {
GroupNext::None => return None,
GroupNext::Repeat => {}
GroupNext::New(el) => return Some(el),
};
}
}
}
/// Determines whether two matrices are "approximately equal" elementwise.
fn matrix_approx(mat1: &Matrix<f64>, mat2: &Matrix<f64>) -> bool {
const EPS: f64 = 1e-4;
let mat1 = mat1.iter();
let mut mat2 = mat2.iter();
for x in mat1 {
let y = mat2.next().expect("Matrices don't have the same size!");
if abs_diff_ne!(x, y, epsilon = EPS) {
return false;
}
}
true
}
/// Builds a reflection matrix from a given vector.
pub fn refl_mat(n: Vector<f64>) -> Matrix<f64> {
let dim = n.nrows(); | random_line_split |
||
group.rs | don't contain central inversion.
fn | (self, left: bool) -> Box<dyn GroupIter> {
if self.dim != 3 {
panic!("Quaternions can only be generated from 3D matrices.");
}
Box::new(
self.rotations()
.map(move |el| quat_to_mat(mat_to_quat(el), left)),
)
}
/// Returns the swirl symmetry group of two 3D groups.
pub fn swirl(g: Self, h: Self) -> Self {
if g.dim != 3 {
panic!("g must be a group of 3D matrices.");
}
if h.dim != 3 {
panic!("h must be a group of 3D matrices.");
}
Self {
dim: 4,
iter: Box::new(
itertools::iproduct!(g.quaternions(true), h.quaternions(false))
.map(|(mat1, mat2)| {
let mat = mat1 * mat2;
std::iter::once(mat.clone()).chain(std::iter::once(-mat))
})
.flatten(),
),
}
}
/// Returns a new group whose elements have all been generated already, so
/// that they can be used multiple times quickly.
pub fn cache(self) -> Self {
self.elements().into()
}
/// Returns the exact same group, but now asserts that each generated
/// element has the appropriate dimension. Used for debugging purposes.
pub fn debug(self) -> Self {
let dim = self.dim;
Self {
dim,
iter: Box::new(self.map(move |x| {
let msg = "Size of matrix does not match expected dimension.";
assert_eq!(x.nrows(), dim, "{}", msg);
assert_eq!(x.ncols(), dim, "{}", msg);
x
})),
}
}
/// Generates the trivial group of a certain dimension.
pub fn trivial(dim: usize) -> Self {
Self {
dim,
iter: Box::new(std::iter::once(Matrix::identity(dim, dim))),
}
}
/// Generates the group with the identity and a central inversion of a
/// certain dimension.
pub fn central_inv(dim: usize) -> Self {
Self {
dim,
iter: Box::new(
vec![Matrix::identity(dim, dim), -Matrix::identity(dim, dim)].into_iter(),
),
}
}
/// Generates a step prism group from a base group and a homomorphism into
/// another group.
pub fn step(g: Self, f: impl Fn(Matrix<f64>) -> Matrix<f64> + Clone + 'static) -> Self {
let dim = g.dim * 2;
Self {
dim,
iter: Box::new(g.map(move |mat| {
let clone = mat.clone();
direct_sum(clone, f(mat))
})),
}
}
/// Generates a Coxeter group from its [`CoxMatrix`], or returns `None` if
/// the group doesn't fit as a matrix group in spherical space.
pub fn cox_group(cox: CoxMatrix) -> Option<Self> {
Some(Self {
dim: cox.nrows(),
iter: Box::new(GenIter::from_cox_mat(cox)?),
})
}
/// Generates the direct product of two groups. Uses the specified function
/// to uniquely map the ordered pairs of matrices into other matrices.
pub fn fn_product(
g: Self,
h: Self,
dim: usize,
product: (impl Fn((Matrix<f64>, Matrix<f64>)) -> Matrix<f64> + Clone + 'static),
) -> Self {
Self {
dim,
iter: Box::new(itertools::iproduct!(g, h).map(product)),
}
}
/// Returns the group determined by all products between elements of the
/// first and the second group. **Is meant only for groups that commute with
/// one another.**
pub fn matrix_product(g: Self, h: Self) -> Option<Self> {
// The two matrices must have the same size.
if g.dim != h.dim {
return None;
}
let dim = g.dim;
Some(Self::fn_product(g, h, dim, |(mat1, mat2)| mat1 * mat2))
}
/// Calculates the direct product of two groups. Pairs of matrices are then
/// mapped to their direct sum.
pub fn direct_product(g: Self, h: Self) -> Self {
let dim = g.dim + h.dim;
Self::fn_product(g, h, dim, |(mat1, mat2)| direct_sum(mat1, mat2))
}
/// Generates the [wreath product](https://en.wikipedia.org/wiki/Wreath_product)
/// of two symmetry groups.
pub fn wreath(g: Self, h: Self) -> Self {
let h = h.elements();
let h_len = h.len();
let g_dim = g.dim;
let dim = g_dim * h_len;
// Indexes each element in h.
let mut h_indices = BTreeMap::new();
for (i, h_el) in h.iter().enumerate() {
h_indices.insert(OrdMatrix::new(h_el.clone()), i);
}
// Converts h into a permutation group.
let mut permutations = Vec::with_capacity(h_len);
for h_el_1 in &h {
let mut perm = Vec::with_capacity(h.len());
for h_el_2 in &h {
perm.push(
*h_indices
.get(&OrdMatrix::new(h_el_1 * h_el_2))
.expect("h is not a valid group!"),
);
}
permutations.push(perm);
}
// Computes the direct product of g with itself |h| times.
let g_prod = vec![&g; h_len - 1]
.into_iter()
.cloned()
.fold(g.clone(), |acc, g| Group::direct_product(g, acc));
Self {
dim,
iter: Box::new(
g_prod
.map(move |g_el| {
let mut matrices = Vec::new();
for perm in &permutations {
let mut new_el = Matrix::zeros(dim, dim);
// Permutes the blocks on the diagonal of g_el.
for (i, &j) in perm.iter().enumerate() {
for x in 0..g_dim {
for y in 0..g_dim {
new_el[(i * g_dim + x, j * g_dim + y)] =
g_el[(i * g_dim + x, i * g_dim + y)];
}
}
}
matrices.push(new_el);
}
matrices.into_iter()
})
.flatten(),
),
}
}
/// Generates the orbit of a point under a given symmetry group.
pub fn orbit(self, p: Point) -> Vec<Point> {
let mut points = BTreeSet::new();
for m in self {
points.insert(OrdPoint::new(m * &p));
}
points.into_iter().map(|x| x.0).collect()
}
/// Generates a polytope as the convex hull of the orbit of a point under a
/// given symmetry group.
pub fn into_polytope(self, p: Point) -> Concrete {
convex::convex_hull(self.orbit(p))
}
}
impl From<Vec<Matrix<f64>>> for Group {
fn from(elements: Vec<Matrix<f64>>) -> Self {
Self {
dim: elements
.get(0)
.expect("Group must have at least one element.")
.nrows(),
iter: Box::new(elements.into_iter()),
}
}
}
/// The result of trying to get the next element in a group.
pub enum GroupNext {
/// We've already found all elements of the group.
None,
/// We found an element we had found previously.
Repeat,
/// We found a new element.
New(Matrix<f64>),
}
#[allow(clippy::upper_case_acronyms)]
type MatrixMN<R, C> = nalgebra::Matrix<f64, R, C, VecStorage<f64, R, C>>;
#[derive(Clone, Debug)]
#[allow(clippy::upper_case_acronyms)]
/// A matrix ordered by fuzzy lexicographic ordering. Used to quickly
/// determine whether an element in a [`GenIter`](GenIter) is a
/// duplicate.
pub struct OrdMatrixMN<R: Dim, C: Dim>(pub MatrixMN<R, C>)
where
VecStorage<f64, R, C>: Storage<f64, R, C>;
impl<R: Dim, C: Dim> std::ops::Deref for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
type Target = MatrixMN<R, C>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<R: Dim, C: Dim> std::ops::DerefMut for OrdMatrixMN<R, C>
where
VecStorage<f64, R, C>: Storage<f64, R, C>,
{
fn deref_mut(&mut self) -> &mut Self::Target {
&mut | quaternions | identifier_name |
connection.py | API."""
def __init__(
self,
websession: aiohttp.ClientSession,
username,
password,
device_id,
device_name,
country,
) -> None:
"""
Initialize connection object.
Args:
websession (aiohttp.ClientSession): An instance of aiohttp.ClientSession.
username (str): Username used for the MySubaru mobile app.
password (str): Password used for the MySubaru mobile app.
device_id (str): Alphanumeric designator that Subaru API uses to track individual device authorization.
device_name (str): Human friendly name that is associated with `device_id` (shows on mysubaru.com profile "devices").
country (str): Country of MySubaru Account [CAN, USA].
"""
self._username = username
self._password = password
self._device_id = device_id
self._country = country
self._lock = asyncio.Lock()
self._device_name = device_name
self._vehicles = []
self._head = {
"User-Agent": "Mozilla/5.0 (Linux; Android 10; Android SDK built for x86 Build/QSR1.191030.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.185 Mobile Safari/537.36",
"Origin": "file://",
"X-Requested-With": API_MOBILE_APP[self._country],
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate",
"Accept": "*/*",
}
self._websession = websession
self._authenticated = False
self._registered = False
self._current_vin = None
self._list_of_vins = []
self._session_login_time = None
self._auth_contact_options = None
async def connect(self):
"""
Connect to and establish session with Subaru Starlink mobile app API.
Returns:
List: A list of dicts containing information about each vehicle registered in the Subaru account.
Raises:
InvalidCredentials: If login credentials are incorrect.
IncompleteCredentials: If login credentials were not provided.
SubaruException: If login fails for any other reason.
"""
await self._authenticate()
await self._get_vehicle_data()
if not self.device_registered:
await self._get_contact_methods()
return self._vehicles
@property
def device_registered(self):
"""Device is registered."""
return self._registered
@property
def auth_contact_methods(self):
"""Contact methods for 2FA."""
return self._auth_contact_options
async def request_auth_code(self, contact_method):
"""Request 2FA code be sent via specified contact method."""
if contact_method not in self.auth_contact_methods:
_LOGGER.error("Invalid 2FA contact method requested")
return False
_LOGGER.debug("Requesting 2FA code")
post_data = {
"contactMethod": contact_method,
"languagePreference": "EN",
}
js_resp = await self.__open(
API_2FA_SEND_VERIFICATION,
POST,
params=post_data,
)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
return True
async def submit_auth_code(self, code, make_permanent=True):
"""Submit received 2FA code for validation."""
if not code.isdecimal() or len(code) != 6:
_LOGGER.error("2FA code must be 6 digits")
return False
_LOGGER.info("Validating 2FA response")
post_data = {
"deviceId": self._device_id,
"deviceName": self._device_name,
"verificationCode": code,
}
if make_permanent:
post_data["rememberDevice"] = "on"
js_resp = await self.__open(API_2FA_AUTH_VERIFY, POST, params=post_data)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
_LOGGER.info("Device successfully authorized")
while not self._registered:
# Device registration does not always immediately take effect
await asyncio.sleep(3)
await self._authenticate()
# Current server side vin context is ambiguous (even for single vehicle account??)
self._current_vin = None
return True
async def validate_session(self, vin):
"""
Validate if current session is ready for an API command/query.
Verifies session cookie is still valid and re-authenticates if necessary.
Sets server-side vehicle context as needed.
Args:
vin (str): VIN of desired server-side vehicle context.
Returns:
bool: `True` if session is ready to send a command or query to the Subaru API with the desired `vin` context.
Raises:
SubaruException: If validation fails and a new session fails to be established.
"""
result = False
js_resp = await self.__open(API_VALIDATE_SESSION, GET)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
if vin != self._current_vin:
# API call for VIN that is not the current remote context.
_LOGGER.debug("Switching Subaru API vehicle context to: %s", vin)
if await self._select_vehicle(vin):
result = True
else:
result = True
if result is False:
await self._authenticate(vin)
# New session cookie. Must call selectVehicle.json before any other API call.
if await self._select_vehicle(vin):
result = True
return result
def get_session_age(self):
"""Return number of minutes since last authentication."""
return (time.time() - self._session_login_time) // 60
def reset_session(self):
"""Clear session cookies."""
self._websession.cookie_jar.clear()
async def get(self, url, params=None):
"""
Send HTTPS GET request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP GET request parameters
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
return await self.__open(url, method=GET, headers=self._head, params=params)
async def post(self, url, params=None, json_data=None):
"""
Send HTTPS POST request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP POST request parameters
json_data (Dict, optional): HTTP POST request JSON data as a Dict
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
return await self.__open(url, method=POST, headers=self._head, params=params, json_data=json_data)
async def _authenticate(self, vin=None) -> bool:
| self._current_vin = None
return True
if js_resp.get("errorCode"):
_LOGGER.debug(pprint.pformat(js_resp))
error = js_resp.get("errorCode")
if error == API_ERROR_INVALID_ACCOUNT:
_LOGGER.error("Invalid account")
raise InvalidCredentials(error)
if error == API_ERROR_INVALID_CREDENTIALS:
_LOGGER.error("Client authentication failed")
raise InvalidCredentials(error)
if error == API_ERROR_PASSWORD_WARNING:
_LOGGER.error("Multiple Password Failures.")
raise InvalidCredentials(error)
raise SubaruException(error)
raise IncompleteCredentials("Connection requires email and password and device id.")
async def _select_vehicle(self, vin):
"""Select active vehicle for accounts with multiple VINs."""
params = {"vin": vin, "_": int(time.time())}
js_resp = await self.get(API_SELECT_VEHICLE, params=params)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp.get("success"):
self._current_vin = vin
_LOGGER.debug("Current vehicle: vin=%s", js_resp["data"]["vin"])
return js_resp["data"]
if not js_resp.get("success") and js_resp.get("errorCode") == API_ERROR_VEHICLE_SETUP:
# Occasionally happens every few hours. Resetting the session seems to deal with it.
_LOGGER.warning | """Authenticate to Subaru Remote Services API."""
if self._username and self._password and self._device_id:
post_data = {
"env": "cloudprod",
"loginUsername": self._username,
"password": self._password,
"deviceId": self._device_id,
"passwordToken": None,
"selectedVin": vin,
"pushToken": None,
"deviceType": "android",
}
js_resp = await self.__open(API_LOGIN, POST, data=post_data, headers=self._head)
if js_resp.get("success"):
_LOGGER.debug("Client authentication successful")
_LOGGER.debug(pprint.pformat(js_resp))
self._authenticated = True
self._session_login_time = time.time()
self._registered = js_resp["data"]["deviceRegistered"]
self._list_of_vins = [v["vin"] for v in js_resp["data"]["vehicles"]] | identifier_body |
connection.py | API."""
def __init__(
self,
websession: aiohttp.ClientSession,
username,
password,
device_id,
device_name,
country,
) -> None:
"""
Initialize connection object.
Args:
websession (aiohttp.ClientSession): An instance of aiohttp.ClientSession.
username (str): Username used for the MySubaru mobile app.
password (str): Password used for the MySubaru mobile app.
device_id (str): Alphanumeric designator that Subaru API uses to track individual device authorization.
device_name (str): Human friendly name that is associated with `device_id` (shows on mysubaru.com profile "devices").
country (str): Country of MySubaru Account [CAN, USA].
"""
self._username = username
self._password = password
self._device_id = device_id
self._country = country
self._lock = asyncio.Lock()
self._device_name = device_name
self._vehicles = []
self._head = {
"User-Agent": "Mozilla/5.0 (Linux; Android 10; Android SDK built for x86 Build/QSR1.191030.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.185 Mobile Safari/537.36",
"Origin": "file://",
"X-Requested-With": API_MOBILE_APP[self._country],
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate",
"Accept": "*/*",
}
self._websession = websession
self._authenticated = False
self._registered = False
self._current_vin = None
self._list_of_vins = []
self._session_login_time = None
self._auth_contact_options = None
async def connect(self):
"""
Connect to and establish session with Subaru Starlink mobile app API.
Returns:
List: A list of dicts containing information about each vehicle registered in the Subaru account.
Raises:
InvalidCredentials: If login credentials are incorrect.
IncompleteCredentials: If login credentials were not provided.
SubaruException: If login fails for any other reason.
"""
await self._authenticate()
await self._get_vehicle_data()
if not self.device_registered:
await self._get_contact_methods()
return self._vehicles
@property
def device_registered(self):
"""Device is registered."""
return self._registered
@property
def auth_contact_methods(self):
"""Contact methods for 2FA."""
return self._auth_contact_options
async def request_auth_code(self, contact_method):
"""Request 2FA code be sent via specified contact method."""
if contact_method not in self.auth_contact_methods:
_LOGGER.error("Invalid 2FA contact method requested")
return False
_LOGGER.debug("Requesting 2FA code")
post_data = {
"contactMethod": contact_method,
"languagePreference": "EN",
}
js_resp = await self.__open(
API_2FA_SEND_VERIFICATION,
POST,
params=post_data,
)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
return True
async def submit_auth_code(self, code, make_permanent=True):
"""Submit received 2FA code for validation."""
if not code.isdecimal() or len(code) != 6:
_LOGGER.error("2FA code must be 6 digits")
return False
_LOGGER.info("Validating 2FA response")
post_data = {
"deviceId": self._device_id,
"deviceName": self._device_name,
"verificationCode": code,
}
if make_permanent:
post_data["rememberDevice"] = "on"
js_resp = await self.__open(API_2FA_AUTH_VERIFY, POST, params=post_data)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
_LOGGER.info("Device successfully authorized")
while not self._registered:
# Device registration does not always immediately take effect
await asyncio.sleep(3)
await self._authenticate()
# Current server side vin context is ambiguous (even for single vehicle account??)
self._current_vin = None
return True
async def validate_session(self, vin):
"""
Validate if current session is ready for an API command/query.
Verifies session cookie is still valid and re-authenticates if necessary.
Sets server-side vehicle context as needed.
Args:
vin (str): VIN of desired server-side vehicle context.
Returns:
bool: `True` if session is ready to send a command or query to the Subaru API with the desired `vin` context.
Raises:
SubaruException: If validation fails and a new session fails to be established.
"""
result = False
js_resp = await self.__open(API_VALIDATE_SESSION, GET)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
if vin != self._current_vin:
# API call for VIN that is not the current remote context.
_LOGGER.debug("Switching Subaru API vehicle context to: %s", vin)
if await self._select_vehicle(vin):
result = True
else:
result = True
if result is False:
await self._authenticate(vin)
# New session cookie. Must call selectVehicle.json before any other API call.
if await self._select_vehicle(vin):
result = True
return result
def get_session_age(self):
"""Return number of minutes since last authentication."""
return (time.time() - self._session_login_time) // 60
def reset_session(self):
"""Clear session cookies."""
self._websession.cookie_jar.clear()
async def get(self, url, params=None):
"""
Send HTTPS GET request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP GET request parameters
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
return await self.__open(url, method=GET, headers=self._head, params=params)
async def post(self, url, params=None, json_data=None):
"""
Send HTTPS POST request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP POST request parameters
json_data (Dict, optional): HTTP POST request JSON data as a Dict
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
|
async def _authenticate(self, vin=None) -> bool:
"""Authenticate to Subaru Remote Services API."""
if self._username and self._password and self._device_id:
post_data = {
"env": "cloudprod",
"loginUsername": self._username,
"password": self._password,
"deviceId": self._device_id,
"passwordToken": None,
"selectedVin": vin,
"pushToken": None,
"deviceType": "android",
}
js_resp = await self.__open(API_LOGIN, POST, data=post_data, headers=self._head)
if js_resp.get("success"):
_LOGGER.debug("Client authentication successful")
_LOGGER.debug(pprint.pformat(js_resp))
self._authenticated = True
self._session_login_time = time.time()
self._registered = js_resp["data"]["deviceRegistered"]
self._list_of_vins = [v["vin"] for v in js_resp["data"]["vehicles"]]
self._current_vin = None
return True
if js_resp.get("errorCode"):
_LOGGER.debug(pprint.pformat(js_resp))
error = js_resp.get("errorCode")
if error == API_ERROR_INVALID_ACCOUNT:
_LOGGER.error("Invalid account")
raise InvalidCredentials(error)
if error == API_ERROR_INVALID_CREDENTIALS:
_LOGGER.error("Client authentication failed")
raise InvalidCredentials(error)
if error == API_ERROR_PASSWORD_WARNING:
_LOGGER.error("Multiple Password Failures.")
raise InvalidCredentials(error)
raise SubaruException(error)
raise IncompleteCredentials("Connection requires email and password and device id.")
async def _select_vehicle(self, vin):
"""Select active vehicle for accounts with multiple VINs."""
params = {"vin": vin, "_": int(time.time())}
js_resp = await self.get(API_SELECT_VEHICLE, params=params)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp.get("success"):
self._current_vin = vin
_LOGGER.debug("Current vehicle: vin=%s", js_resp["data"]["vin"])
return js_resp["data"]
if not js_resp.get("success") and js_resp.get("errorCode") == API_ERROR_VEHICLE_SETUP:
# Occasionally happens every few hours. Resetting the session seems to deal with it.
_LOGGER.warning | return await self.__open(url, method=POST, headers=self._head, params=params, json_data=json_data) | conditional_block |
connection.py | API."""
def __init__(
self,
websession: aiohttp.ClientSession,
username,
password,
device_id,
device_name,
country,
) -> None:
"""
Initialize connection object.
Args:
websession (aiohttp.ClientSession): An instance of aiohttp.ClientSession.
username (str): Username used for the MySubaru mobile app.
password (str): Password used for the MySubaru mobile app.
device_id (str): Alphanumeric designator that Subaru API uses to track individual device authorization.
device_name (str): Human friendly name that is associated with `device_id` (shows on mysubaru.com profile "devices").
country (str): Country of MySubaru Account [CAN, USA].
"""
self._username = username
self._password = password
self._device_id = device_id
self._country = country
self._lock = asyncio.Lock()
self._device_name = device_name
self._vehicles = []
self._head = {
"User-Agent": "Mozilla/5.0 (Linux; Android 10; Android SDK built for x86 Build/QSR1.191030.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.185 Mobile Safari/537.36",
"Origin": "file://",
"X-Requested-With": API_MOBILE_APP[self._country],
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate",
"Accept": "*/*",
}
self._websession = websession
self._authenticated = False
self._registered = False
self._current_vin = None
self._list_of_vins = []
self._session_login_time = None
self._auth_contact_options = None
async def connect(self):
"""
Connect to and establish session with Subaru Starlink mobile app API.
Returns:
List: A list of dicts containing information about each vehicle registered in the Subaru account.
Raises:
InvalidCredentials: If login credentials are incorrect.
IncompleteCredentials: If login credentials were not provided.
SubaruException: If login fails for any other reason.
"""
await self._authenticate()
await self._get_vehicle_data()
if not self.device_registered:
await self._get_contact_methods()
return self._vehicles
@property
def device_registered(self):
"""Device is registered."""
return self._registered
@property
def auth_contact_methods(self):
"""Contact methods for 2FA."""
return self._auth_contact_options
async def request_auth_code(self, contact_method):
"""Request 2FA code be sent via specified contact method."""
if contact_method not in self.auth_contact_methods:
_LOGGER.error("Invalid 2FA contact method requested")
return False
_LOGGER.debug("Requesting 2FA code")
post_data = {
"contactMethod": contact_method,
"languagePreference": "EN",
}
js_resp = await self.__open(
API_2FA_SEND_VERIFICATION,
POST,
params=post_data,
)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
return True
async def submit_auth_code(self, code, make_permanent=True):
"""Submit received 2FA code for validation."""
if not code.isdecimal() or len(code) != 6:
_LOGGER.error("2FA code must be 6 digits")
return False
_LOGGER.info("Validating 2FA response")
post_data = {
"deviceId": self._device_id,
"deviceName": self._device_name,
"verificationCode": code,
}
if make_permanent:
post_data["rememberDevice"] = "on"
js_resp = await self.__open(API_2FA_AUTH_VERIFY, POST, params=post_data)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
_LOGGER.info("Device successfully authorized")
while not self._registered:
# Device registration does not always immediately take effect
await asyncio.sleep(3)
await self._authenticate()
# Current server side vin context is ambiguous (even for single vehicle account??)
self._current_vin = None
return True
async def validate_session(self, vin):
"""
Validate if current session is ready for an API command/query.
Verifies session cookie is still valid and re-authenticates if necessary.
Sets server-side vehicle context as needed.
Args:
vin (str): VIN of desired server-side vehicle context.
Returns:
bool: `True` if session is ready to send a command or query to the Subaru API with the desired `vin` context.
Raises:
SubaruException: If validation fails and a new session fails to be established.
"""
result = False
js_resp = await self.__open(API_VALIDATE_SESSION, GET)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
if vin != self._current_vin:
# API call for VIN that is not the current remote context.
_LOGGER.debug("Switching Subaru API vehicle context to: %s", vin)
if await self._select_vehicle(vin):
result = True
else:
result = True
if result is False:
await self._authenticate(vin)
# New session cookie. Must call selectVehicle.json before any other API call.
if await self._select_vehicle(vin):
result = True
return result
def get_session_age(self):
"""Return number of minutes since last authentication."""
return (time.time() - self._session_login_time) // 60
def | (self):
"""Clear session cookies."""
self._websession.cookie_jar.clear()
async def get(self, url, params=None):
"""
Send HTTPS GET request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP GET request parameters
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
return await self.__open(url, method=GET, headers=self._head, params=params)
async def post(self, url, params=None, json_data=None):
"""
Send HTTPS POST request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP POST request parameters
json_data (Dict, optional): HTTP POST request JSON data as a Dict
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
return await self.__open(url, method=POST, headers=self._head, params=params, json_data=json_data)
async def _authenticate(self, vin=None) -> bool:
"""Authenticate to Subaru Remote Services API."""
if self._username and self._password and self._device_id:
post_data = {
"env": "cloudprod",
"loginUsername": self._username,
"password": self._password,
"deviceId": self._device_id,
"passwordToken": None,
"selectedVin": vin,
"pushToken": None,
"deviceType": "android",
}
js_resp = await self.__open(API_LOGIN, POST, data=post_data, headers=self._head)
if js_resp.get("success"):
_LOGGER.debug("Client authentication successful")
_LOGGER.debug(pprint.pformat(js_resp))
self._authenticated = True
self._session_login_time = time.time()
self._registered = js_resp["data"]["deviceRegistered"]
self._list_of_vins = [v["vin"] for v in js_resp["data"]["vehicles"]]
self._current_vin = None
return True
if js_resp.get("errorCode"):
_LOGGER.debug(pprint.pformat(js_resp))
error = js_resp.get("errorCode")
if error == API_ERROR_INVALID_ACCOUNT:
_LOGGER.error("Invalid account")
raise InvalidCredentials(error)
if error == API_ERROR_INVALID_CREDENTIALS:
_LOGGER.error("Client authentication failed")
raise InvalidCredentials(error)
if error == API_ERROR_PASSWORD_WARNING:
_LOGGER.error("Multiple Password Failures.")
raise InvalidCredentials(error)
raise SubaruException(error)
raise IncompleteCredentials("Connection requires email and password and device id.")
async def _select_vehicle(self, vin):
"""Select active vehicle for accounts with multiple VINs."""
params = {"vin": vin, "_": int(time.time())}
js_resp = await self.get(API_SELECT_VEHICLE, params=params)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp.get("success"):
self._current_vin = vin
_LOGGER.debug("Current vehicle: vin=%s", js_resp["data"]["vin"])
return js_resp["data"]
if not js_resp.get("success") and js_resp.get("errorCode") == API_ERROR_VEHICLE_SETUP:
# Occasionally happens every few hours. Resetting the session seems to deal with it.
_LOGGER.warning | reset_session | identifier_name |
connection.py | app API."""
def __init__(
self,
websession: aiohttp.ClientSession,
username,
password,
device_id,
device_name,
country,
) -> None:
"""
Initialize connection object.
Args:
websession (aiohttp.ClientSession): An instance of aiohttp.ClientSession.
username (str): Username used for the MySubaru mobile app.
password (str): Password used for the MySubaru mobile app.
device_id (str): Alphanumeric designator that Subaru API uses to track individual device authorization.
device_name (str): Human friendly name that is associated with `device_id` (shows on mysubaru.com profile "devices").
country (str): Country of MySubaru Account [CAN, USA].
"""
self._username = username
self._password = password
self._device_id = device_id
self._country = country
self._lock = asyncio.Lock()
self._device_name = device_name
self._vehicles = []
self._head = {
"User-Agent": "Mozilla/5.0 (Linux; Android 10; Android SDK built for x86 Build/QSR1.191030.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.185 Mobile Safari/537.36",
"Origin": "file://",
"X-Requested-With": API_MOBILE_APP[self._country],
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate", | self._registered = False
self._current_vin = None
self._list_of_vins = []
self._session_login_time = None
self._auth_contact_options = None
async def connect(self):
"""
Connect to and establish session with Subaru Starlink mobile app API.
Returns:
List: A list of dicts containing information about each vehicle registered in the Subaru account.
Raises:
InvalidCredentials: If login credentials are incorrect.
IncompleteCredentials: If login credentials were not provided.
SubaruException: If login fails for any other reason.
"""
await self._authenticate()
await self._get_vehicle_data()
if not self.device_registered:
await self._get_contact_methods()
return self._vehicles
@property
def device_registered(self):
"""Device is registered."""
return self._registered
@property
def auth_contact_methods(self):
"""Contact methods for 2FA."""
return self._auth_contact_options
async def request_auth_code(self, contact_method):
"""Request 2FA code be sent via specified contact method."""
if contact_method not in self.auth_contact_methods:
_LOGGER.error("Invalid 2FA contact method requested")
return False
_LOGGER.debug("Requesting 2FA code")
post_data = {
"contactMethod": contact_method,
"languagePreference": "EN",
}
js_resp = await self.__open(
API_2FA_SEND_VERIFICATION,
POST,
params=post_data,
)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
return True
async def submit_auth_code(self, code, make_permanent=True):
"""Submit received 2FA code for validation."""
if not code.isdecimal() or len(code) != 6:
_LOGGER.error("2FA code must be 6 digits")
return False
_LOGGER.info("Validating 2FA response")
post_data = {
"deviceId": self._device_id,
"deviceName": self._device_name,
"verificationCode": code,
}
if make_permanent:
post_data["rememberDevice"] = "on"
js_resp = await self.__open(API_2FA_AUTH_VERIFY, POST, params=post_data)
if js_resp:
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
_LOGGER.info("Device successfully authorized")
while not self._registered:
# Device registration does not always immediately take effect
await asyncio.sleep(3)
await self._authenticate()
# Current server side vin context is ambiguous (even for single vehicle account??)
self._current_vin = None
return True
async def validate_session(self, vin):
"""
Validate if current session is ready for an API command/query.
Verifies session cookie is still valid and re-authenticates if necessary.
Sets server-side vehicle context as needed.
Args:
vin (str): VIN of desired server-side vehicle context.
Returns:
bool: `True` if session is ready to send a command or query to the Subaru API with the desired `vin` context.
Raises:
SubaruException: If validation fails and a new session fails to be established.
"""
result = False
js_resp = await self.__open(API_VALIDATE_SESSION, GET)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp["success"]:
if vin != self._current_vin:
# API call for VIN that is not the current remote context.
_LOGGER.debug("Switching Subaru API vehicle context to: %s", vin)
if await self._select_vehicle(vin):
result = True
else:
result = True
if result is False:
await self._authenticate(vin)
# New session cookie. Must call selectVehicle.json before any other API call.
if await self._select_vehicle(vin):
result = True
return result
def get_session_age(self):
"""Return number of minutes since last authentication."""
return (time.time() - self._session_login_time) // 60
def reset_session(self):
"""Clear session cookies."""
self._websession.cookie_jar.clear()
async def get(self, url, params=None):
"""
Send HTTPS GET request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP GET request parameters
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
return await self.__open(url, method=GET, headers=self._head, params=params)
async def post(self, url, params=None, json_data=None):
"""
Send HTTPS POST request to Subaru Remote Services API.
Args:
url (str): URL path that will be concatenated after `subarulink.const.MOBILE_API_BASE_URL`
params (Dict, optional): HTTP POST request parameters
json_data (Dict, optional): HTTP POST request JSON data as a Dict
Returns:
Dict: JSON response as a Dict
Raises:
SubaruException: If request fails.
"""
if self._authenticated:
return await self.__open(url, method=POST, headers=self._head, params=params, json_data=json_data)
async def _authenticate(self, vin=None) -> bool:
"""Authenticate to Subaru Remote Services API."""
if self._username and self._password and self._device_id:
post_data = {
"env": "cloudprod",
"loginUsername": self._username,
"password": self._password,
"deviceId": self._device_id,
"passwordToken": None,
"selectedVin": vin,
"pushToken": None,
"deviceType": "android",
}
js_resp = await self.__open(API_LOGIN, POST, data=post_data, headers=self._head)
if js_resp.get("success"):
_LOGGER.debug("Client authentication successful")
_LOGGER.debug(pprint.pformat(js_resp))
self._authenticated = True
self._session_login_time = time.time()
self._registered = js_resp["data"]["deviceRegistered"]
self._list_of_vins = [v["vin"] for v in js_resp["data"]["vehicles"]]
self._current_vin = None
return True
if js_resp.get("errorCode"):
_LOGGER.debug(pprint.pformat(js_resp))
error = js_resp.get("errorCode")
if error == API_ERROR_INVALID_ACCOUNT:
_LOGGER.error("Invalid account")
raise InvalidCredentials(error)
if error == API_ERROR_INVALID_CREDENTIALS:
_LOGGER.error("Client authentication failed")
raise InvalidCredentials(error)
if error == API_ERROR_PASSWORD_WARNING:
_LOGGER.error("Multiple Password Failures.")
raise InvalidCredentials(error)
raise SubaruException(error)
raise IncompleteCredentials("Connection requires email and password and device id.")
async def _select_vehicle(self, vin):
"""Select active vehicle for accounts with multiple VINs."""
params = {"vin": vin, "_": int(time.time())}
js_resp = await self.get(API_SELECT_VEHICLE, params=params)
_LOGGER.debug(pprint.pformat(js_resp))
if js_resp.get("success"):
self._current_vin = vin
_LOGGER.debug("Current vehicle: vin=%s", js_resp["data"]["vin"])
return js_resp["data"]
if not js_resp.get("success") and js_resp.get("errorCode") == API_ERROR_VEHICLE_SETUP:
# Occasionally happens every few hours. Resetting the session seems to deal with it.
_LOGGER.warning(" | "Accept": "*/*",
}
self._websession = websession
self._authenticated = False | random_line_split |
main.go | os.Lstat(workdir)
if err != nil {
log.Fatalf("workdir error: %s", err)
}
dbCertificate, dbCaCertPool := loadCerts(
cfg.MySQL.CertificatePath,
cfg.MySQL.PrivateKeyPath,
cfg.MySQL.PrivateKeyPassphrase,
cfg.MySQL.CACertificatePath,
)
dbURI := db.NewDSN(
cfg.MySQL.Username,
cfg.MySQL.Password,
cfg.MySQL.DBName,
cfg.MySQL.Hostname,
int(cfg.MySQL.Port),
cfg.MySQL.ServerName,
dbCertificate,
dbCaCertPool,
)
database, err := migrations.LockDBAndMigrate(logger, "mysql", dbURI)
if err != nil {
log.Fatalf("db error: %s", err)
}
database.LogMode(false)
clk := clock.NewClock()
cloneMsgCh := make(chan revok.CloneMsg)
scanRepository := db.NewScanRepository(database, clk)
repositoryRepository := db.NewRepositoryRepository(database)
fetchRepository := db.NewFetchRepository(database)
credentialRepository := db.NewCredentialRepository(database)
branchRepository := db.NewBranchRepository(database)
emitter := metrics.BuildEmitter(cfg.Metrics.DatadogAPIKey, cfg.Metrics.Environment)
gitClient := gitclient.New(cfg.GitHub.PrivateKeyPath, cfg.GitHub.PublicKeyPath, cfg.GitPath)
repoWhitelist := notifications.BuildWhitelist(cfg.Whitelist...)
formatter := notifications.NewSlackNotificationFormatter()
traceClient, err := trace.NewClient(context.Background(), cfg.Trace.ProjectName)
if err != nil {
logger.Error("failed-to-create-trace-client", err)
}
slackHTTPClient := &http.Client{
Timeout: 5 * time.Second,
}
notifier := notifications.NewSlackNotifier(clk, slackHTTPClient, formatter)
certificate, caCertPool := loadCerts(
cfg.Identity.CertificatePath,
cfg.Identity.PrivateKeyPath,
cfg.Identity.PrivateKeyPassphrase,
cfg.Identity.CACertificatePath,
)
rolodexServerAddr := fmt.Sprintf("%s:%d", cfg.Rolodex.ServerAddress, cfg.Rolodex.ServerPort)
tlsConfig := tlsconfig.Build(
tlsconfig.WithInternalServiceDefaults(),
tlsconfig.WithIdentity(certificate),
)
transportCreds := credentials.NewTLS(tlsConfig.Client(tlsconfig.WithAuthority(caCertPool)))
conn, err := grpc.Dial(
rolodexServerAddr,
grpc.WithDialer(keepAliveDial),
grpc.WithTransportCredentials(transportCreds),
grpc.WithUnaryInterceptor(traceClient.GRPCClientInterceptor()),
)
if err != nil {
log.Fatalf("failed to connect to rolodex: %s", err)
}
rolodexClient := rolodexpb.NewRolodexClient(conn)
teamURLs := notifications.NewTeamURLs(
cfg.Slack.DefaultURL,
cfg.Slack.DefaultPublicChannel,
cfg.Slack.DefaultPrivateChannel,
cfg.Slack.TeamURLs,
)
addressBook := notifications.NewRolodex(
rolodexClient,
teamURLs,
)
router := notifications.NewRouter(
notifier,
addressBook,
repoWhitelist,
)
sniffer := sniff.NewDefaultSniffer()
scanner := revok.NewScanner(
gitClient,
repositoryRepository,
scanRepository,
credentialRepository,
sniffer,
)
notificationComposer := revok.NewNotificationComposer(
repositoryRepository,
router,
scanner,
)
if cfg.GitHub.AccessToken != "" {
githubHTTPClient := &http.Client{
Timeout: 30 * time.Second,
Transport: &oauth2.Transport{
Source: oauth2.StaticTokenSource(
&oauth2.Token{AccessToken: cfg.GitHub.AccessToken},
),
Base: &http.Transport{
DisableKeepAlives: true,
},
},
}
gh := github.NewClient(githubHTTPClient)
ghClient = revok.NewGitHubClient(gh.Repositories)
}
changeFetcher := revok.NewChangeFetcher(
logger,
gitClient,
ghClient,
notificationComposer,
repositoryRepository,
fetchRepository,
emitter,
)
changeScheduleRunner := revok.NewScheduleRunner(logger)
changeScheduler := revok.NewChangeScheduler(
logger,
repositoryRepository,
changeScheduleRunner,
changeFetcher,
)
cloner := revok.NewCloner(
logger,
workdir,
cloneMsgCh,
gitClient,
repositoryRepository,
notificationComposer,
emitter,
changeScheduler,
)
dirscanUpdater := revok.NewRescanner(
logger,
scanRepository,
credentialRepository,
scanner,
router,
emitter,
)
statsReporter := stats.NewReporter(
logger,
clk,
60*time.Second,
db.NewStatsRepository(database),
emitter,
)
headCredentialCounter := revok.NewHeadCredentialCounter(
logger,
branchRepository,
repositoryRepository,
clk,
cfg.CredentialCounterInterval,
gitClient,
sniffer,
)
gitGCRunner := revok.NewGitGCRunner(logger, clk, repositoryRepository, gitClient, 24*time.Hour)
debug := admin.Runner(
"6060",
admin.WithInfo(info),
admin.WithUptime(),
)
members := []grouper.Member{
{Name: "cloner", Runner: cloner},
{Name: "dirscan-updater", Runner: dirscanUpdater},
{Name: "stats-reporter", Runner: statsReporter},
{Name: "head-credential-counter", Runner: headCredentialCounter},
{Name: "change-schedule-runner", Runner: changeScheduleRunner},
{Name: "git-gc-runner", Runner: gitGCRunner},
{Name: "debug", Runner: debug},
}
looper := gitclient.NewLooper()
searcher := search.NewSearcher(repositoryRepository, looper)
fileLookup := gitclient.NewFileLookup()
blobSearcher := search.NewBlobSearcher(repositoryRepository, fileLookup)
handler := api.NewSearchServer(logger, searcher, blobSearcher)
serverTLS := tlsConfig.Server(tlsconfig.WithClientAuthentication(caCertPool))
grpcServer := grpcrunner.New(
logger,
fmt.Sprintf("127.0.0.1:%d", cfg.API.BindPort),
func(server *grpc.Server) {
revokpb.RegisterRevokSearchServer(server, handler)
},
grpc.Creds(credentials.NewTLS(serverTLS)),
)
members = append(members, grouper.Member{
Name: "grpc-server",
Runner: grpcServer,
})
pubSubClient, err := pubsub.NewClient(context.Background(), cfg.PubSub.ProjectName)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
subscription := pubSubClient.Subscription(cfg.PubSub.FetchHint.Subscription)
publicKey, err := crypto.ReadRSAPublicKey(cfg.PubSub.PublicKeyPath)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
pushEventProcessor := queue.NewPushEventProcessor(
changeFetcher,
emitter,
clk,
traceClient,
)
signatureChecker := queue.NewSignatureCheck(crypto.NewRSAVerifier(publicKey), emitter, pushEventProcessor)
members = append(members, grouper.Member{
Name: "github-hint-handler",
Runner: queue.NewPubSubSubscriber(logger, subscription, signatureChecker, emitter),
})
if cfg.GitHub.AccessToken != "" {
repoDiscoverer := revok.NewRepoDiscoverer(
logger,
workdir,
cloneMsgCh,
ghClient,
clk,
cfg.RepositoryDiscovery.Interval,
cfg.RepositoryDiscovery.Organizations,
cfg.RepositoryDiscovery.Users,
repositoryRepository,
)
members = append(members, grouper.Member{
Name: "repo-discoverer",
Runner: repoDiscoverer,
})
}
startupTasks := []grouper.Member{
{
Name: "schedule-fetches",
Runner: changeScheduler,
},
}
system := []grouper.Member{
{
Name: "servers",
Runner: grouper.NewParallel(os.Interrupt, members),
},
{
Name: "startup-tasks",
Runner: grouper.NewParallel(os.Interrupt, startupTasks),
},
}
runner := sigmon.New(grouper.NewOrdered(os.Interrupt, system))
err = <-ifrit.Invoke(runner).Wait()
if err != nil {
log.Fatalf("failed-to-start: %s", err)
}
}
func loadCerts(certificatePath, privateKeyPath, privateKeyPassphrase, caCertificatePath string) (tls.Certificate, *x509.CertPool) {
certificate, err := config.LoadCertificateFromFiles(
certificatePath,
privateKeyPath,
privateKeyPassphrase,
)
if err != nil {
log.Fatalln(err)
}
caCertPool, err := config.LoadCertificatePoolFromFiles(caCertificatePath)
if err != nil {
log.Fatalln(err)
}
return certificate, caCertPool
}
func | keepAliveDial | identifier_name |
|
main.go | "github.com/tedsuo/ifrit/sigmon"
"cred-alert/config"
"cred-alert/crypto"
"cred-alert/db"
"cred-alert/db/migrations"
"cred-alert/gitclient"
"cred-alert/metrics"
"cred-alert/notifications"
"cred-alert/queue"
"cred-alert/revok"
"cred-alert/revok/api"
"cred-alert/revok/stats"
"cred-alert/revokpb"
"cred-alert/search"
"cred-alert/sniff"
"rolodex/rolodexpb"
)
var info = admin.ServiceInfo{
Name: "revok",
Description: "A service which fetches new Git commits and scans them for credentials.",
Team: "PCF Security Enablement",
}
func main() {
var cfg *config.WorkerConfig
var flagOpts config.WorkerOpts
var ghClient *revok.GitHubClient
logger := lager.NewLogger("revok-worker")
logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
logger.Info("starting")
_, err := flags.Parse(&flagOpts)
if err != nil |
bs, err := ioutil.ReadFile(string(flagOpts.ConfigFile))
if err != nil {
logger.Error("failed-to-open-config-file", err)
os.Exit(1)
}
cfg, err = config.LoadWorkerConfig(bs)
if err != nil {
logger.Error("failed-to-load-config-file", err)
os.Exit(1)
}
errs := cfg.Validate()
if errs != nil {
for _, err := range errs {
fmt.Println(err.Error())
}
os.Exit(1)
}
if cfg.Metrics.SentryDSN != "" {
logger.RegisterSink(revok.NewSentrySink(cfg.Metrics.SentryDSN, cfg.Metrics.Environment))
}
if cfg.Metrics.HoneycombWriteKey != "" && cfg.Metrics.Environment != "" {
s := honeylager.NewSink(cfg.Metrics.HoneycombWriteKey, cfg.Metrics.Environment, lager.DEBUG)
defer s.Close()
logger.RegisterSink(s)
}
workdir := cfg.WorkDir
_, err = os.Lstat(workdir)
if err != nil {
log.Fatalf("workdir error: %s", err)
}
dbCertificate, dbCaCertPool := loadCerts(
cfg.MySQL.CertificatePath,
cfg.MySQL.PrivateKeyPath,
cfg.MySQL.PrivateKeyPassphrase,
cfg.MySQL.CACertificatePath,
)
dbURI := db.NewDSN(
cfg.MySQL.Username,
cfg.MySQL.Password,
cfg.MySQL.DBName,
cfg.MySQL.Hostname,
int(cfg.MySQL.Port),
cfg.MySQL.ServerName,
dbCertificate,
dbCaCertPool,
)
database, err := migrations.LockDBAndMigrate(logger, "mysql", dbURI)
if err != nil {
log.Fatalf("db error: %s", err)
}
database.LogMode(false)
clk := clock.NewClock()
cloneMsgCh := make(chan revok.CloneMsg)
scanRepository := db.NewScanRepository(database, clk)
repositoryRepository := db.NewRepositoryRepository(database)
fetchRepository := db.NewFetchRepository(database)
credentialRepository := db.NewCredentialRepository(database)
branchRepository := db.NewBranchRepository(database)
emitter := metrics.BuildEmitter(cfg.Metrics.DatadogAPIKey, cfg.Metrics.Environment)
gitClient := gitclient.New(cfg.GitHub.PrivateKeyPath, cfg.GitHub.PublicKeyPath, cfg.GitPath)
repoWhitelist := notifications.BuildWhitelist(cfg.Whitelist...)
formatter := notifications.NewSlackNotificationFormatter()
traceClient, err := trace.NewClient(context.Background(), cfg.Trace.ProjectName)
if err != nil {
logger.Error("failed-to-create-trace-client", err)
}
slackHTTPClient := &http.Client{
Timeout: 5 * time.Second,
}
notifier := notifications.NewSlackNotifier(clk, slackHTTPClient, formatter)
certificate, caCertPool := loadCerts(
cfg.Identity.CertificatePath,
cfg.Identity.PrivateKeyPath,
cfg.Identity.PrivateKeyPassphrase,
cfg.Identity.CACertificatePath,
)
rolodexServerAddr := fmt.Sprintf("%s:%d", cfg.Rolodex.ServerAddress, cfg.Rolodex.ServerPort)
tlsConfig := tlsconfig.Build(
tlsconfig.WithInternalServiceDefaults(),
tlsconfig.WithIdentity(certificate),
)
transportCreds := credentials.NewTLS(tlsConfig.Client(tlsconfig.WithAuthority(caCertPool)))
conn, err := grpc.Dial(
rolodexServerAddr,
grpc.WithDialer(keepAliveDial),
grpc.WithTransportCredentials(transportCreds),
grpc.WithUnaryInterceptor(traceClient.GRPCClientInterceptor()),
)
if err != nil {
log.Fatalf("failed to connect to rolodex: %s", err)
}
rolodexClient := rolodexpb.NewRolodexClient(conn)
teamURLs := notifications.NewTeamURLs(
cfg.Slack.DefaultURL,
cfg.Slack.DefaultPublicChannel,
cfg.Slack.DefaultPrivateChannel,
cfg.Slack.TeamURLs,
)
addressBook := notifications.NewRolodex(
rolodexClient,
teamURLs,
)
router := notifications.NewRouter(
notifier,
addressBook,
repoWhitelist,
)
sniffer := sniff.NewDefaultSniffer()
scanner := revok.NewScanner(
gitClient,
repositoryRepository,
scanRepository,
credentialRepository,
sniffer,
)
notificationComposer := revok.NewNotificationComposer(
repositoryRepository,
router,
scanner,
)
if cfg.GitHub.AccessToken != "" {
githubHTTPClient := &http.Client{
Timeout: 30 * time.Second,
Transport: &oauth2.Transport{
Source: oauth2.StaticTokenSource(
&oauth2.Token{AccessToken: cfg.GitHub.AccessToken},
),
Base: &http.Transport{
DisableKeepAlives: true,
},
},
}
gh := github.NewClient(githubHTTPClient)
ghClient = revok.NewGitHubClient(gh.Repositories)
}
changeFetcher := revok.NewChangeFetcher(
logger,
gitClient,
ghClient,
notificationComposer,
repositoryRepository,
fetchRepository,
emitter,
)
changeScheduleRunner := revok.NewScheduleRunner(logger)
changeScheduler := revok.NewChangeScheduler(
logger,
repositoryRepository,
changeScheduleRunner,
changeFetcher,
)
cloner := revok.NewCloner(
logger,
workdir,
cloneMsgCh,
gitClient,
repositoryRepository,
notificationComposer,
emitter,
changeScheduler,
)
dirscanUpdater := revok.NewRescanner(
logger,
scanRepository,
credentialRepository,
scanner,
router,
emitter,
)
statsReporter := stats.NewReporter(
logger,
clk,
60*time.Second,
db.NewStatsRepository(database),
emitter,
)
headCredentialCounter := revok.NewHeadCredentialCounter(
logger,
branchRepository,
repositoryRepository,
clk,
cfg.CredentialCounterInterval,
gitClient,
sniffer,
)
gitGCRunner := revok.NewGitGCRunner(logger, clk, repositoryRepository, gitClient, 24*time.Hour)
debug := admin.Runner(
"6060",
admin.WithInfo(info),
admin.WithUptime(),
)
members := []grouper.Member{
{Name: "cloner", Runner: cloner},
{Name: "dirscan-updater", Runner: dirscanUpdater},
{Name: "stats-reporter", Runner: statsReporter},
{Name: "head-credential-counter", Runner: headCredentialCounter},
{Name: "change-schedule-runner", Runner: changeScheduleRunner},
{Name: "git-gc-runner", Runner: gitGCRunner},
{Name: "debug", Runner: debug},
}
looper := gitclient.NewLooper()
searcher := search.NewSearcher(repositoryRepository, looper)
fileLookup := gitclient.NewFileLookup()
blobSearcher := search.NewBlobSearcher(repositoryRepository, fileLookup)
handler := api.NewSearchServer(logger, searcher, blobSearcher)
serverTLS := tlsConfig.Server(tlsconfig.WithClientAuthentication(caCertPool))
grpcServer := grpcrunner.New(
logger,
fmt.Sprintf("127.0.0.1:%d", cfg.API.BindPort),
func(server *grpc.Server) {
revokpb.RegisterRevokSearchServer(server, handler)
},
grpc.Creds(credentials.NewTLS(serverTLS)),
)
members = append(members, grouper.Member{
Name: "grpc-server",
Runner: grpcServer,
})
pubSubClient, err := pubsub.NewClient(context.Background(), cfg.PubSub.ProjectName)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
subscription := pubSubClient.Subscription(cfg.PubSub.FetchHint.Subscription)
publicKey, err := crypto.ReadRSAPublicKey(cfg.PubSub.PublicKeyPath)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
pushEventProcessor | {
os.Exit(1)
} | conditional_block |
main.go | "github.com/tedsuo/ifrit/sigmon"
"cred-alert/config"
"cred-alert/crypto"
"cred-alert/db"
"cred-alert/db/migrations"
"cred-alert/gitclient"
"cred-alert/metrics"
"cred-alert/notifications"
"cred-alert/queue"
"cred-alert/revok"
"cred-alert/revok/api"
"cred-alert/revok/stats"
"cred-alert/revokpb"
"cred-alert/search"
"cred-alert/sniff"
"rolodex/rolodexpb"
)
var info = admin.ServiceInfo{
Name: "revok",
Description: "A service which fetches new Git commits and scans them for credentials.",
Team: "PCF Security Enablement",
}
func main() |
cfg, err = config.LoadWorkerConfig(bs)
if err != nil {
logger.Error("failed-to-load-config-file", err)
os.Exit(1)
}
errs := cfg.Validate()
if errs != nil {
for _, err := range errs {
fmt.Println(err.Error())
}
os.Exit(1)
}
if cfg.Metrics.SentryDSN != "" {
logger.RegisterSink(revok.NewSentrySink(cfg.Metrics.SentryDSN, cfg.Metrics.Environment))
}
if cfg.Metrics.HoneycombWriteKey != "" && cfg.Metrics.Environment != "" {
s := honeylager.NewSink(cfg.Metrics.HoneycombWriteKey, cfg.Metrics.Environment, lager.DEBUG)
defer s.Close()
logger.RegisterSink(s)
}
workdir := cfg.WorkDir
_, err = os.Lstat(workdir)
if err != nil {
log.Fatalf("workdir error: %s", err)
}
dbCertificate, dbCaCertPool := loadCerts(
cfg.MySQL.CertificatePath,
cfg.MySQL.PrivateKeyPath,
cfg.MySQL.PrivateKeyPassphrase,
cfg.MySQL.CACertificatePath,
)
dbURI := db.NewDSN(
cfg.MySQL.Username,
cfg.MySQL.Password,
cfg.MySQL.DBName,
cfg.MySQL.Hostname,
int(cfg.MySQL.Port),
cfg.MySQL.ServerName,
dbCertificate,
dbCaCertPool,
)
database, err := migrations.LockDBAndMigrate(logger, "mysql", dbURI)
if err != nil {
log.Fatalf("db error: %s", err)
}
database.LogMode(false)
clk := clock.NewClock()
cloneMsgCh := make(chan revok.CloneMsg)
scanRepository := db.NewScanRepository(database, clk)
repositoryRepository := db.NewRepositoryRepository(database)
fetchRepository := db.NewFetchRepository(database)
credentialRepository := db.NewCredentialRepository(database)
branchRepository := db.NewBranchRepository(database)
emitter := metrics.BuildEmitter(cfg.Metrics.DatadogAPIKey, cfg.Metrics.Environment)
gitClient := gitclient.New(cfg.GitHub.PrivateKeyPath, cfg.GitHub.PublicKeyPath, cfg.GitPath)
repoWhitelist := notifications.BuildWhitelist(cfg.Whitelist...)
formatter := notifications.NewSlackNotificationFormatter()
traceClient, err := trace.NewClient(context.Background(), cfg.Trace.ProjectName)
if err != nil {
logger.Error("failed-to-create-trace-client", err)
}
slackHTTPClient := &http.Client{
Timeout: 5 * time.Second,
}
notifier := notifications.NewSlackNotifier(clk, slackHTTPClient, formatter)
certificate, caCertPool := loadCerts(
cfg.Identity.CertificatePath,
cfg.Identity.PrivateKeyPath,
cfg.Identity.PrivateKeyPassphrase,
cfg.Identity.CACertificatePath,
)
rolodexServerAddr := fmt.Sprintf("%s:%d", cfg.Rolodex.ServerAddress, cfg.Rolodex.ServerPort)
tlsConfig := tlsconfig.Build(
tlsconfig.WithInternalServiceDefaults(),
tlsconfig.WithIdentity(certificate),
)
transportCreds := credentials.NewTLS(tlsConfig.Client(tlsconfig.WithAuthority(caCertPool)))
conn, err := grpc.Dial(
rolodexServerAddr,
grpc.WithDialer(keepAliveDial),
grpc.WithTransportCredentials(transportCreds),
grpc.WithUnaryInterceptor(traceClient.GRPCClientInterceptor()),
)
if err != nil {
log.Fatalf("failed to connect to rolodex: %s", err)
}
rolodexClient := rolodexpb.NewRolodexClient(conn)
teamURLs := notifications.NewTeamURLs(
cfg.Slack.DefaultURL,
cfg.Slack.DefaultPublicChannel,
cfg.Slack.DefaultPrivateChannel,
cfg.Slack.TeamURLs,
)
addressBook := notifications.NewRolodex(
rolodexClient,
teamURLs,
)
router := notifications.NewRouter(
notifier,
addressBook,
repoWhitelist,
)
sniffer := sniff.NewDefaultSniffer()
scanner := revok.NewScanner(
gitClient,
repositoryRepository,
scanRepository,
credentialRepository,
sniffer,
)
notificationComposer := revok.NewNotificationComposer(
repositoryRepository,
router,
scanner,
)
if cfg.GitHub.AccessToken != "" {
githubHTTPClient := &http.Client{
Timeout: 30 * time.Second,
Transport: &oauth2.Transport{
Source: oauth2.StaticTokenSource(
&oauth2.Token{AccessToken: cfg.GitHub.AccessToken},
),
Base: &http.Transport{
DisableKeepAlives: true,
},
},
}
gh := github.NewClient(githubHTTPClient)
ghClient = revok.NewGitHubClient(gh.Repositories)
}
changeFetcher := revok.NewChangeFetcher(
logger,
gitClient,
ghClient,
notificationComposer,
repositoryRepository,
fetchRepository,
emitter,
)
changeScheduleRunner := revok.NewScheduleRunner(logger)
changeScheduler := revok.NewChangeScheduler(
logger,
repositoryRepository,
changeScheduleRunner,
changeFetcher,
)
cloner := revok.NewCloner(
logger,
workdir,
cloneMsgCh,
gitClient,
repositoryRepository,
notificationComposer,
emitter,
changeScheduler,
)
dirscanUpdater := revok.NewRescanner(
logger,
scanRepository,
credentialRepository,
scanner,
router,
emitter,
)
statsReporter := stats.NewReporter(
logger,
clk,
60*time.Second,
db.NewStatsRepository(database),
emitter,
)
headCredentialCounter := revok.NewHeadCredentialCounter(
logger,
branchRepository,
repositoryRepository,
clk,
cfg.CredentialCounterInterval,
gitClient,
sniffer,
)
gitGCRunner := revok.NewGitGCRunner(logger, clk, repositoryRepository, gitClient, 24*time.Hour)
debug := admin.Runner(
"6060",
admin.WithInfo(info),
admin.WithUptime(),
)
members := []grouper.Member{
{Name: "cloner", Runner: cloner},
{Name: "dirscan-updater", Runner: dirscanUpdater},
{Name: "stats-reporter", Runner: statsReporter},
{Name: "head-credential-counter", Runner: headCredentialCounter},
{Name: "change-schedule-runner", Runner: changeScheduleRunner},
{Name: "git-gc-runner", Runner: gitGCRunner},
{Name: "debug", Runner: debug},
}
looper := gitclient.NewLooper()
searcher := search.NewSearcher(repositoryRepository, looper)
fileLookup := gitclient.NewFileLookup()
blobSearcher := search.NewBlobSearcher(repositoryRepository, fileLookup)
handler := api.NewSearchServer(logger, searcher, blobSearcher)
serverTLS := tlsConfig.Server(tlsconfig.WithClientAuthentication(caCertPool))
grpcServer := grpcrunner.New(
logger,
fmt.Sprintf("127.0.0.1:%d", cfg.API.BindPort),
func(server *grpc.Server) {
revokpb.RegisterRevokSearchServer(server, handler)
},
grpc.Creds(credentials.NewTLS(serverTLS)),
)
members = append(members, grouper.Member{
Name: "grpc-server",
Runner: grpcServer,
})
pubSubClient, err := pubsub.NewClient(context.Background(), cfg.PubSub.ProjectName)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
subscription := pubSubClient.Subscription(cfg.PubSub.FetchHint.Subscription)
publicKey, err := crypto.ReadRSAPublicKey(cfg.PubSub.PublicKeyPath)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
pushEventProcessor | {
var cfg *config.WorkerConfig
var flagOpts config.WorkerOpts
var ghClient *revok.GitHubClient
logger := lager.NewLogger("revok-worker")
logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
logger.Info("starting")
_, err := flags.Parse(&flagOpts)
if err != nil {
os.Exit(1)
}
bs, err := ioutil.ReadFile(string(flagOpts.ConfigFile))
if err != nil {
logger.Error("failed-to-open-config-file", err)
os.Exit(1)
} | identifier_body |
main.go | "cred-alert/db"
"cred-alert/db/migrations"
"cred-alert/gitclient"
"cred-alert/metrics"
"cred-alert/notifications"
"cred-alert/queue"
"cred-alert/revok"
"cred-alert/revok/api"
"cred-alert/revok/stats"
"cred-alert/revokpb"
"cred-alert/search"
"cred-alert/sniff"
"rolodex/rolodexpb"
)
var info = admin.ServiceInfo{
Name: "revok",
Description: "A service which fetches new Git commits and scans them for credentials.",
Team: "PCF Security Enablement",
}
func main() {
var cfg *config.WorkerConfig
var flagOpts config.WorkerOpts
var ghClient *revok.GitHubClient
logger := lager.NewLogger("revok-worker")
logger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
logger.Info("starting")
_, err := flags.Parse(&flagOpts)
if err != nil {
os.Exit(1)
}
bs, err := ioutil.ReadFile(string(flagOpts.ConfigFile))
if err != nil {
logger.Error("failed-to-open-config-file", err)
os.Exit(1)
}
cfg, err = config.LoadWorkerConfig(bs)
if err != nil {
logger.Error("failed-to-load-config-file", err)
os.Exit(1)
}
errs := cfg.Validate()
if errs != nil {
for _, err := range errs {
fmt.Println(err.Error())
}
os.Exit(1)
}
if cfg.Metrics.SentryDSN != "" {
logger.RegisterSink(revok.NewSentrySink(cfg.Metrics.SentryDSN, cfg.Metrics.Environment))
}
if cfg.Metrics.HoneycombWriteKey != "" && cfg.Metrics.Environment != "" {
s := honeylager.NewSink(cfg.Metrics.HoneycombWriteKey, cfg.Metrics.Environment, lager.DEBUG)
defer s.Close()
logger.RegisterSink(s)
}
workdir := cfg.WorkDir
_, err = os.Lstat(workdir)
if err != nil {
log.Fatalf("workdir error: %s", err)
}
dbCertificate, dbCaCertPool := loadCerts(
cfg.MySQL.CertificatePath,
cfg.MySQL.PrivateKeyPath,
cfg.MySQL.PrivateKeyPassphrase,
cfg.MySQL.CACertificatePath,
)
dbURI := db.NewDSN(
cfg.MySQL.Username,
cfg.MySQL.Password,
cfg.MySQL.DBName,
cfg.MySQL.Hostname,
int(cfg.MySQL.Port),
cfg.MySQL.ServerName,
dbCertificate,
dbCaCertPool,
)
database, err := migrations.LockDBAndMigrate(logger, "mysql", dbURI)
if err != nil {
log.Fatalf("db error: %s", err)
}
database.LogMode(false)
clk := clock.NewClock()
cloneMsgCh := make(chan revok.CloneMsg)
scanRepository := db.NewScanRepository(database, clk)
repositoryRepository := db.NewRepositoryRepository(database)
fetchRepository := db.NewFetchRepository(database)
credentialRepository := db.NewCredentialRepository(database)
branchRepository := db.NewBranchRepository(database)
emitter := metrics.BuildEmitter(cfg.Metrics.DatadogAPIKey, cfg.Metrics.Environment)
gitClient := gitclient.New(cfg.GitHub.PrivateKeyPath, cfg.GitHub.PublicKeyPath, cfg.GitPath)
repoWhitelist := notifications.BuildWhitelist(cfg.Whitelist...)
formatter := notifications.NewSlackNotificationFormatter()
traceClient, err := trace.NewClient(context.Background(), cfg.Trace.ProjectName)
if err != nil {
logger.Error("failed-to-create-trace-client", err)
}
slackHTTPClient := &http.Client{
Timeout: 5 * time.Second,
}
notifier := notifications.NewSlackNotifier(clk, slackHTTPClient, formatter)
certificate, caCertPool := loadCerts(
cfg.Identity.CertificatePath,
cfg.Identity.PrivateKeyPath,
cfg.Identity.PrivateKeyPassphrase,
cfg.Identity.CACertificatePath,
)
rolodexServerAddr := fmt.Sprintf("%s:%d", cfg.Rolodex.ServerAddress, cfg.Rolodex.ServerPort)
tlsConfig := tlsconfig.Build(
tlsconfig.WithInternalServiceDefaults(),
tlsconfig.WithIdentity(certificate),
)
transportCreds := credentials.NewTLS(tlsConfig.Client(tlsconfig.WithAuthority(caCertPool)))
conn, err := grpc.Dial(
rolodexServerAddr,
grpc.WithDialer(keepAliveDial),
grpc.WithTransportCredentials(transportCreds),
grpc.WithUnaryInterceptor(traceClient.GRPCClientInterceptor()),
)
if err != nil {
log.Fatalf("failed to connect to rolodex: %s", err)
}
rolodexClient := rolodexpb.NewRolodexClient(conn)
teamURLs := notifications.NewTeamURLs(
cfg.Slack.DefaultURL,
cfg.Slack.DefaultPublicChannel,
cfg.Slack.DefaultPrivateChannel,
cfg.Slack.TeamURLs,
)
addressBook := notifications.NewRolodex(
rolodexClient,
teamURLs,
)
router := notifications.NewRouter(
notifier,
addressBook,
repoWhitelist,
)
sniffer := sniff.NewDefaultSniffer()
scanner := revok.NewScanner(
gitClient,
repositoryRepository,
scanRepository,
credentialRepository,
sniffer,
)
notificationComposer := revok.NewNotificationComposer(
repositoryRepository,
router,
scanner,
)
if cfg.GitHub.AccessToken != "" {
githubHTTPClient := &http.Client{
Timeout: 30 * time.Second,
Transport: &oauth2.Transport{
Source: oauth2.StaticTokenSource(
&oauth2.Token{AccessToken: cfg.GitHub.AccessToken},
),
Base: &http.Transport{
DisableKeepAlives: true,
},
},
}
gh := github.NewClient(githubHTTPClient)
ghClient = revok.NewGitHubClient(gh.Repositories)
}
changeFetcher := revok.NewChangeFetcher(
logger,
gitClient,
ghClient,
notificationComposer,
repositoryRepository,
fetchRepository,
emitter,
)
changeScheduleRunner := revok.NewScheduleRunner(logger)
changeScheduler := revok.NewChangeScheduler(
logger,
repositoryRepository,
changeScheduleRunner,
changeFetcher,
)
cloner := revok.NewCloner(
logger,
workdir,
cloneMsgCh,
gitClient,
repositoryRepository,
notificationComposer,
emitter,
changeScheduler,
)
dirscanUpdater := revok.NewRescanner(
logger,
scanRepository,
credentialRepository,
scanner,
router,
emitter,
)
statsReporter := stats.NewReporter(
logger,
clk,
60*time.Second,
db.NewStatsRepository(database),
emitter,
)
headCredentialCounter := revok.NewHeadCredentialCounter(
logger,
branchRepository,
repositoryRepository,
clk,
cfg.CredentialCounterInterval,
gitClient,
sniffer,
)
gitGCRunner := revok.NewGitGCRunner(logger, clk, repositoryRepository, gitClient, 24*time.Hour)
debug := admin.Runner(
"6060",
admin.WithInfo(info),
admin.WithUptime(),
)
members := []grouper.Member{
{Name: "cloner", Runner: cloner},
{Name: "dirscan-updater", Runner: dirscanUpdater},
{Name: "stats-reporter", Runner: statsReporter},
{Name: "head-credential-counter", Runner: headCredentialCounter},
{Name: "change-schedule-runner", Runner: changeScheduleRunner},
{Name: "git-gc-runner", Runner: gitGCRunner},
{Name: "debug", Runner: debug},
}
looper := gitclient.NewLooper()
searcher := search.NewSearcher(repositoryRepository, looper)
fileLookup := gitclient.NewFileLookup()
blobSearcher := search.NewBlobSearcher(repositoryRepository, fileLookup)
handler := api.NewSearchServer(logger, searcher, blobSearcher)
serverTLS := tlsConfig.Server(tlsconfig.WithClientAuthentication(caCertPool))
grpcServer := grpcrunner.New(
logger,
fmt.Sprintf("127.0.0.1:%d", cfg.API.BindPort),
func(server *grpc.Server) {
revokpb.RegisterRevokSearchServer(server, handler)
},
grpc.Creds(credentials.NewTLS(serverTLS)),
)
members = append(members, grouper.Member{
Name: "grpc-server",
Runner: grpcServer,
})
pubSubClient, err := pubsub.NewClient(context.Background(), cfg.PubSub.ProjectName)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
subscription := pubSubClient.Subscription(cfg.PubSub.FetchHint.Subscription)
publicKey, err := crypto.ReadRSAPublicKey(cfg.PubSub.PublicKeyPath)
if err != nil {
logger.Fatal("failed", err)
os.Exit(1)
}
pushEventProcessor := queue.NewPushEventProcessor(
changeFetcher,
emitter,
clk,
traceClient,
) | random_line_split |
||
task.rs | currently running, but has been notified that it must run again.
Notified,
/// Task has been scheduled
Scheduled,
/// Task is complete
Complete,
}
// ===== impl Task =====
impl Task {
/// Create a new task handle
pub fn new(future: BoxFuture) -> Task {
let task_fut = TaskFuture::Futures1(executor::spawn(future));
let inner = Box::new(Inner {
next: AtomicPtr::new(ptr::null_mut()),
state: AtomicUsize::new(State::new().into()),
ref_count: AtomicUsize::new(1),
future: Some(task_fut),
});
Task { ptr: Box::into_raw(inner) }
}
/// Create a new task handle for a futures 0.2 future
#[cfg(feature = "unstable-futures")]
pub fn new2<F>(fut: BoxFuture2, make_waker: F) -> Task
where F: FnOnce(usize) -> futures2::task::Waker
{
let mut inner = Box::new(Inner {
next: AtomicPtr::new(ptr::null_mut()),
state: AtomicUsize::new(State::new().into()),
ref_count: AtomicUsize::new(1),
future: None,
});
let waker = make_waker((&*inner) as *const _ as usize);
let tls = futures2::task::LocalMap::new();
inner.future = Some(TaskFuture::Futures2 { waker, tls, fut });
Task { ptr: Box::into_raw(inner) }
}
/// Transmute a u64 to a Task
pub unsafe fn from_notify_id(unpark_id: usize) -> Task {
mem::transmute(unpark_id)
}
/// Transmute a u64 to a task ref
pub unsafe fn from_notify_id_ref<'a>(unpark_id: &'a usize) -> &'a Task {
mem::transmute(unpark_id)
}
/// Execute the task returning `Run::Schedule` if the task needs to be
/// scheduled again.
pub fn run(&self, unpark: &Arc<Notifier>, exec: &mut Sender) -> Run {
use self::State::*;
// Transition task to running state. At this point, the task must be
// scheduled.
let actual: State = self.inner().state.compare_and_swap(
Scheduled.into(), Running.into(), AcqRel).into();
trace!("running; state={:?}", actual);
match actual {
Scheduled => {},
_ => panic!("unexpected task state; {:?}", actual),
}
trace!("Task::run; state={:?}", State::from(self.inner().state.load(Relaxed)));
let fut = &mut self.inner_mut().future;
// This block deals with the future panicking while being polled.
//
// If the future panics, then the drop handler must be called such that
// `thread::panicking() -> true`. To do this, the future is dropped from
// within the catch_unwind block.
let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
struct Guard<'a>(&'a mut Option<TaskFuture>, bool);
impl<'a> Drop for Guard<'a> {
fn drop(&mut self) {
// This drops the future
if self.1 {
let _ = self.0.take();
}
}
}
let mut g = Guard(fut, true);
let ret = g.0.as_mut().unwrap()
.poll(unpark, self.ptr as usize, exec);
g.1 = false;
ret
}));
match res {
Ok(Ok(Async::Ready(_))) | Ok(Err(_)) | Err(_) => {
trace!(" -> task complete");
// Drop the future
self.inner_mut().drop_future();
// Transition to the completed state
self.inner().state.store(State::Complete.into(), Release);
Run::Complete
}
Ok(Ok(Async::NotReady)) => {
trace!(" -> not ready");
// Attempt to transition from Running -> Idle, if successful,
// then the task does not need to be scheduled again. If the CAS
// fails, then the task has been unparked concurrent to running,
// in which case it transitions immediately back to scheduled
// and we return `true`.
let prev: State = self.inner().state.compare_and_swap(
Running.into(), Idle.into(), AcqRel).into();
match prev {
Running => Run::Idle,
Notified => {
self.inner().state.store(Scheduled.into(), Release);
Run::Schedule
}
_ => unreachable!(),
}
}
}
}
/// Transition the task state to scheduled.
///
/// Returns `true` if the caller is permitted to schedule the task.
pub fn schedule(&self) -> bool {
use self::State::*;
loop {
let actual = self.inner().state.compare_and_swap(
Idle.into(),
Scheduled.into(),
AcqRel).into();
match actual {
Idle => return true,
Running => {
let actual = self.inner().state.compare_and_swap(
Running.into(), Notified.into(), AcqRel).into();
match actual {
Idle => continue,
_ => return false,
}
}
Complete | Notified | Scheduled => return false,
}
}
}
#[inline]
fn inner(&self) -> &Inner {
unsafe { &*self.ptr }
}
#[inline]
fn inner_mut(&self) -> &mut Inner {
unsafe { &mut *self.ptr }
}
}
impl fmt::Debug for Task {
fn | (&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Task")
.field("inner", self.inner())
.finish()
}
}
impl Clone for Task {
fn clone(&self) -> Task {
use std::isize;
const MAX_REFCOUNT: usize = (isize::MAX) as usize;
// Using a relaxed ordering is alright here, as knowledge of the
// original reference prevents other threads from erroneously deleting
// the object.
//
// As explained in the [Boost documentation][1], Increasing the
// reference counter can always be done with memory_order_relaxed: New
// references to an object can only be formed from an existing
// reference, and passing an existing reference from one thread to
// another must already provide any required synchronization.
//
// [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
let old_size = self.inner().ref_count.fetch_add(1, Relaxed);
// However we need to guard against massive refcounts in case someone
// is `mem::forget`ing Arcs. If we don't do this the count can overflow
// and users will use-after free. We racily saturate to `isize::MAX` on
// the assumption that there aren't ~2 billion threads incrementing
// the reference count at once. This branch will never be taken in
// any realistic program.
//
// We abort because such a program is incredibly degenerate, and we
// don't care to support it.
if old_size > MAX_REFCOUNT {
// TODO: abort
panic!();
}
Task { ptr: self.ptr }
}
}
impl Drop for Task {
fn drop(&mut self) {
// Because `fetch_sub` is already atomic, we do not need to synchronize
// with other threads unless we are going to delete the object. This
// same logic applies to the below `fetch_sub` to the `weak` count.
if self.inner().ref_count.fetch_sub(1, Release) != 1 {
return;
}
// This fence is needed to prevent reordering of use of the data and
// deletion of the data. Because it is marked `Release`, the decreasing
// of the reference count synchronizes with this `Acquire` fence. This
// means that use of the data happens before decreasing the reference
// count, which happens before this fence, which happens before the
// deletion of the data.
//
// As explained in the [Boost documentation][1],
//
// > It is important to enforce any possible access to the object in one
// > thread (through an existing reference) to *happen before* deleting
// > the object in a different thread. This is achieved by a "release"
// > operation after dropping a reference (any access to the object
// > through this reference must obviously happened before), and an
// > "acquire" operation before deleting the object.
//
// [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
atomic::fence(Acquire);
unsafe {
let _ = Box::from_raw(self.ptr);
}
}
}
unsafe impl Send for Task {}
// ===== impl Inner =====
impl Inner {
fn stub() -> Inner {
Inner {
next: AtomicPtr::new(ptr::null_mut()),
state: AtomicUsize::new(State::stub().into()),
ref_count: AtomicUsize::new(0),
future: Some(TaskFuture | fmt | identifier_name |
task.rs | drop(&mut self) {
// This drops the future
if self.1 {
let _ = self.0.take();
}
}
}
let mut g = Guard(fut, true);
let ret = g.0.as_mut().unwrap()
.poll(unpark, self.ptr as usize, exec);
g.1 = false;
ret
}));
match res {
Ok(Ok(Async::Ready(_))) | Ok(Err(_)) | Err(_) => {
trace!(" -> task complete");
// Drop the future
self.inner_mut().drop_future();
// Transition to the completed state
self.inner().state.store(State::Complete.into(), Release);
Run::Complete
}
Ok(Ok(Async::NotReady)) => {
trace!(" -> not ready");
// Attempt to transition from Running -> Idle, if successful,
// then the task does not need to be scheduled again. If the CAS
// fails, then the task has been unparked concurrent to running,
// in which case it transitions immediately back to scheduled
// and we return `true`.
let prev: State = self.inner().state.compare_and_swap(
Running.into(), Idle.into(), AcqRel).into();
match prev {
Running => Run::Idle,
Notified => {
self.inner().state.store(Scheduled.into(), Release);
Run::Schedule
}
_ => unreachable!(),
}
}
}
}
/// Transition the task state to scheduled.
///
/// Returns `true` if the caller is permitted to schedule the task.
pub fn schedule(&self) -> bool {
use self::State::*;
loop {
let actual = self.inner().state.compare_and_swap(
Idle.into(),
Scheduled.into(),
AcqRel).into();
match actual {
Idle => return true,
Running => {
let actual = self.inner().state.compare_and_swap(
Running.into(), Notified.into(), AcqRel).into();
match actual {
Idle => continue,
_ => return false,
}
}
Complete | Notified | Scheduled => return false,
}
}
}
#[inline]
fn inner(&self) -> &Inner {
unsafe { &*self.ptr }
}
#[inline]
fn inner_mut(&self) -> &mut Inner {
unsafe { &mut *self.ptr }
}
}
impl fmt::Debug for Task {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Task")
.field("inner", self.inner())
.finish()
}
}
impl Clone for Task {
fn clone(&self) -> Task {
use std::isize;
const MAX_REFCOUNT: usize = (isize::MAX) as usize;
// Using a relaxed ordering is alright here, as knowledge of the
// original reference prevents other threads from erroneously deleting
// the object.
//
// As explained in the [Boost documentation][1], Increasing the
// reference counter can always be done with memory_order_relaxed: New
// references to an object can only be formed from an existing
// reference, and passing an existing reference from one thread to
// another must already provide any required synchronization.
//
// [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
let old_size = self.inner().ref_count.fetch_add(1, Relaxed);
// However we need to guard against massive refcounts in case someone
// is `mem::forget`ing Arcs. If we don't do this the count can overflow
// and users will use-after free. We racily saturate to `isize::MAX` on
// the assumption that there aren't ~2 billion threads incrementing
// the reference count at once. This branch will never be taken in
// any realistic program.
//
// We abort because such a program is incredibly degenerate, and we
// don't care to support it.
if old_size > MAX_REFCOUNT {
// TODO: abort
panic!();
}
Task { ptr: self.ptr }
}
}
impl Drop for Task {
fn drop(&mut self) {
// Because `fetch_sub` is already atomic, we do not need to synchronize
// with other threads unless we are going to delete the object. This
// same logic applies to the below `fetch_sub` to the `weak` count.
if self.inner().ref_count.fetch_sub(1, Release) != 1 {
return;
}
// This fence is needed to prevent reordering of use of the data and
// deletion of the data. Because it is marked `Release`, the decreasing
// of the reference count synchronizes with this `Acquire` fence. This
// means that use of the data happens before decreasing the reference
// count, which happens before this fence, which happens before the
// deletion of the data.
//
// As explained in the [Boost documentation][1],
//
// > It is important to enforce any possible access to the object in one
// > thread (through an existing reference) to *happen before* deleting
// > the object in a different thread. This is achieved by a "release"
// > operation after dropping a reference (any access to the object
// > through this reference must obviously happened before), and an
// > "acquire" operation before deleting the object.
//
// [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
atomic::fence(Acquire);
unsafe {
let _ = Box::from_raw(self.ptr);
}
}
}
unsafe impl Send for Task {}
// ===== impl Inner =====
impl Inner {
fn stub() -> Inner {
Inner {
next: AtomicPtr::new(ptr::null_mut()),
state: AtomicUsize::new(State::stub().into()),
ref_count: AtomicUsize::new(0),
future: Some(TaskFuture::Futures1(executor::spawn(Box::new(future::empty())))),
}
}
fn drop_future(&mut self) {
let _ = self.future.take();
}
}
impl Drop for Inner {
fn drop(&mut self) {
self.drop_future();
}
}
impl fmt::Debug for Inner {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Inner")
.field("next", &self.next)
.field("state", &self.state)
.field("ref_count", &self.ref_count)
.field("future", &"Spawn<BoxFuture>")
.finish()
}
}
// ===== impl Queue =====
impl Queue {
pub fn new() -> Queue {
let stub = Box::new(Inner::stub());
let ptr = &*stub as *const _ as *mut _;
Queue {
head: AtomicPtr::new(ptr),
tail: Cell::new(ptr),
stub: stub,
}
}
pub fn push(&self, handle: Task) {
unsafe {
self.push2(handle.ptr);
// Forgetting the handle is necessary to avoid the ref dec
mem::forget(handle);
}
}
unsafe fn push2(&self, handle: *mut Inner) {
// Set the next pointer. This does not require an atomic operation as
// this node is not accessible. The write will be flushed with the next
// operation
(*handle).next = AtomicPtr::new(ptr::null_mut());
// Update the head to point to the new node. We need to see the previous
// node in order to update the next pointer as well as release `handle`
// to any other threads calling `push`.
let prev = self.head.swap(handle, AcqRel);
// Release `handle` to the consume end.
(*prev).next.store(handle, Release);
}
pub unsafe fn poll(&self) -> Poll {
let mut tail = self.tail.get();
let mut next = (*tail).next.load(Acquire);
let stub = &*self.stub as *const _ as *mut _;
if tail == stub {
if next.is_null() {
return Poll::Empty;
}
self.tail.set(next);
tail = next;
next = (*next).next.load(Acquire);
}
if !next.is_null() {
self.tail.set(next);
// No ref_count inc is necessary here as this poll is paired
// with a `push` which "forgets" the handle.
return Poll::Data(Task {
ptr: tail,
});
}
if self.head.load(Acquire) != tail {
return Poll::Inconsistent;
}
self.push2(stub);
next = (*tail).next.load(Acquire);
if !next.is_null() {
self.tail.set(next);
return Poll::Data(Task {
ptr: tail,
});
}
Poll::Inconsistent
}
}
// ===== impl State =====
impl State {
/// Returns the initial task state.
///
/// Tasks start in the scheduled state as they are immediately scheduled on
/// creation.
fn new() -> State {
State::Scheduled
}
fn stub() -> State | {
State::Idle
} | identifier_body |
|
task.rs | currently running, but has been notified that it must run again.
Notified,
/// Task has been scheduled
Scheduled,
/// Task is complete
Complete,
}
// ===== impl Task =====
impl Task {
/// Create a new task handle
pub fn new(future: BoxFuture) -> Task {
let task_fut = TaskFuture::Futures1(executor::spawn(future));
let inner = Box::new(Inner {
next: AtomicPtr::new(ptr::null_mut()),
state: AtomicUsize::new(State::new().into()),
ref_count: AtomicUsize::new(1),
future: Some(task_fut),
});
Task { ptr: Box::into_raw(inner) }
}
/// Create a new task handle for a futures 0.2 future
#[cfg(feature = "unstable-futures")]
pub fn new2<F>(fut: BoxFuture2, make_waker: F) -> Task
where F: FnOnce(usize) -> futures2::task::Waker
{
let mut inner = Box::new(Inner {
next: AtomicPtr::new(ptr::null_mut()),
state: AtomicUsize::new(State::new().into()),
ref_count: AtomicUsize::new(1),
future: None,
});
let waker = make_waker((&*inner) as *const _ as usize);
let tls = futures2::task::LocalMap::new();
inner.future = Some(TaskFuture::Futures2 { waker, tls, fut });
Task { ptr: Box::into_raw(inner) }
}
/// Transmute a u64 to a Task
pub unsafe fn from_notify_id(unpark_id: usize) -> Task {
mem::transmute(unpark_id)
}
/// Transmute a u64 to a task ref
pub unsafe fn from_notify_id_ref<'a>(unpark_id: &'a usize) -> &'a Task {
mem::transmute(unpark_id)
}
/// Execute the task returning `Run::Schedule` if the task needs to be
/// scheduled again.
pub fn run(&self, unpark: &Arc<Notifier>, exec: &mut Sender) -> Run {
use self::State::*;
// Transition task to running state. At this point, the task must be
// scheduled.
let actual: State = self.inner().state.compare_and_swap(
Scheduled.into(), Running.into(), AcqRel).into();
trace!("running; state={:?}", actual);
match actual {
Scheduled => {},
_ => panic!("unexpected task state; {:?}", actual),
}
trace!("Task::run; state={:?}", State::from(self.inner().state.load(Relaxed)));
let fut = &mut self.inner_mut().future;
// This block deals with the future panicking while being polled.
//
// If the future panics, then the drop handler must be called such that
// `thread::panicking() -> true`. To do this, the future is dropped from
// within the catch_unwind block.
let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
struct Guard<'a>(&'a mut Option<TaskFuture>, bool);
impl<'a> Drop for Guard<'a> {
fn drop(&mut self) {
// This drops the future
if self.1 {
let _ = self.0.take();
}
}
}
let mut g = Guard(fut, true);
let ret = g.0.as_mut().unwrap()
.poll(unpark, self.ptr as usize, exec);
g.1 = false;
ret
}));
match res {
Ok(Ok(Async::Ready(_))) | Ok(Err(_)) | Err(_) => {
trace!(" -> task complete");
// Drop the future
self.inner_mut().drop_future();
// Transition to the completed state
self.inner().state.store(State::Complete.into(), Release);
Run::Complete
}
Ok(Ok(Async::NotReady)) => {
trace!(" -> not ready");
// Attempt to transition from Running -> Idle, if successful,
// then the task does not need to be scheduled again. If the CAS
// fails, then the task has been unparked concurrent to running,
// in which case it transitions immediately back to scheduled
// and we return `true`.
let prev: State = self.inner().state.compare_and_swap(
Running.into(), Idle.into(), AcqRel).into();
match prev {
Running => Run::Idle,
Notified => {
self.inner().state.store(Scheduled.into(), Release);
Run::Schedule
}
_ => unreachable!(),
}
}
}
}
/// Transition the task state to scheduled.
///
/// Returns `true` if the caller is permitted to schedule the task.
pub fn schedule(&self) -> bool {
use self::State::*;
loop {
let actual = self.inner().state.compare_and_swap(
Idle.into(),
Scheduled.into(),
AcqRel).into();
match actual {
Idle => return true,
Running => {
let actual = self.inner().state.compare_and_swap(
Running.into(), Notified.into(), AcqRel).into();
match actual {
Idle => continue,
_ => return false,
}
}
Complete | Notified | Scheduled => return false,
}
}
}
#[inline]
fn inner(&self) -> &Inner {
unsafe { &*self.ptr }
}
#[inline]
fn inner_mut(&self) -> &mut Inner {
unsafe { &mut *self.ptr }
}
}
impl fmt::Debug for Task {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Task")
.field("inner", self.inner())
.finish()
}
}
impl Clone for Task {
fn clone(&self) -> Task {
use std::isize;
const MAX_REFCOUNT: usize = (isize::MAX) as usize;
// Using a relaxed ordering is alright here, as knowledge of the
// original reference prevents other threads from erroneously deleting
// the object.
//
// As explained in the [Boost documentation][1], Increasing the
// reference counter can always be done with memory_order_relaxed: New
// references to an object can only be formed from an existing
// reference, and passing an existing reference from one thread to
// another must already provide any required synchronization.
//
// [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
let old_size = self.inner().ref_count.fetch_add(1, Relaxed);
// However we need to guard against massive refcounts in case someone
// is `mem::forget`ing Arcs. If we don't do this the count can overflow
// and users will use-after free. We racily saturate to `isize::MAX` on
// the assumption that there aren't ~2 billion threads incrementing
// the reference count at once. This branch will never be taken in
// any realistic program.
//
// We abort because such a program is incredibly degenerate, and we
// don't care to support it.
if old_size > MAX_REFCOUNT {
// TODO: abort
panic!();
}
Task { ptr: self.ptr }
}
}
impl Drop for Task {
fn drop(&mut self) {
// Because `fetch_sub` is already atomic, we do not need to synchronize
// with other threads unless we are going to delete the object. This
// same logic applies to the below `fetch_sub` to the `weak` count.
if self.inner().ref_count.fetch_sub(1, Release) != 1 {
return;
}
// This fence is needed to prevent reordering of use of the data and
// deletion of the data. Because it is marked `Release`, the decreasing
// of the reference count synchronizes with this `Acquire` fence. This
// means that use of the data happens before decreasing the reference
// count, which happens before this fence, which happens before the
// deletion of the data.
//
// As explained in the [Boost documentation][1],
//
// > It is important to enforce any possible access to the object in one
// > thread (through an existing reference) to *happen before* deleting
// > the object in a different thread. This is achieved by a "release"
// > operation after dropping a reference (any access to the object
// > through this reference must obviously happened before), and an
// > "acquire" operation before deleting the object.
//
// [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
atomic::fence(Acquire);
unsafe {
let _ = Box::from_raw(self.ptr);
}
}
}
unsafe impl Send for Task {} |
impl Inner {
fn stub() -> Inner {
Inner {
next: AtomicPtr::new(ptr::null_mut()),
state: AtomicUsize::new(State::stub().into()),
ref_count: AtomicUsize::new(0),
future: Some(TaskFuture |
// ===== impl Inner ===== | random_line_split |
process_test.py | az) * np.sin(az) * np.cos(elev))
G = sum(np.sin(az) * np.sin(elev))
D = sum(vel * np.cos(az))
E = sum(np.sin(az) * np.cos(az) * np.cos(elev))
F = sum(np.cos(az) ** 2 * np.cos(elev))
H = sum(np.cos(az) * np.sin(elev))
W = sum(vel)
X = sum(np.sin(az) * np.cos(elev))
Y = sum(np.cos(az) * np.cos(elev))
Z = sum(az * np.sin(elev))
# solve A = uB + vC + wG , D = uE + vF + wH and W = uX + vY+ wZ
y = np.array([[B, E, X], [C, F, Y], [G, H, Z]])
z = np.array([A, D, W])
# print y
# print z
try:
sol = np.linalg.solve(y, z)
# print sol
u = sol[0]
v = sol[1]
w = sol[2]
return u, v, w
except np.linalg.linalg.LinAlgError:
return FILL_VALUE, FILL_VALUE, FILL_VALUE
else:
return FILL_VALUE, FILL_VALUE, FILL_VALUE
def decode_header(header):
"""
Takes in a list of lines from the raw hpl file. Separates them by
tab and removes unnecessary text
"""
new_header = {}
for item in header:
split = item.split('\t')
new_header[split[0].replace(':', '')] = split[1].replace("\r\n", "")
return new_header
def _to_epoch(dt):
return (dt - datetime(1970, 1, 1)).total_seconds()
"""
process_file(in_file, out_dir, prefix):
Processes a raw halo hpl file and turns it into a netcdf
:param in_file:
:param out_dir:
:return:
"""
def writeVAD_to_nc(filename, date, elev, u, v, w, ws, wd, hgt, rmse, r_sq,up_flag,intensity):
if os.path.exists(filename):
# open the netcdf
nc = netCDF4.Dataset(filename, 'a', format="NETCDF4")
dim = nc.dimensions['t'].size
u_var = nc.variables['u']
v_var = nc.variables['v']
w_var = nc.variables['w']
ws_var = nc.variables['ws']
wd_var = nc.variables['wd']
rms_var = nc.variables['rms']
r_sq_var = nc.variables['r_sq']
time_var = nc.variables['time']
hgt_var = nc.variables['hgt']
up_flag_var = nc.variables['up_flag']
u_var[dim, :] = u
v_var[dim, :] = v
w_var[dim, :] = w
ws_var[dim, :] = ws
wd_var[dim, :] = wd
rms_var[dim, :] = rmse
r_sq_var[dim, :] = r_sq
up_flag_var[dim] = up_flag
else:
# Create the netcdf
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
# Create the height dimension
nc.createDimension('height', len(hgt))
nc.createDimension('t', None)
# Add the attributes
nc.setncattr("elev", elev)
nc.setncattr("date", date.isoformat())
# Create the variables
u_var = nc.createVariable('u', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
v_var = nc.createVariable('v', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
w_var = nc.createVariable('w', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
ws_var = nc.createVariable('ws', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
wd_var = nc.createVariable('wd', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
hgt_var = nc.createVariable('hgt', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
rms_var = nc.createVariable('rms', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
r_sq_var = nc.createVariable('r_sq', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
up_flag_var = nc.createVariable('up_flag', 'f8', ('t'))
intensity_var = nc.createVariable('intensity', 'f8', ('t','hgt'))
time_var = nc.createVariable('time', 'i8', ('t'))
time_var.setncattr('units', 'seconds since 1970-01-01 00:00:00 UTC')
dim = nc.dimensions['t'].size
u_var[dim, :] = np.where(np.isnan(u), FILL_VALUE, u)
v_var[dim, :] = np.where(np.isnan(v), FILL_VALUE, v)
w_var[dim, :] = np.where(np.isnan(w), FILL_VALUE, w)
ws_var[dim, :] = np.where(np.isnan(ws), FILL_VALUE, ws)
wd_var[dim, :] = np.where(np.isnan(wd), FILL_VALUE, wd)
hgt_var[dim, :] = np.where(np.isnan(hgt), FILL_VALUE, hgt)
rms_var[dim, :] = np.where(np.isnan(rmse), FILL_VALUE, rmse)
r_sq_var[dim, :] = np.where(np.isnan(r_sq), FILL_VALUE, r_sq)
time_var[dim] = (date - datetime(1970, 1, 1)).total_seconds()
up_flag_var[dim]=up_flag
intensity_var[dim] = intensity
# Close the netcdf
nc.close()
def writeSTARE_to_nc(filename, date, w, hgt, intensity):
|
hgt_var[:] = hgt
time_var[:] = [(d - datetime(1970, 1, 1)).total_seconds() for d in date]
w_var[:, :] = w
intensity_var[:] = intensity
# Close the netcdf
nc.close()
def writeRHI_to_nc(filename, date, vel, rng, elev, az, intensity,up_flag):
if os.path.exists(filename):
# open the netcdf
nc = netCDF4.Dataset(filename, 'r+', format="NETCDF4")
dim = nc.dimensions['t'].size
vel_var = nc.variables['velocity']
rng_var = nc.variables['range']
elev_var = nc.variables['elevation']
az_var = nc.variables['azimuth']
intensity_var = nc.variables['intensity']
time_var = nc.variables['time']
up_flag_var = nc.variables['up_flag']
# vel_var[dim, :] = vel
# rng_var[:] = rng
# elev_var[dim] = elev
# az_var[dim] = az
# intensity_var[dim, :] = intensity
else:
# Create the netcdf
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
# Create the height dimension
nc.createDimension('height', len(rng))
nc.createDimension('t', None)
# Create the variables
vel_var = nc.createVariable('velocity', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
rng_var = nc.createVariable('range', 'f8', ('height'), fill_value=FILL_VALUE)
elev_var = nc.createVariable('elevation', 'f8', ('t'), fill_value=FILL_VALUE)
az_var = nc.createVariable('azimuth', 'f8', ('t'), fill_value=FILL_VALUE)
intensity_var = nc.createVariable('intensity', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
up_flag_var = nc.createVariable('up_flag', 'f8', ('t'))
time_var = nc.createVariable('time', 'i8', ('t'))
time_var.setncattr('units', 'seconds since 1970-0 | logging.debug(filename)
logging.debug(date)
# Create the netcdf
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
# Create the height dimension
nc.createDimension('hgt', len(hgt))
nc.createDimension('t', None)
# Add the attributes
nc.setncattr("date", date[0].isoformat())
# Create the variables
w_var = nc.createVariable('w', 'f8', ('t', 'hgt'), fill_value=FILL_VALUE)
hgt_var = nc.createVariable('hgt', 'f8', ('t', 'hgt'), fill_value=FILL_VALUE)
intensity_var = nc.createVariable('intensity', 'f8', ('t','hgt'))
time_var = nc.createVariable('time', 'i8', ('t'))
time_var.setncattr('units', 'seconds since 1970-01-01 00:00:00 UTC') | identifier_body |
process_test.py | attr('units', 'seconds since 1970-01-01 00:00:00 UTC')
hgt_var[:] = hgt
time_var[:] = [(d - datetime(1970, 1, 1)).total_seconds() for d in date]
w_var[:, :] = w
intensity_var[:] = intensity
# Close the netcdf
nc.close()
def writeRHI_to_nc(filename, date, vel, rng, elev, az, intensity,up_flag):
if os.path.exists(filename):
# open the netcdf
nc = netCDF4.Dataset(filename, 'r+', format="NETCDF4")
dim = nc.dimensions['t'].size
vel_var = nc.variables['velocity']
rng_var = nc.variables['range']
elev_var = nc.variables['elevation']
az_var = nc.variables['azimuth']
intensity_var = nc.variables['intensity']
time_var = nc.variables['time']
up_flag_var = nc.variables['up_flag']
# vel_var[dim, :] = vel
# rng_var[:] = rng
# elev_var[dim] = elev
# az_var[dim] = az
# intensity_var[dim, :] = intensity
else:
# Create the netcdf
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
# Create the height dimension
nc.createDimension('height', len(rng))
nc.createDimension('t', None)
# Create the variables
vel_var = nc.createVariable('velocity', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
rng_var = nc.createVariable('range', 'f8', ('height'), fill_value=FILL_VALUE)
elev_var = nc.createVariable('elevation', 'f8', ('t'), fill_value=FILL_VALUE)
az_var = nc.createVariable('azimuth', 'f8', ('t'), fill_value=FILL_VALUE)
intensity_var = nc.createVariable('intensity', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
up_flag_var = nc.createVariable('up_flag', 'f8', ('t'))
time_var = nc.createVariable('time', 'i8', ('t'))
time_var.setncattr('units', 'seconds since 1970-01-01 00:00:00 UTC')
dim = nc.dimensions['t'].size
dim2 = dim+len(date)
vel_var[dim:dim2, :] = vel
rng_var[:] = np.where(np.isnan(rng), FILL_VALUE, rng)
elev_var[dim:dim2] = np.where(np.isnan(elev), FILL_VALUE, elev)
az_var[dim:dim2] = np.where(np.isnan(az), FILL_VALUE, az)
intensity_var[dim:dim2, :] = np.where(np.isnan(intensity), FILL_VALUE, intensity)
time_var[dim:dim2] = [(d - datetime(1970, 1, 1)).total_seconds() for d in date]
#print [up_flag for i in range(len(date))]
up_flag_var[dim:dim2] = [float(up_flag) for i in range(len(date))]
# Close the netcdf
nc.close()
#########PROCESS CODE####################
#######deployment logging
# reads config file in TORUS_DL/logs/config.js
# writesout changes/events to deployment log in TORUS_DL/logs/log_MMDDYY.txt
# grab current timestamp for run
now = datetime.utcnow()
#now=datetime(2019,05,17,23,58)
log_time = now.strftime("%m%d%y_%H%M")
today = now.strftime("%Y%m%d") # - commented out for test date below.
# today_l = datetime(2019,05,07)
# today=today_l.strftime("%Y%m%d")
# now = datetime(year=2019, month=5, day=7, hour=16, minute=15)
# open and read in config file info
config = open('/Users/elizabethsmith/TORUS_DL/logs/config.js')
logdata = json.load(config)
config.close()
if logdata["status"]=='up':
print "we're up :)"
up_flag=1
if logdata["status"]=='down':
print "we're down :( "
up_flag=0
# TB - Running into an error here when starting a new log file.
# Added some automation to make your like easier
if os.path.exists('/Users/elizabethsmith/TORUS_DL/logs/' + logdata["logfile"]):
# open and read most recent logfile entry
current_logfile = open('/Users/elizabethsmith/TORUS_DL/logs/' + logdata["logfile"], "r+")
lines = current_logfile.readlines()
prev_status = lines[-6][8:-1] # reading logfile previous status (skipping text)
prev_heading = lines[-5][9:-1] # reading logfile previous heading (skipping text)
prev_lat = lines[-4][5:-1] # reading logfile previous lat (skipping text)
prev_lon = lines[-3][5:-1] # reading logfile previous lat (skipping text)
prev_note = lines[-2][6:-1] # reading logfile previous note (skipping text)
# check if the previous log entry matches the data in the config file..
print logdata["note"], prev_note
if (str(logdata["status"]) != prev_status or str(logdata["heading"]) != prev_heading or
str(logdata["lat"]) != prev_lat or str(logdata["lon"]) != prev_lon or
str(logdata["note"]) != prev_note):
print '**CONFIG FILE HAS BEEN UPDATED!** generating log entry...'
# generate writeout for new log entry based on config file.
writeout = ["*********ENTRY**************\n",
"timestamp: %s\n" % log_time,
"status: %s\n" % logdata["status"],
"heading: %s\n" % logdata["heading"],
"lat: %s\n" % logdata["lat"],
"lon: %s\n" % logdata["lon"],
"note: %s\n" % logdata["note"],
"*********END***************\n"]
current_logfile.writelines(writeout)
print "**Logfile updated -- see /Users/elizabethsmith/TORUS_DL/logs/%s" % logdata["logfile"]
else:
print "--no config changes"
current_logfile.close()
else:
current_logfile = open('/Users/elizabethsmith/TORUS_DL/logs/' + logdata["logfile"], "w")
writeout = ["*********ENTRY**************\n",
"timestamp: %s\n" % log_time,
"status: %s\n" % logdata["status"],
"heading: %s\n" % logdata["heading"],
"lat: %s\n" % logdata["lat"],
"lon: %s\n" % logdata["lon"],
"note: %s\n" % logdata["note"],
"*********END***************\n"]
current_logfile.writelines(writeout)
print "**Logfile updated -- see /Users/elizabethsmith/TORUS_DL/logs/%s" % logdata["logfile"]
# get list of exisiting processed scans
path_proc = '/Users/elizabethsmith/TORUS_DL/data/nonQA_proc/dl/2019/201905/' + today + '/'
# check to make sure the output dir exists
try:
os.makedirs(path_proc)
except OSError:
logging.debug("Output path already exists...")
# Check to make sure the processed_files.txt exists
if not os.path.exists(path_proc + 'processed_files.txt'):
os.system('touch {}'.format(path_proc + 'processed_files.txt'))
# Open the processed files list and read it in
proc_list = open(path_proc + 'processed_files.txt', "r+")
proc_files = proc_list.readlines()
proc_list.close()
# Be sure to add the files that are processed to the running list
# get list of existing raw scans - always do the stare
# TB - I changed some things here so only the scans from the current hour are even looked at.
# - This cuts down on processing for the stare files!
path_raw = now.strftime('/Users/elizabethsmith/TORUS_DL/data/raw/dl/%Y/%Y%m/%Y%m%d/*%Y%m%d_*.hpl')
#print path_raw
raw_files = [f for f in glob(path_raw)]
#print raw_files
raw_files=sorted(raw_files)
# Process the scans
for in_file in raw_files:
# TB - I changed your logic for finding the files to process. This is a little easier and less prone to bugs
# Check to see if the file is in the alreasy processed files. If it is, skip it.
if in_file+'\n' in proc_files:
logging.debug("{} already processed".format(in_file))
continue
else:
logging.info("Processing {}".format(in_file))
# read in new scan
out_dir = path_proc
prefix = 'nonQA'
# Read in the text file
lines = []
with open(in_file) as f:
for line in f:
| lines.append(line) | conditional_block |
|
process_test.py | scans - always do the stare
# TB - I changed some things here so only the scans from the current hour are even looked at.
# - This cuts down on processing for the stare files!
path_raw = now.strftime('/Users/elizabethsmith/TORUS_DL/data/raw/dl/%Y/%Y%m/%Y%m%d/*%Y%m%d_*.hpl')
#print path_raw
raw_files = [f for f in glob(path_raw)]
#print raw_files
raw_files=sorted(raw_files)
# Process the scans
for in_file in raw_files:
# TB - I changed your logic for finding the files to process. This is a little easier and less prone to bugs
# Check to see if the file is in the alreasy processed files. If it is, skip it.
if in_file+'\n' in proc_files:
logging.debug("{} already processed".format(in_file))
continue
else:
logging.info("Processing {}".format(in_file))
# read in new scan
out_dir = path_proc
prefix = 'nonQA'
# Read in the text file
lines = []
with open(in_file) as f:
for line in f:
lines.append(line)
logging.debug("Decoding header")
# Read in the header info
header = decode_header(lines[0:11])
ngates = int(header['Number of gates'])
# nrays = int(header['No. of rays in file']) # Cant do this apparently. Not always correct (wtf)
len_data = len(lines[17:])
nrays = len_data / (ngates + 1)
gate_length = float(header['Range gate length (m)'])
start_time = datetime.strptime(header['Start time'], '%Y%m%d %H:%M:%S.%f')
scan_type = None
logging.debug("Reading data")
# Read in the actual data
az = np.zeros(nrays)
hour = np.zeros(nrays)
elev = np.zeros(nrays)
pitch = np.zeros(nrays)
roll = np.zeros(nrays)
rng = np.asarray([(gate + .5) * gate_length for gate in range(ngates)])
vel = np.zeros((ngates, nrays))
intensity = np.zeros((ngates, nrays))
beta = np.zeros((ngates, nrays))
try:
for ray in range(nrays):
# Get the scan info
info = lines[ray * (ngates + 1) + 17].split()
hour[ray] = float(info[0])
az[ray] = float(info[1])
elev[ray] = float(info[2])
pitch[ray] = float(info[3])
roll[ray] = float(info[4])
for gate in range(ngates):
data = lines[ray * (ngates + 1) + 17 + gate + 1].split()
vel[gate, ray] = float(data[1])
intensity[gate, ray] = float(data[2])
beta[gate, ray] = float(data[3])
except IndexError:
logging.warning("Something went wrong with the indexing here...")
# correction for some rounding/hysteresis in scanner azimuths... setting all vals==360. to 0.
az[np.where(az == 360.)] = 0.
# dynamic identification of lidar scan type (fp,ppi,rhi)
# TB - I Added the round here. Was getting a fp file ID'd as a rhi file
# - Also had an issue with and RHI file where az[0] was 0.01 and az[2] was 0
try:
if np.round(az[0], 1) == np.round(az[2], 1): # const azimuth could be RHI or stare
if np.round(elev[0], 1) == np.round(elev[2], 1): # const azimuth and constant elev = stare
scan_type = 'fp'
else: # const azimuth and non-constant elev = RHI
scan_type = 'rhi'
elif np.round(elev[0], 1) == np.round(elev[2]): # changing azimuth, const elev = PPI
scan_type = 'ppi'
if scan_type == None:
raise IndexError
logging.info("Scan Type: " + scan_type)
except IndexError:
logging.warning("Something went wrong with scan type IDing...")
if scan_type == 'ppi':
date = datetime.strptime(start_time.strftime('%Y-%m-%dT%H:%M:%S'), "%Y-%m-%dT%H:%M:%S")
hgt = []
u = []
v = []
w = []
rmse = []
r_sq = []
for i, rng in enumerate(rng):
# Get the required stuff for this range ring
cnr = intensity[i, :] # range,azimuth
Vel = vel[i, :] # range,azimuth
Az = az # 8-terms of az
Elev = elev # 8-terms of az
# Filter out the bad values based on CNR - default was 1.015
Az = np.where(cnr <= 1.01, FILL_VALUE, Az)
Vel = np.where(cnr <= 1.01, FILL_VALUE, Vel)
Az = list_to_masked_array(Az, FILL_VALUE)
Vel = list_to_masked_array(Vel, FILL_VALUE)
# Calculate the vad and height for this range ring
tmp_u, tmp_v, tmp_w = calc_vad_3d(Az, Elev, Vel) # grab this to it can point to it!!!
# Calculate the RMSE
N = float(Vel.size)
az_rad = np.deg2rad(Az)
elev_rad = np.deg2rad(Elev)
derived_vr = (np.sin(az_rad) * np.cos(elev_rad) * tmp_u) + \
(np.cos(az_rad) * np.cos(elev_rad) * tmp_v) + \
(np.sin(elev_rad) * tmp_w)
tmp_E = Vel - derived_vr
# Calculate rms error
tmp_RMSE = np.sqrt(1 / N * np.sum(tmp_E ** 2))
tmp_r_sq = calc_homogeneity(Vel, derived_vr)
# Append to the lists for plotting
u.append(tmp_u)
v.append(tmp_v)
w.append(tmp_w)
hgt.append(ray_height(rng, Elev[0]))
rmse.append(tmp_RMSE)
r_sq.append(tmp_r_sq)
vector_wind = rotate(u, v, w, logdata["heading"], 0, 0)
vector_wind = vector_wind.squeeze()
u = vector_wind[:, 0]
v = vector_wind[:, 1]
w = vector_wind[:, 2]
ws = wind_uv_to_spd(u, v)
wd = wind_uv_to_dir(u, v)
writeVAD_to_nc(path_proc + prefix + date.strftime('%Y%m%d') + '_VAD.nc', date, elev, u, v, w, ws, wd, hgt,
rmse, r_sq,up_flag)
# add newly processed file to list of processed files
proc_list = open(path_proc + 'processed_files.txt', "a")
proc_list.writelines(in_file+'\n')
proc_list.close()
if scan_type == 'fp':
# TB - I decided that it is best to just process the entire stare file every time
# instead of try to append to the netcdf. This shouldn't hinder processeing time that much
# since I changed things to only grab things from the same hour you're processing
date = datetime.strptime(start_time.strftime('%Y-%m-%dT%H:%M:%S'), "%Y-%m-%dT%H:%M:%S")
times = np.asarray([datetime(year=date.year, month=date.month, day=date.day) + timedelta(hours=h) for h in hour])
# Filter out the bad values based on CNR
Vel = np.where(intensity <= 1.01, FILL_VALUE, vel)
# Get the rng into a 2d array
rng = np.array([rng for i in range(len(rng))])
logging.debug("Writing stare file")
writeSTARE_to_nc(path_proc+prefix+date.strftime('%Y%m%d_%H_STARE.nc'), times, vel.transpose(), rng, up_flag)
if scan_type=='rhi':
# TB - A quick tip: Don't do an RHI at az=0. It bounces between 0 and 360 and is a pain in the ass to process
# - Just do it at like 1 deg. or even .1
# TB - Note to self - need to do a heading correction on this one.
date = start_time
times = np.asarray([datetime(year=date.year, month=date.month, day=date.day) + timedelta(hours=h) for h in hour])
filename = path_proc + prefix + date.strftime('%Y%m%d_%H') + '_RHI.nc'
# break | writeRHI_to_nc(filename, times, vel.transpose(), rng, elev, az, intensity.transpose(), up_flag) | random_line_split |
|
process_test.py | az) * np.sin(az) * np.cos(elev))
G = sum(np.sin(az) * np.sin(elev))
D = sum(vel * np.cos(az))
E = sum(np.sin(az) * np.cos(az) * np.cos(elev))
F = sum(np.cos(az) ** 2 * np.cos(elev))
H = sum(np.cos(az) * np.sin(elev))
W = sum(vel)
X = sum(np.sin(az) * np.cos(elev))
Y = sum(np.cos(az) * np.cos(elev))
Z = sum(az * np.sin(elev))
# solve A = uB + vC + wG , D = uE + vF + wH and W = uX + vY+ wZ
y = np.array([[B, E, X], [C, F, Y], [G, H, Z]])
z = np.array([A, D, W])
# print y
# print z
try:
sol = np.linalg.solve(y, z)
# print sol
u = sol[0]
v = sol[1]
w = sol[2]
return u, v, w
except np.linalg.linalg.LinAlgError:
return FILL_VALUE, FILL_VALUE, FILL_VALUE
else:
return FILL_VALUE, FILL_VALUE, FILL_VALUE
def | (header):
"""
Takes in a list of lines from the raw hpl file. Separates them by
tab and removes unnecessary text
"""
new_header = {}
for item in header:
split = item.split('\t')
new_header[split[0].replace(':', '')] = split[1].replace("\r\n", "")
return new_header
def _to_epoch(dt):
return (dt - datetime(1970, 1, 1)).total_seconds()
"""
process_file(in_file, out_dir, prefix):
Processes a raw halo hpl file and turns it into a netcdf
:param in_file:
:param out_dir:
:return:
"""
def writeVAD_to_nc(filename, date, elev, u, v, w, ws, wd, hgt, rmse, r_sq,up_flag,intensity):
if os.path.exists(filename):
# open the netcdf
nc = netCDF4.Dataset(filename, 'a', format="NETCDF4")
dim = nc.dimensions['t'].size
u_var = nc.variables['u']
v_var = nc.variables['v']
w_var = nc.variables['w']
ws_var = nc.variables['ws']
wd_var = nc.variables['wd']
rms_var = nc.variables['rms']
r_sq_var = nc.variables['r_sq']
time_var = nc.variables['time']
hgt_var = nc.variables['hgt']
up_flag_var = nc.variables['up_flag']
u_var[dim, :] = u
v_var[dim, :] = v
w_var[dim, :] = w
ws_var[dim, :] = ws
wd_var[dim, :] = wd
rms_var[dim, :] = rmse
r_sq_var[dim, :] = r_sq
up_flag_var[dim] = up_flag
else:
# Create the netcdf
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
# Create the height dimension
nc.createDimension('height', len(hgt))
nc.createDimension('t', None)
# Add the attributes
nc.setncattr("elev", elev)
nc.setncattr("date", date.isoformat())
# Create the variables
u_var = nc.createVariable('u', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
v_var = nc.createVariable('v', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
w_var = nc.createVariable('w', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
ws_var = nc.createVariable('ws', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
wd_var = nc.createVariable('wd', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
hgt_var = nc.createVariable('hgt', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
rms_var = nc.createVariable('rms', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
r_sq_var = nc.createVariable('r_sq', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
up_flag_var = nc.createVariable('up_flag', 'f8', ('t'))
intensity_var = nc.createVariable('intensity', 'f8', ('t','hgt'))
time_var = nc.createVariable('time', 'i8', ('t'))
time_var.setncattr('units', 'seconds since 1970-01-01 00:00:00 UTC')
dim = nc.dimensions['t'].size
u_var[dim, :] = np.where(np.isnan(u), FILL_VALUE, u)
v_var[dim, :] = np.where(np.isnan(v), FILL_VALUE, v)
w_var[dim, :] = np.where(np.isnan(w), FILL_VALUE, w)
ws_var[dim, :] = np.where(np.isnan(ws), FILL_VALUE, ws)
wd_var[dim, :] = np.where(np.isnan(wd), FILL_VALUE, wd)
hgt_var[dim, :] = np.where(np.isnan(hgt), FILL_VALUE, hgt)
rms_var[dim, :] = np.where(np.isnan(rmse), FILL_VALUE, rmse)
r_sq_var[dim, :] = np.where(np.isnan(r_sq), FILL_VALUE, r_sq)
time_var[dim] = (date - datetime(1970, 1, 1)).total_seconds()
up_flag_var[dim]=up_flag
intensity_var[dim] = intensity
# Close the netcdf
nc.close()
def writeSTARE_to_nc(filename, date, w, hgt, intensity):
logging.debug(filename)
logging.debug(date)
# Create the netcdf
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
# Create the height dimension
nc.createDimension('hgt', len(hgt))
nc.createDimension('t', None)
# Add the attributes
nc.setncattr("date", date[0].isoformat())
# Create the variables
w_var = nc.createVariable('w', 'f8', ('t', 'hgt'), fill_value=FILL_VALUE)
hgt_var = nc.createVariable('hgt', 'f8', ('t', 'hgt'), fill_value=FILL_VALUE)
intensity_var = nc.createVariable('intensity', 'f8', ('t','hgt'))
time_var = nc.createVariable('time', 'i8', ('t'))
time_var.setncattr('units', 'seconds since 1970-01-01 00:00:00 UTC')
hgt_var[:] = hgt
time_var[:] = [(d - datetime(1970, 1, 1)).total_seconds() for d in date]
w_var[:, :] = w
intensity_var[:] = intensity
# Close the netcdf
nc.close()
def writeRHI_to_nc(filename, date, vel, rng, elev, az, intensity,up_flag):
if os.path.exists(filename):
# open the netcdf
nc = netCDF4.Dataset(filename, 'r+', format="NETCDF4")
dim = nc.dimensions['t'].size
vel_var = nc.variables['velocity']
rng_var = nc.variables['range']
elev_var = nc.variables['elevation']
az_var = nc.variables['azimuth']
intensity_var = nc.variables['intensity']
time_var = nc.variables['time']
up_flag_var = nc.variables['up_flag']
# vel_var[dim, :] = vel
# rng_var[:] = rng
# elev_var[dim] = elev
# az_var[dim] = az
# intensity_var[dim, :] = intensity
else:
# Create the netcdf
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
# Create the height dimension
nc.createDimension('height', len(rng))
nc.createDimension('t', None)
# Create the variables
vel_var = nc.createVariable('velocity', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
rng_var = nc.createVariable('range', 'f8', ('height'), fill_value=FILL_VALUE)
elev_var = nc.createVariable('elevation', 'f8', ('t'), fill_value=FILL_VALUE)
az_var = nc.createVariable('azimuth', 'f8', ('t'), fill_value=FILL_VALUE)
intensity_var = nc.createVariable('intensity', 'f8', ('t', 'height'), fill_value=FILL_VALUE)
up_flag_var = nc.createVariable('up_flag', 'f8', ('t'))
time_var = nc.createVariable('time', 'i8', ('t'))
time_var.setncattr('units', 'seconds since 1970-0 | decode_header | identifier_name |
sender.go | Logic
type metricPair struct {
attributes pcommon.Map
metric pmetric.Metric
}
type sender struct {
logBuffer []plog.LogRecord
metricBuffer []metricPair
config *Config
client *http.Client
filter filter
sources sourceFormats
compressor compressor
prometheusFormatter prometheusFormatter
graphiteFormatter graphiteFormatter
}
const (
logKey string = "log"
// maxBufferSize defines size of the logBuffer (maximum number of plog.LogRecord entries)
maxBufferSize int = 1024 * 1024
headerContentType string = "Content-Type"
headerContentEncoding string = "Content-Encoding"
headerClient string = "X-Sumo-Client"
headerHost string = "X-Sumo-Host"
headerName string = "X-Sumo-Name"
headerCategory string = "X-Sumo-Category"
headerFields string = "X-Sumo-Fields"
contentTypeLogs string = "application/x-www-form-urlencoded"
contentTypePrometheus string = "application/vnd.sumologic.prometheus"
contentTypeCarbon2 string = "application/vnd.sumologic.carbon2"
contentTypeGraphite string = "application/vnd.sumologic.graphite"
contentEncodingGzip string = "gzip"
contentEncodingDeflate string = "deflate"
)
func newAppendResponse() appendResponse {
return appendResponse{
appended: true,
}
}
func newSender(
cfg *Config,
cl *http.Client,
f filter,
s sourceFormats,
c compressor,
pf prometheusFormatter,
gf graphiteFormatter,
) *sender {
return &sender{
config: cfg,
client: cl,
filter: f,
sources: s,
compressor: c,
prometheusFormatter: pf,
graphiteFormatter: gf,
}
}
// send sends data to sumologic
func (s *sender) send(ctx context.Context, pipeline PipelineType, body io.Reader, flds fields) error {
data, err := s.compressor.compress(body)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.config.HTTPClientSettings.Endpoint, data)
if err != nil |
// Add headers
switch s.config.CompressEncoding {
case GZIPCompression:
req.Header.Set(headerContentEncoding, contentEncodingGzip)
case DeflateCompression:
req.Header.Set(headerContentEncoding, contentEncodingDeflate)
case NoCompression:
default:
return fmt.Errorf("invalid content encoding: %s", s.config.CompressEncoding)
}
req.Header.Add(headerClient, s.config.Client)
if s.sources.host.isSet() {
req.Header.Add(headerHost, s.sources.host.format(flds))
}
if s.sources.name.isSet() {
req.Header.Add(headerName, s.sources.name.format(flds))
}
if s.sources.category.isSet() {
req.Header.Add(headerCategory, s.sources.category.format(flds))
}
switch pipeline {
case LogsPipeline:
req.Header.Add(headerContentType, contentTypeLogs)
req.Header.Add(headerFields, flds.string())
case MetricsPipeline:
switch s.config.MetricFormat {
case PrometheusFormat:
req.Header.Add(headerContentType, contentTypePrometheus)
case Carbon2Format:
req.Header.Add(headerContentType, contentTypeCarbon2)
case GraphiteFormat:
req.Header.Add(headerContentType, contentTypeGraphite)
default:
return fmt.Errorf("unsupported metrics format: %s", s.config.MetricFormat)
}
default:
return errors.New("unexpected pipeline")
}
resp, err := s.client.Do(req)
if err != nil {
return err
}
if resp.StatusCode < 200 || resp.StatusCode >= 400 {
return fmt.Errorf("error during sending data: %s", resp.Status)
}
return nil
}
// logToText converts LogRecord to a plain text line, returns it and error eventually
func (s *sender) logToText(record plog.LogRecord) string {
return record.Body().AsString()
}
// logToJSON converts LogRecord to a json line, returns it and error eventually
func (s *sender) logToJSON(record plog.LogRecord) (string, error) {
data := s.filter.filterOut(record.Attributes())
record.Body().CopyTo(data.orig.PutEmpty(logKey))
nextLine, err := json.Marshal(data.orig.AsRaw())
if err != nil {
return "", err
}
return bytes.NewBuffer(nextLine).String(), nil
}
// sendLogs sends log records from the logBuffer formatted according
// to configured LogFormat and as the result of execution
// returns array of records which has not been sent correctly and error
func (s *sender) sendLogs(ctx context.Context, flds fields) ([]plog.LogRecord, error) {
var (
body strings.Builder
errs error
droppedRecords []plog.LogRecord
currentRecords []plog.LogRecord
)
for _, record := range s.logBuffer {
var formattedLine string
var err error
switch s.config.LogFormat {
case TextFormat:
formattedLine = s.logToText(record)
case JSONFormat:
formattedLine, err = s.logToJSON(record)
default:
err = errors.New("unexpected log format")
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, LogsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, LogsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
}
return droppedRecords, errs
}
// sendMetrics sends metrics in right format basing on the s.config.MetricFormat
func (s *sender) sendMetrics(ctx context.Context, flds fields) ([]metricPair, error) {
var (
body strings.Builder
errs error
droppedRecords []metricPair
currentRecords []metricPair
)
for _, record := range s.metricBuffer {
var formattedLine string
var err error
switch s.config.MetricFormat {
case PrometheusFormat:
formattedLine = s.prometheusFormatter.metric2String(record)
case Carbon2Format:
formattedLine = carbon2Metric2String(record)
case GraphiteFormat:
formattedLine = s.graphiteFormatter.metric2String(record)
default:
err = fmt.Errorf("unexpected metric format: %s", s.config.MetricFormat)
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, MetricsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, MetricsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
}
return droppedRecords, errs
}
// appendAndSend appends line to the request body that will be sent and sends
// the accumulated data if the internal logBuffer has been filled (with maxBufferSize elements).
// It returns appendResponse
func (s *sender) appendAndSend(
ctx context.Context,
line string,
pipeline PipelineType,
body *strings.Builder,
flds fields,
) (appendResponse, error) {
var errs error
ar := newAppendResponse()
if body.Len() > 0 && body.Len()+len(line) >= s.config.MaxRequestBodySize {
ar.sent = true
errs = multierr.Append(errs, s.send(ctx, pipeline, strings.NewReader(body.String()), flds))
body.Reset()
}
if body.Len() > 0 {
// Do not add newline if the body is empty
if _, err := body.WriteString("\n"); err != nil {
errs = multierr.Append(errs, err)
ar.appended = false
| {
return err
} | conditional_block |
sender.go | Logic
type metricPair struct {
attributes pcommon.Map
metric pmetric.Metric
}
type sender struct {
logBuffer []plog.LogRecord
metricBuffer []metricPair
config *Config
client *http.Client
filter filter
sources sourceFormats
compressor compressor
prometheusFormatter prometheusFormatter
graphiteFormatter graphiteFormatter
}
const (
logKey string = "log"
// maxBufferSize defines size of the logBuffer (maximum number of plog.LogRecord entries)
maxBufferSize int = 1024 * 1024
headerContentType string = "Content-Type"
headerContentEncoding string = "Content-Encoding"
headerClient string = "X-Sumo-Client"
headerHost string = "X-Sumo-Host"
headerName string = "X-Sumo-Name"
headerCategory string = "X-Sumo-Category"
headerFields string = "X-Sumo-Fields"
contentTypeLogs string = "application/x-www-form-urlencoded"
contentTypePrometheus string = "application/vnd.sumologic.prometheus"
contentTypeCarbon2 string = "application/vnd.sumologic.carbon2"
contentTypeGraphite string = "application/vnd.sumologic.graphite"
contentEncodingGzip string = "gzip"
contentEncodingDeflate string = "deflate"
)
func newAppendResponse() appendResponse {
return appendResponse{
appended: true,
}
}
func newSender(
cfg *Config,
cl *http.Client,
f filter,
s sourceFormats,
c compressor,
pf prometheusFormatter,
gf graphiteFormatter,
) *sender {
return &sender{
config: cfg,
client: cl,
filter: f,
sources: s,
compressor: c,
prometheusFormatter: pf,
graphiteFormatter: gf,
}
}
// send sends data to sumologic
func (s *sender) send(ctx context.Context, pipeline PipelineType, body io.Reader, flds fields) error {
data, err := s.compressor.compress(body)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.config.HTTPClientSettings.Endpoint, data)
if err != nil {
return err
}
// Add headers
switch s.config.CompressEncoding {
case GZIPCompression:
req.Header.Set(headerContentEncoding, contentEncodingGzip)
case DeflateCompression:
req.Header.Set(headerContentEncoding, contentEncodingDeflate)
case NoCompression:
default:
return fmt.Errorf("invalid content encoding: %s", s.config.CompressEncoding)
}
req.Header.Add(headerClient, s.config.Client)
if s.sources.host.isSet() {
req.Header.Add(headerHost, s.sources.host.format(flds))
}
if s.sources.name.isSet() {
req.Header.Add(headerName, s.sources.name.format(flds))
}
if s.sources.category.isSet() {
req.Header.Add(headerCategory, s.sources.category.format(flds))
}
switch pipeline {
case LogsPipeline:
req.Header.Add(headerContentType, contentTypeLogs)
req.Header.Add(headerFields, flds.string())
case MetricsPipeline:
switch s.config.MetricFormat {
case PrometheusFormat:
req.Header.Add(headerContentType, contentTypePrometheus)
case Carbon2Format:
req.Header.Add(headerContentType, contentTypeCarbon2)
case GraphiteFormat:
req.Header.Add(headerContentType, contentTypeGraphite)
default:
return fmt.Errorf("unsupported metrics format: %s", s.config.MetricFormat)
}
default:
return errors.New("unexpected pipeline")
}
resp, err := s.client.Do(req)
if err != nil {
return err
}
if resp.StatusCode < 200 || resp.StatusCode >= 400 {
return fmt.Errorf("error during sending data: %s", resp.Status)
}
return nil
}
// logToText converts LogRecord to a plain text line, returns it and error eventually
func (s *sender) | (record plog.LogRecord) string {
return record.Body().AsString()
}
// logToJSON converts LogRecord to a json line, returns it and error eventually
func (s *sender) logToJSON(record plog.LogRecord) (string, error) {
data := s.filter.filterOut(record.Attributes())
record.Body().CopyTo(data.orig.PutEmpty(logKey))
nextLine, err := json.Marshal(data.orig.AsRaw())
if err != nil {
return "", err
}
return bytes.NewBuffer(nextLine).String(), nil
}
// sendLogs sends log records from the logBuffer formatted according
// to configured LogFormat and as the result of execution
// returns array of records which has not been sent correctly and error
func (s *sender) sendLogs(ctx context.Context, flds fields) ([]plog.LogRecord, error) {
var (
body strings.Builder
errs error
droppedRecords []plog.LogRecord
currentRecords []plog.LogRecord
)
for _, record := range s.logBuffer {
var formattedLine string
var err error
switch s.config.LogFormat {
case TextFormat:
formattedLine = s.logToText(record)
case JSONFormat:
formattedLine, err = s.logToJSON(record)
default:
err = errors.New("unexpected log format")
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, LogsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, LogsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
}
return droppedRecords, errs
}
// sendMetrics sends metrics in right format basing on the s.config.MetricFormat
func (s *sender) sendMetrics(ctx context.Context, flds fields) ([]metricPair, error) {
var (
body strings.Builder
errs error
droppedRecords []metricPair
currentRecords []metricPair
)
for _, record := range s.metricBuffer {
var formattedLine string
var err error
switch s.config.MetricFormat {
case PrometheusFormat:
formattedLine = s.prometheusFormatter.metric2String(record)
case Carbon2Format:
formattedLine = carbon2Metric2String(record)
case GraphiteFormat:
formattedLine = s.graphiteFormatter.metric2String(record)
default:
err = fmt.Errorf("unexpected metric format: %s", s.config.MetricFormat)
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, MetricsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, MetricsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
}
return droppedRecords, errs
}
// appendAndSend appends line to the request body that will be sent and sends
// the accumulated data if the internal logBuffer has been filled (with maxBufferSize elements).
// It returns appendResponse
func (s *sender) appendAndSend(
ctx context.Context,
line string,
pipeline PipelineType,
body *strings.Builder,
flds fields,
) (appendResponse, error) {
var errs error
ar := newAppendResponse()
if body.Len() > 0 && body.Len()+len(line) >= s.config.MaxRequestBodySize {
ar.sent = true
errs = multierr.Append(errs, s.send(ctx, pipeline, strings.NewReader(body.String()), flds))
body.Reset()
}
if body.Len() > 0 {
// Do not add newline if the body is empty
if _, err := body.WriteString("\n"); err != nil {
errs = multierr.Append(errs, err)
ar.appended = false
| logToText | identifier_name |
sender.go | o Logic
type metricPair struct {
attributes pcommon.Map
metric pmetric.Metric
}
type sender struct {
logBuffer []plog.LogRecord
metricBuffer []metricPair
config *Config
client *http.Client
filter filter
sources sourceFormats
compressor compressor
prometheusFormatter prometheusFormatter
graphiteFormatter graphiteFormatter
}
const (
logKey string = "log"
// maxBufferSize defines size of the logBuffer (maximum number of plog.LogRecord entries)
maxBufferSize int = 1024 * 1024
headerContentType string = "Content-Type"
headerContentEncoding string = "Content-Encoding"
headerClient string = "X-Sumo-Client"
headerHost string = "X-Sumo-Host"
headerName string = "X-Sumo-Name"
headerCategory string = "X-Sumo-Category"
headerFields string = "X-Sumo-Fields"
contentTypeLogs string = "application/x-www-form-urlencoded"
contentTypePrometheus string = "application/vnd.sumologic.prometheus"
contentTypeCarbon2 string = "application/vnd.sumologic.carbon2"
contentTypeGraphite string = "application/vnd.sumologic.graphite"
contentEncodingGzip string = "gzip"
contentEncodingDeflate string = "deflate"
)
func newAppendResponse() appendResponse {
return appendResponse{
appended: true,
}
}
func newSender(
cfg *Config,
cl *http.Client,
f filter,
s sourceFormats,
c compressor,
pf prometheusFormatter,
gf graphiteFormatter,
) *sender {
return &sender{
config: cfg,
client: cl,
filter: f,
sources: s,
compressor: c,
prometheusFormatter: pf,
graphiteFormatter: gf,
}
}
// send sends data to sumologic
func (s *sender) send(ctx context.Context, pipeline PipelineType, body io.Reader, flds fields) error {
data, err := s.compressor.compress(body)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.config.HTTPClientSettings.Endpoint, data)
if err != nil {
return err
}
// Add headers
switch s.config.CompressEncoding {
case GZIPCompression:
req.Header.Set(headerContentEncoding, contentEncodingGzip)
case DeflateCompression:
req.Header.Set(headerContentEncoding, contentEncodingDeflate)
case NoCompression:
default:
return fmt.Errorf("invalid content encoding: %s", s.config.CompressEncoding)
}
req.Header.Add(headerClient, s.config.Client)
if s.sources.host.isSet() {
req.Header.Add(headerHost, s.sources.host.format(flds))
}
if s.sources.name.isSet() {
req.Header.Add(headerName, s.sources.name.format(flds))
}
if s.sources.category.isSet() {
req.Header.Add(headerCategory, s.sources.category.format(flds))
}
switch pipeline {
case LogsPipeline:
req.Header.Add(headerContentType, contentTypeLogs)
req.Header.Add(headerFields, flds.string())
case MetricsPipeline:
switch s.config.MetricFormat {
case PrometheusFormat:
req.Header.Add(headerContentType, contentTypePrometheus)
case Carbon2Format:
req.Header.Add(headerContentType, contentTypeCarbon2)
case GraphiteFormat:
req.Header.Add(headerContentType, contentTypeGraphite)
default:
return fmt.Errorf("unsupported metrics format: %s", s.config.MetricFormat)
}
default:
return errors.New("unexpected pipeline")
}
resp, err := s.client.Do(req)
if err != nil {
return err
}
if resp.StatusCode < 200 || resp.StatusCode >= 400 {
return fmt.Errorf("error during sending data: %s", resp.Status)
}
return nil
}
// logToText converts LogRecord to a plain text line, returns it and error eventually
func (s *sender) logToText(record plog.LogRecord) string {
return record.Body().AsString()
}
// logToJSON converts LogRecord to a json line, returns it and error eventually
func (s *sender) logToJSON(record plog.LogRecord) (string, error) {
data := s.filter.filterOut(record.Attributes())
record.Body().CopyTo(data.orig.PutEmpty(logKey))
nextLine, err := json.Marshal(data.orig.AsRaw())
if err != nil {
return "", err
}
return bytes.NewBuffer(nextLine).String(), nil
}
// sendLogs sends log records from the logBuffer formatted according
// to configured LogFormat and as the result of execution
// returns array of records which has not been sent correctly and error
func (s *sender) sendLogs(ctx context.Context, flds fields) ([]plog.LogRecord, error) {
var (
body strings.Builder
errs error
droppedRecords []plog.LogRecord
currentRecords []plog.LogRecord
)
for _, record := range s.logBuffer {
var formattedLine string
var err error
switch s.config.LogFormat {
case TextFormat:
formattedLine = s.logToText(record)
case JSONFormat:
formattedLine, err = s.logToJSON(record)
default:
err = errors.New("unexpected log format")
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, LogsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, LogsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
} | func (s *sender) sendMetrics(ctx context.Context, flds fields) ([]metricPair, error) {
var (
body strings.Builder
errs error
droppedRecords []metricPair
currentRecords []metricPair
)
for _, record := range s.metricBuffer {
var formattedLine string
var err error
switch s.config.MetricFormat {
case PrometheusFormat:
formattedLine = s.prometheusFormatter.metric2String(record)
case Carbon2Format:
formattedLine = carbon2Metric2String(record)
case GraphiteFormat:
formattedLine = s.graphiteFormatter.metric2String(record)
default:
err = fmt.Errorf("unexpected metric format: %s", s.config.MetricFormat)
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, MetricsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, MetricsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
}
return droppedRecords, errs
}
// appendAndSend appends line to the request body that will be sent and sends
// the accumulated data if the internal logBuffer has been filled (with maxBufferSize elements).
// It returns appendResponse
func (s *sender) appendAndSend(
ctx context.Context,
line string,
pipeline PipelineType,
body *strings.Builder,
flds fields,
) (appendResponse, error) {
var errs error
ar := newAppendResponse()
if body.Len() > 0 && body.Len()+len(line) >= s.config.MaxRequestBodySize {
ar.sent = true
errs = multierr.Append(errs, s.send(ctx, pipeline, strings.NewReader(body.String()), flds))
body.Reset()
}
if body.Len() > 0 {
// Do not add newline if the body is empty
if _, err := body.WriteString("\n"); err != nil {
errs = multierr.Append(errs, err)
ar.appended = false
|
return droppedRecords, errs
}
// sendMetrics sends metrics in right format basing on the s.config.MetricFormat | random_line_split |
sender.go | BufferSize defines size of the logBuffer (maximum number of plog.LogRecord entries)
maxBufferSize int = 1024 * 1024
headerContentType string = "Content-Type"
headerContentEncoding string = "Content-Encoding"
headerClient string = "X-Sumo-Client"
headerHost string = "X-Sumo-Host"
headerName string = "X-Sumo-Name"
headerCategory string = "X-Sumo-Category"
headerFields string = "X-Sumo-Fields"
contentTypeLogs string = "application/x-www-form-urlencoded"
contentTypePrometheus string = "application/vnd.sumologic.prometheus"
contentTypeCarbon2 string = "application/vnd.sumologic.carbon2"
contentTypeGraphite string = "application/vnd.sumologic.graphite"
contentEncodingGzip string = "gzip"
contentEncodingDeflate string = "deflate"
)
func newAppendResponse() appendResponse {
return appendResponse{
appended: true,
}
}
func newSender(
cfg *Config,
cl *http.Client,
f filter,
s sourceFormats,
c compressor,
pf prometheusFormatter,
gf graphiteFormatter,
) *sender {
return &sender{
config: cfg,
client: cl,
filter: f,
sources: s,
compressor: c,
prometheusFormatter: pf,
graphiteFormatter: gf,
}
}
// send sends data to sumologic
func (s *sender) send(ctx context.Context, pipeline PipelineType, body io.Reader, flds fields) error {
data, err := s.compressor.compress(body)
if err != nil {
return err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.config.HTTPClientSettings.Endpoint, data)
if err != nil {
return err
}
// Add headers
switch s.config.CompressEncoding {
case GZIPCompression:
req.Header.Set(headerContentEncoding, contentEncodingGzip)
case DeflateCompression:
req.Header.Set(headerContentEncoding, contentEncodingDeflate)
case NoCompression:
default:
return fmt.Errorf("invalid content encoding: %s", s.config.CompressEncoding)
}
req.Header.Add(headerClient, s.config.Client)
if s.sources.host.isSet() {
req.Header.Add(headerHost, s.sources.host.format(flds))
}
if s.sources.name.isSet() {
req.Header.Add(headerName, s.sources.name.format(flds))
}
if s.sources.category.isSet() {
req.Header.Add(headerCategory, s.sources.category.format(flds))
}
switch pipeline {
case LogsPipeline:
req.Header.Add(headerContentType, contentTypeLogs)
req.Header.Add(headerFields, flds.string())
case MetricsPipeline:
switch s.config.MetricFormat {
case PrometheusFormat:
req.Header.Add(headerContentType, contentTypePrometheus)
case Carbon2Format:
req.Header.Add(headerContentType, contentTypeCarbon2)
case GraphiteFormat:
req.Header.Add(headerContentType, contentTypeGraphite)
default:
return fmt.Errorf("unsupported metrics format: %s", s.config.MetricFormat)
}
default:
return errors.New("unexpected pipeline")
}
resp, err := s.client.Do(req)
if err != nil {
return err
}
if resp.StatusCode < 200 || resp.StatusCode >= 400 {
return fmt.Errorf("error during sending data: %s", resp.Status)
}
return nil
}
// logToText converts LogRecord to a plain text line, returns it and error eventually
func (s *sender) logToText(record plog.LogRecord) string {
return record.Body().AsString()
}
// logToJSON converts LogRecord to a json line, returns it and error eventually
func (s *sender) logToJSON(record plog.LogRecord) (string, error) {
data := s.filter.filterOut(record.Attributes())
record.Body().CopyTo(data.orig.PutEmpty(logKey))
nextLine, err := json.Marshal(data.orig.AsRaw())
if err != nil {
return "", err
}
return bytes.NewBuffer(nextLine).String(), nil
}
// sendLogs sends log records from the logBuffer formatted according
// to configured LogFormat and as the result of execution
// returns array of records which has not been sent correctly and error
func (s *sender) sendLogs(ctx context.Context, flds fields) ([]plog.LogRecord, error) {
var (
body strings.Builder
errs error
droppedRecords []plog.LogRecord
currentRecords []plog.LogRecord
)
for _, record := range s.logBuffer {
var formattedLine string
var err error
switch s.config.LogFormat {
case TextFormat:
formattedLine = s.logToText(record)
case JSONFormat:
formattedLine, err = s.logToJSON(record)
default:
err = errors.New("unexpected log format")
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, LogsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, LogsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
}
return droppedRecords, errs
}
// sendMetrics sends metrics in right format basing on the s.config.MetricFormat
func (s *sender) sendMetrics(ctx context.Context, flds fields) ([]metricPair, error) {
var (
body strings.Builder
errs error
droppedRecords []metricPair
currentRecords []metricPair
)
for _, record := range s.metricBuffer {
var formattedLine string
var err error
switch s.config.MetricFormat {
case PrometheusFormat:
formattedLine = s.prometheusFormatter.metric2String(record)
case Carbon2Format:
formattedLine = carbon2Metric2String(record)
case GraphiteFormat:
formattedLine = s.graphiteFormatter.metric2String(record)
default:
err = fmt.Errorf("unexpected metric format: %s", s.config.MetricFormat)
}
if err != nil {
droppedRecords = append(droppedRecords, record)
errs = multierr.Append(errs, err)
continue
}
ar, err := s.appendAndSend(ctx, formattedLine, MetricsPipeline, &body, flds)
if err != nil {
errs = multierr.Append(errs, err)
if ar.sent {
droppedRecords = append(droppedRecords, currentRecords...)
}
if !ar.appended {
droppedRecords = append(droppedRecords, record)
}
}
// If data was sent, cleanup the currentTimeSeries counter
if ar.sent {
currentRecords = currentRecords[:0]
}
// If log has been appended to body, increment the currentTimeSeries
if ar.appended {
currentRecords = append(currentRecords, record)
}
}
if body.Len() > 0 {
if err := s.send(ctx, MetricsPipeline, strings.NewReader(body.String()), flds); err != nil {
errs = multierr.Append(errs, err)
droppedRecords = append(droppedRecords, currentRecords...)
}
}
return droppedRecords, errs
}
// appendAndSend appends line to the request body that will be sent and sends
// the accumulated data if the internal logBuffer has been filled (with maxBufferSize elements).
// It returns appendResponse
func (s *sender) appendAndSend(
ctx context.Context,
line string,
pipeline PipelineType,
body *strings.Builder,
flds fields,
) (appendResponse, error) {
var errs error
ar := newAppendResponse()
if body.Len() > 0 && body.Len()+len(line) >= s.config.MaxRequestBodySize {
ar.sent = true
errs = multierr.Append(errs, s.send(ctx, pipeline, strings.NewReader(body.String()), flds))
body.Reset()
}
if body.Len() > 0 {
// Do not add newline if the body is empty
if _, err := body.WriteString("\n"); err != nil {
errs = multierr.Append(errs, err)
ar.appended = false
}
}
if ar.appended {
// Do not append new line if separator was not appended
if _, err := body.WriteString(line); err != nil {
errs = multierr.Append(errs, err)
ar.appended = false
}
}
return ar, errs
}
// cleanLogsBuffer zeroes logBuffer
func (s *sender) cleanLogsBuffer() | {
s.logBuffer = (s.logBuffer)[:0]
} | identifier_body |
|
marketplace.js | (n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
function filterSearch() {
var fs = {};
fs.CompanyName = '';
fs.Products = [];
fs.ProductCategories = []
fs.ProducingCountries = [];
fs.ProducingRegions = [];
fs.StandardsCertified = []
fs.StandardsAssessed = [];
fs.Compliance = {};
fs.Compliance.Overall = max(-1, $('#overallPercentage').val());
fs.Compliance.Environment = max(-1, $('#environmentPercentage').val());
fs.Compliance.Social = max(-1, $('#sociallPercentage').val());
fs.Compliance.Economic = max(-1, $('#economicPercentage').val());
fs.Compliance.Quality = max(-1, $('#qualityPercentage').val());
fs.Compliance.BusinessIntegrity = max(-1, $('#businessIntegrityPercentage').val());
var sd;
sd = $('#CompanyName').val();
if (sd && 0 < sd.length) {
fs.CompanyName = sd;
}
sd = $('#DropDownProduct').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
var p = o.split(':')[2];
if (p && 0 < p) fs.Products.push(p);
else fs.ProductCategories.push(o.split(':')[0]);
});
}
sd = $('#DropDownProducingCountry').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
var p = o.split(':')[1];
if (p && 0 < p) fs.ProducingCountries.push(p);
else fs.ProducingRegions.push(o.split(':')[0]);
});
}
sd = $('#StandardsCertifiedList').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
fs.StandardsCertified.push(o);
});
}
sd = $('#StandardsAssessedList').val();
if (sd && 0 < sd.length) {
sd.forEach(function (o, i) {
fs.StandardsAssessed.push(o);
});
}
searchReports(fs, buildResultsTable);
}
var buildResultsTable = function (d) {
var results_container = $('#ResultsTable tbody');
var standard_template = '<span class="standard" data-id="{0}" data-name="{1}" data-logolarge="{3}"><a href="marketplace.aspx#"><img src="http://search.standardsmap.org:8080/{2}" title="{1}" width="45" height="45" /></a></span>';
var row_template = '<tr class="report_result" data-id="{0}"><td class="company"><a href="marketplace.aspx#">{1}</a></td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td><td><a href="http://search.standardsmap.org:8080/reportfinal.aspx?report={0}">View</a></td></tr>';
var report_template = '<tr class="standard_result" data-id="{0}" id="{3}-{0}"><td colspan="6"><span class="standard_title"><img src="http://search.standardsmap.org:8080/{2}" width="90" height="90" /><h4>{1}</h4></span><span id="data-{3}-{0}"></span></td></tr>';
var company_template = '<tr class="company_result" data-id="{0}" id="{1}-{0}"><td colspan="6"><span id="company-{1}-{0}"></span></td></tr>';
results_container.empty();
if (d) {
var rpt_list = [];
d.forEach(function (r, i) {
rpt_list.push(r.ReportID);
var standards = '';
if (r.Standards) {
r.Standards.forEach(function (s, i) { standards += standard_template.format(s.Id, s.Name, s.LogoSmall, s.LogoLarge); });
}
var row = $(row_template.format(r.ReportID, r.CompanyName, r.Product, r.Country, standards, formatDate(fixJsonDate(r.Modified))));
row.find('td.company a').on('click', function (ev) {
ev.preventDefault();
var result = $(ev.currentTarget).closest('.report_result');
var cmp_row = results_container.find('#' + r.ReportID + '-' + r.CompanyID + '.company_result');
// does the row exist? if so toggle visibility
if (cmp_row.length) {
cmp_row.toggle();
}
else {
cmp_row = result.after(company_template.format(r.CompanyID, r.ReportID));
getCompanyDetails(r.CompanyID, 0, 1, function (d) {
showCompanyDetails(d, '#company-' + r.ReportID + '-' + r.CompanyID);
});
}
});
results_container.append(row);
});
results_container.find('.standard a').on('click', function (ev) {
ev.preventDefault();
var std = $(ev.currentTarget).closest('.standard');
var result = std.closest('.report_result');
var id = std.attr('data-id');
var name = std.attr('data-name');
var logo = std.attr('data-logolarge');
var rid = result.attr('data-id');
var std_row = results_container.find('#' + rid + '-' + id + '.standard_result');
// does the row exist? if so toggle visibility
if (std_row.length) {
std_row.toggle();
}
else {
var cmp_row = result.next('.company_result');
if (cmp_row.length) {
std_row = cmp_row.after(report_template.format(id, name, logo, rid));
}
else {
std_row = result.after(report_template.format(id, name, logo, rid));
}
getStandardResults(rid, id, 0, function (d) {
showStandardResults(d.Data, '#data-' + rid + '-' + id);
});
}
});
$('#ReportIDs').val(rpt_list.join(','));
}
}
var fixJsonDate = function (dt) {
var date = new Date(parseInt(dt.replace(/[^0-9 +]/g, '')));
return date;
}
var formatDate = function (d) {
var dd = d.getDate();
if ( dd < 10 ) dd = '0' + dd;
var mm = d.getMonth()+1;
if ( mm < 10 ) mm = '0' + mm;
var yy = d.getFullYear() % 100;
if ( yy < 10 ) yy = '0' + yy;
return dd+'/'+mm+'/'+yy;
}
var showCompanyDetails = function (d, el) {
var template = '<span class="standard_title"><img src="http://search.standardsmap.org:8080/{5}" width="90" height="90"><h4>{1}</h4></span><span class="company_details"><p class="lead">{2}</p><p>Products/Services: {6}<br />Destination markets: {7}</p><p>Contact: <a href="mailto:{4}">{4}</a><br />Website: <a href="http://search.standardsmap.org:8080/{3}" target="_blank">{3}</a></p></span>{8}';
var standards = '';
var standard_template = '<span class="standard" data-id="{0}" data-name="{1}" data-logolarge="{3}"><img src="http://search.standardsmap.org:8080/{2}" title="{1}" alt="{1}" width="45" height="45" /></span>';
if (d.Standards) {
standards = '<span class="standards_certified">';
d.Standards.forEach(function (s, i) { standards += standard_template.format(s.Id, s.Name, s.LogoSmall, s.LogoLarge); });
standards += '</span>';
}
$(el).append(template.format(d.Id, d.Name, d.Description, d.Website, d.ContactEmail, d.Logo, d.Products, d.DestinationMarkets, standards));
}
var showStandardResults = function (d, el) {
//var overview_template = '<table class="table overview_table"><thead><tr><th>Overall</th><th>Environment</th><th>Social</th><th>Economic</th><th>Quality management</th><th>Ethics</th></tr></thead><tbody><tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{4}</td><td>{5}</td></tr></tbody></table>';
var overview_template = '<table class="overview_table"><caption>Latest compliance assessment {6}</caption><thead><tr class="hotspot-background-colors"><th class=""><i>∑</i>Overall</th><th class="hotspot-environment "><i class="icon-sm-environment"></i> Environment</th><th class="hotspot-social "><i class="icon-sm-social"></i> Social</th><th class="hotspot-economic "><i class="icon-sm-economic"></i> Economic</th><th class="hotspot-quality-management"><i class="icon-sm-quality"></i> Quality</th><th class="hotspot-ethics"><i class=" | isNumber | identifier_name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.