filename
stringlengths 4
198
| content
stringlengths 25
939k
| environment
list | variablearg
list | constarg
list | variableargjson
stringclasses 1
value | constargjson
stringlengths 2
3.9k
| lang
stringclasses 3
values | constargcount
float64 0
129
⌀ | variableargcount
float64 0
0
⌀ | sentence
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
fall_web_app.py
|
import streamlit as st
from streamlit_player import st_player
import cv2
import numpy as np
import tempfile
import time
from PIL import Image
############################################################
############################################################
import os
import collections
# comment out below line to enable tensorflow logging outputs
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import time
import tensorflow as tf
import core.yolov4
import core.utils as utils
from core.yolov4 import filter_boxes
from tensorflow.python.saved_model import tag_constants
from core.config import cfg
from PIL import Image
import cv2
import numpy as np
import matplotlib.pyplot as plt
from tensorflow._api.v2.compat.v1 import ConfigProto
from tensorflow._api.v2.compat.v1 import InteractiveSession
from deep_sort import preprocessing, nn_matching
from deep_sort.detection import Detection
from deep_sort.tracker import Tracker
from tools import generate_detections as gdet
max_cosine_distance = 0.4
nn_budget = None
nms_max_overlap = 1.0
# initialize deep sort
model_filename = 'model_data/mars-small128.pb'
encoder = gdet.create_box_encoder(model_filename, batch_size=1)
# calculate cosine distance metric
metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget)
# initialize tracker
tracker = Tracker(metric)
# load configuration for object detector
config = ConfigProto()
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)
STRIDES = np.array(cfg.YOLO.STRIDES)
ANCHORS = utils.get_anchors(cfg.YOLO.ANCHORS_TINY, True)
NUM_CLASS = len(utils.read_class_names(cfg.YOLO.CLASSES))
XYSCALE = cfg.YOLO.XYSCALE
FRAMEWORK = 'tf'
input_size = 416
video_path = './data/video/fall_sample2.mp4'
saved_model_loaded = tf.saved_model.load('./checkpoints/yolov4-416', tags=[tag_constants.SERVING])
infer = saved_model_loaded.signatures['serving_default']
############################################################
############################################################
DEMO_VIDEO = 'demo_video.mp4'
st.title('Fall Detection Application Using YOLO')
st.markdown(
"""
<style>
[data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
width: 300px;
}
[data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
width: 300px;
margin-left: -300px;
}
</style>
""",
unsafe_allow_html=True,
)
st.sidebar.title('Menu')
# st.sidebar.subheader('Parameters')
@st.cache()
def image_resize(image, width=None, height=None, inter=cv2.INTER_AREA):
# initialize the dimensions of the image to be resized and
# grab the image size
dim = None
(h, w) = image.shape[:2]
# if both the width and height are None, then return the
# original image
if width is None and height is None:
return image
# check to see if the width is None
if width is None:
# calculate the ratio of the height and construct the
# dimensions
r = height / float(h)
dim = (int(w * r), height)
# otherwise, the height is None
else:
# calculate the ratio of the width and construct the
# dimensions
r = width / float(w)
dim = (width, int(h * r))
# resize the image
resized = cv2.resize(image, dim, interpolation=inter)
# return the resized image
return resized
app_mode = st.sidebar.selectbox('Please Select',
['About', 'Sample Videos', 'Help', 'Run on Video']
)
if app_mode =='About':
st.markdown('''
This is an application for fall detection of individuals based on the **YOLO V.4** object detection algorithm.
The method used in this algorithm is suitable for detecting falls from a standing position or while walking. \n
This method is based on the proposed method in **Lu, K. L., & Chu, E. T. H. (2018).
An image-based fall detection system for the elderly. Applied Sciences, 8(10), 1995.**
''')
st.markdown(
"""
<style>
[data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
width: 300px;
}
[data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
width: 300px;
margin-left: -300px;
}
</style>
""",
unsafe_allow_html=True,
)
st.image('TEAM_LOGO.jpg')
elif app_mode == 'Sample Videos':
st.video('demo1.mp4', format='video/mp4', start_time=0)
st.video('demo2.mp4', format='video/mp4', start_time=0)
st.video('demo3.mp4', format='video/mp4', start_time=0)
st.video('demo4.mp4', format='video/mp4', start_time=0)
elif app_mode == 'Help':
st.markdown('''
- The Ratio Factor is a factor which multiplied by the height of the bounding box of
the person at 1.5 seconds before each moment. If the height of the bounding box at each
moment is less than the multiplication value, the algorithm will detect a falling-down occurrence.
The suggested value is 5.5, but values between 5 and 7 are good choices. The higher values will lead to more
conservative results. \n
''')
st.markdown(
"""
<style>
[data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
width: 300px;
}
[data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
width: 300px;
margin-left: -300px;
}
</style>
""",
unsafe_allow_html=True,
)
####################################################################
####################################################################
elif app_mode == 'Run on Video':
st.set_option('deprecation.showfileUploaderEncoding', False)
st.sidebar.markdown('---')
ratio = st.sidebar.slider('Ratio', min_value=1.0, max_value=8.0, value=5.5, step=0.5)
st.sidebar.markdown('---')
st.markdown(' ## Output')
st.markdown(
"""
<style>
[data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
width: 300px;
}
[data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
width: 300px;
margin-left: -300px;
}
</style>
""",
unsafe_allow_html=True,
)
stframe = st.empty()
video_file_buffer = st.sidebar.file_uploader("Upload a video", type=['mp4'])
tffile = tempfile.NamedTemporaryFile(delete=False)
if not video_file_buffer:
vid = cv2.VideoCapture(DEMO_VIDEO)
tffile.name = DEMO_VIDEO
else:
tffile.write(video_file_buffer.read())
vid = cv2.VideoCapture(tffile.name)
width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps_input = int(vid.get(cv2.CAP_PROP_FPS))
# codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
codec = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output_res.avi', codec, fps_input, (width, height))
st.sidebar.text('Input Video')
st.sidebar.video(tffile.name)
fps = 0
i = 0
kpi1, kpi2, kpi3 = st.beta_columns(3)
with kpi1:
kpi1 = st.markdown("**Frame Rate**")
kpi1_text = st.markdown("0")
with kpi2:
st.markdown("**Tracked Individuals**")
kpi2_text = st.markdown("0")
with kpi3:
st.markdown("**Fall Detection Status**")
kpi3_text = st.markdown('')
kpi3_text.write(f"<h1 style='text-align: center; color: green;'>{'No Fall'}</h1>", unsafe_allow_html=True)
st.markdown("<hr/>", unsafe_allow_html=True)
###################################################
###################################################
frame_num = 0
# while video is running
# DEFINING A DICTIONARY FOR TRACKING
id_Locs = collections.defaultdict(list) # FOR METHOD THREE
id_ylocs = collections.defaultdict(list) # FOR METHOD ONE
yLocs = []
falls = 0
track_dict = dict()
frame_list = []
while vid.isOpened():
i += 1
ret, frame = vid.read()
if not ret:
continue
if ret:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
image = Image.fromarray(frame)
else:
print('Video has ended or failed, try a different video format!')
break
frame_num += 1
frame_size = frame.shape[:2]
image_data = cv2.resize(frame, (input_size, input_size))
image_data = image_data / 255.
image_data = image_data[np.newaxis, ...].astype(np.float32)
start_time = time.time()
batch_data = tf.constant(image_data)
pred_bbox = infer(batch_data)
for key, value in pred_bbox.items():
boxes = value[:, :, 0:4]
pred_conf = value[:, :, 4:]
boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),
scores=tf.reshape(
pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),
max_output_size_per_class=50,
max_total_size=50,
iou_threshold=0.3,
score_threshold=0.2
)
# convert data to numpy arrays and slice out unused elements
num_objects = valid_detections.numpy()[0]
bboxes = boxes.numpy()[0]
bboxes = bboxes[0:int(num_objects)]
scores = scores.numpy()[0]
scores = scores[0:int(num_objects)]
classes = classes.numpy()[0]
classes = classes[0:int(num_objects)]
# format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, width, height
original_h, original_w, _ = frame.shape
bboxes = utils.format_boxes(bboxes, original_h, original_w)
# store all predictions in one parameter for simplicity when calling functions
pred_bbox = [bboxes, scores, classes, num_objects]
# read in all class names from config
class_names = utils.read_class_names(cfg.YOLO.CLASSES)
# by default allow all classes in .names file
# allowed_classes = list(class_names.values())
# custom allowed classes (uncomment line below to customize tracker for only people)
allowed_classes = ['person']
# loop through objects and use class index to get class name, allow only classes in allowed_classes list
names = []
deleted_indx = []
for i in range(num_objects):
class_indx = int(classes[i])
class_name = class_names[class_indx]
if class_name not in allowed_classes:
deleted_indx.append(i)
else:
names.append(class_name)
names = np.array(names)
count = len(names)
# cv2.putText(frame, "Objects being tracked: {}".format(count), (5, 35), cv2.FONT_HERSHEY_COMPLEX_SMALL, 2,
# (0, 255, 0), 2)
# print("Objects being tracked: {}".format(count))
# delete detections that are not in allowed_classes
bboxes = np.delete(bboxes, deleted_indx, axis=0)
scores = np.delete(scores, deleted_indx, axis=0)
# encode yolo detections and feed to tracker
features = encoder(frame, bboxes)
detections = [Detection(bbox, score, class_name, feature) for bbox, score, class_name, feature in
zip(bboxes, scores, names, features)]
# initialize color map
cmap = plt.get_cmap('tab20b')
colors = [cmap(i)[:3] for i in np.linspace(0, 1, 20)]
# run non-maxima supression
boxs = np.array([d.tlwh for d in detections])
scores = np.array([d.confidence for d in detections])
classes = np.array([d.class_name for d in detections])
indices = preprocessing.non_max_suppression(boxs, classes, nms_max_overlap, scores)
detections = [detections[i] for i in indices]
# Call the tracker
tracker.predict()
tracker.update(detections)
# update tracks
for track in tracker.tracks:
if not track.is_confirmed() or track.time_since_update > 1:
continue
bbox = track.to_tlbr()
class_name = track.get_class()
# draw bbox on screen
color = colors[int(track.track_id) % len(colors)]
color = [i * 255 for i in color]
cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2)
cv2.rectangle(frame, (int(bbox[0]), int(bbox[1] - 30)),
(int(bbox[0]) + (len(class_name) + len(str(track.track_id))) * 17, int(bbox[1])), color, -1)
# cv2.circle(frame, (int((bbox[0] + bbox[2]) / 2), int((bbox[1] + bbox[3]) / 2)), 5, color, -1)
# cv2.circle(frame, (int((bbox[0] + bbox[2]) / 2), int((bbox[1] + bbox[3]) / 2)), 15, (0, 255, 0), -1)
cv2.putText(frame, class_name + "-" + str(track.track_id), (int(bbox[0]), int(bbox[1] - 10)), 0, 0.75,
(255, 255, 255), 2)
#################################################
## PAPER METHOD FOR FALL DETECTION #############
#################################################
frameRate = 25
id_Locs[track.track_id].append([int(bbox[3] - bbox[1]), int(bbox[2] - bbox[0])])
for key, value in id_Locs.items():
if len(value) > int(np.floor(frameRate * 1.5)): # 1.5econds after detection a person:
# if value[-1][0] < (7/8) * value[-1 * int(np.floor(frameRate * 1.5))][0]:
# if value[-1][0] < (5.5 / 8) * value[-1 * int(np.floor(frameRate * 1.5))][0]:
if value[-1][0] < (ratio / 8) * value[-1 * int(np.floor(frameRate * 1.5))][0]:
print("Fall Detected")
cv2.putText(frame, "Person " + str(key) + " Fell Down", (70, 250), cv2.FONT_HERSHEY_PLAIN, 2,
(0, 0, 255), 3)
falls += 1
########################################################
# if enable, then print details about each track
# print("Tracker ID: {}, Class: {}, BBox Coords (xmin, ymin, xmax, ymax): {}".format(str(track.track_id),
# class_name, (
# int(bbox[0]),
# int(bbox[1]),
# int(bbox[2]),
# int(bbox[3]))))
each_id_list = [frame_num, str(track.track_id), int((bbox[0] + bbox[2]) / 2), int((bbox[1] + bbox[3]) / 2)]
frame_list.append(each_id_list)
# calculate frames per second of running detections
fps = 1.0 / (time.time() - start_time)
kpi1_text.write(f"<h1 style='text-align: center; color: red;'>{round(fps, 1)}</h1>", unsafe_allow_html=True)
kpi2_text.write(f"<h1 style='text-align: center; color: red;'>{count}</h1>", unsafe_allow_html=True)
if falls > 0:
cv2.putText(frame, "Fall Detected", (50, 100), cv2.FONT_HERSHEY_PLAIN, 3,
(255, 0, 0), 5)
kpi3_text.write(f"<h1 style='text-align: center; color: red;'>{'Fall Detected'}</h1>", unsafe_allow_html=True)
frame = cv2.resize(frame, (0, 0), fx=0.8, fy=0.8)
frame = image_resize(image=frame, width=640)
stframe.image(frame, channels='RGB', use_column_width=True)
out.write(frame)
vid.release()
out.release()
|
[] |
[] |
[
"TF_CPP_MIN_LOG_LEVEL"
] |
[]
|
["TF_CPP_MIN_LOG_LEVEL"]
|
python
| 1 | 0 | |
kafka/channel/pkg/dispatcher/dispatcher_it_test.go
|
/*
Copyright 2020 The Knative Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package dispatcher
import (
"context"
"net/http"
"net/http/httptest"
"net/http/httputil"
"os"
"sync"
"testing"
"time"
"github.com/cloudevents/sdk-go/v2/binding"
"github.com/cloudevents/sdk-go/v2/binding/transformer"
protocolhttp "github.com/cloudevents/sdk-go/v2/protocol/http"
"github.com/cloudevents/sdk-go/v2/test"
"go.uber.org/zap"
eventingduck "knative.dev/eventing/pkg/apis/duck/v1beta1"
"knative.dev/eventing/pkg/kncloudevents"
"knative.dev/eventing/pkg/tracing"
"knative.dev/pkg/apis"
duckv1 "knative.dev/pkg/apis/duck/v1"
tracingconfig "knative.dev/pkg/tracing/config"
"knative.dev/eventing-contrib/kafka/channel/pkg/utils"
)
// This dispatcher tests the full integration of the dispatcher code with Kafka.
// This test doesn't run on the CI because unit tests script doesn't start a Kafka cluster.
// Use it in emergency situations when you can't reproduce the e2e test failures and the failure might be
// in the dispatcher code.
// Start a kafka cluster with docker: docker run --rm --net=host -e ADV_HOST=localhost -e SAMPLEDATA=0 lensesio/fast-data-dev
// Keep also the port 8080 free for the MessageReceiver
func TestDispatcher(t *testing.T) {
if os.Getenv("CI") == "true" {
t.Skipf("This test can't run in CI")
}
logger, err := zap.NewDevelopment(zap.AddStacktrace(zap.WarnLevel))
if err != nil {
t.Fatal(err)
}
tracing.SetupStaticPublishing(logger.Sugar(), "localhost", &tracingconfig.Config{
Backend: tracingconfig.Zipkin,
Debug: true,
SampleRate: 1.0,
ZipkinEndpoint: "http://localhost:9411/api/v2/spans",
})
dispatcherArgs := KafkaDispatcherArgs{
KnCEConnectionArgs: nil,
ClientID: "testing",
Brokers: []string{"localhost:9092"},
TopicFunc: utils.TopicName,
Logger: logger,
}
// Create the dispatcher. At this point, if Kafka is not up, this thing fails
dispatcher, err := NewDispatcher(context.Background(), &dispatcherArgs)
if err != nil {
t.Skipf("no dispatcher: %v", err)
}
// Start the dispatcher
go func() {
if err := dispatcher.Start(context.Background()); err != nil {
t.Error(err)
}
}()
time.Sleep(1 * time.Second)
// We need a channelaproxy and channelbproxy for handling correctly the Host header
channelAProxy := httptest.NewServer(createReverseProxy(t, "channela.svc"))
defer channelAProxy.Close()
channelBProxy := httptest.NewServer(createReverseProxy(t, "channelb.svc"))
defer channelBProxy.Close()
// Start a bunch of test servers to simulate the various services
transformationsWg := sync.WaitGroup{}
transformationsWg.Add(1)
transformationsServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer transformationsWg.Done()
message := protocolhttp.NewMessageFromHttpRequest(r)
defer message.Finish(nil)
err := protocolhttp.WriteResponseWriter(context.Background(), message, 200, w, transformer.AddExtension("transformed", "true"))
if err != nil {
w.WriteHeader(500)
t.Fatal(err)
}
}))
defer transformationsServer.Close()
receiverWg := sync.WaitGroup{}
receiverWg.Add(1)
receiverServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer receiverWg.Done()
transformed := r.Header.Get("ce-transformed")
if transformed != "true" {
w.WriteHeader(500)
t.Fatalf("Expecting ce-transformed: true, found %s", transformed)
}
}))
defer receiverServer.Close()
transformationsFailureWg := sync.WaitGroup{}
transformationsFailureWg.Add(1)
transformationsFailureServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer transformationsFailureWg.Done()
w.WriteHeader(500)
}))
defer transformationsFailureServer.Close()
deadLetterWg := sync.WaitGroup{}
deadLetterWg.Add(1)
deadLetterServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer deadLetterWg.Done()
transformed := r.Header.Get("ce-transformed")
if transformed != "" {
w.WriteHeader(500)
t.Fatalf("Not expecting ce-transformed, found %s", transformed)
}
}))
defer deadLetterServer.Close()
logger.Debug("Test servers",
zap.String("transformations server", transformationsServer.URL),
zap.String("transformations failure server", transformationsFailureServer.URL),
zap.String("receiver server", receiverServer.URL),
zap.String("dead letter server", deadLetterServer.URL),
)
// send -> channela -> sub with transformationServer and reply to channelb -> channelb -> sub with receiver -> receiver
config := Config{
ChannelConfigs: []ChannelConfig{
{
Namespace: "default",
Name: "channela",
HostName: "channela.svc",
Subscriptions: []Subscription{
{
SubscriberSpec: eventingduck.SubscriberSpec{
UID: "aaaa",
Generation: 1,
SubscriberURI: mustParseUrl(t, transformationsServer.URL),
ReplyURI: mustParseUrl(t, channelBProxy.URL),
},
},
{
SubscriberSpec: eventingduck.SubscriberSpec{
UID: "cccc",
Generation: 1,
SubscriberURI: mustParseUrl(t, transformationsFailureServer.URL),
ReplyURI: mustParseUrl(t, channelBProxy.URL),
Delivery: &eventingduck.DeliverySpec{
DeadLetterSink: &duckv1.Destination{URI: mustParseUrl(t, deadLetterServer.URL)},
},
},
},
},
},
{
Namespace: "default",
Name: "channelb",
HostName: "channelb.svc",
Subscriptions: []Subscription{
{
SubscriberSpec: eventingduck.SubscriberSpec{
UID: "bbbb",
Generation: 1,
SubscriberURI: mustParseUrl(t, receiverServer.URL),
},
},
},
},
},
}
err = dispatcher.UpdateHostToChannelMap(&config)
if err != nil {
t.Fatal(err)
}
failed, err := dispatcher.UpdateKafkaConsumers(&config)
if err != nil {
t.Fatal(err)
}
if len(failed) != 0 {
t.Fatal(err)
}
time.Sleep(5 * time.Second)
// Ok now everything should be ready to send the event
httpsender, err := kncloudevents.NewHttpMessageSender(nil, channelAProxy.URL)
if err != nil {
t.Fatal(err)
}
req, err := httpsender.NewCloudEventRequest(context.Background())
if err != nil {
t.Fatal(err)
}
event := test.FullEvent()
_ = protocolhttp.WriteRequest(context.Background(), binding.ToMessage(&event), req)
res, err := httpsender.Send(req)
if err != nil {
t.Fatal(err)
}
if res.StatusCode != 202 {
t.Fatalf("Expected 202, Have %d", res.StatusCode)
}
transformationsFailureWg.Wait()
deadLetterWg.Wait()
transformationsWg.Wait()
receiverWg.Wait()
// Try to close consumer groups
err = dispatcher.UpdateHostToChannelMap(&Config{})
if err != nil {
t.Fatal(err)
}
failed, err = dispatcher.UpdateKafkaConsumers(&Config{})
if err != nil {
t.Fatal(err)
}
if len(failed) != 0 {
t.Fatal(err)
}
}
func createReverseProxy(t *testing.T, host string) *httputil.ReverseProxy {
director := func(req *http.Request) {
target := mustParseUrl(t, "http://localhost:8080")
req.URL.Scheme = target.Scheme
req.URL.Host = target.Host
req.URL.Path = target.Path
req.Host = host
}
return &httputil.ReverseProxy{Director: director}
}
func mustParseUrl(t *testing.T, str string) *apis.URL {
url, err := apis.ParseURL(str)
if err != nil {
t.Fatal(err)
}
return url
}
|
[
"\"CI\""
] |
[] |
[
"CI"
] |
[]
|
["CI"]
|
go
| 1 | 0 | |
secrets/vault/vault_test.go
|
// Copyright 2019 The Go Cloud Development Kit Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limtations under the License.
package vault
import (
"context"
"errors"
"os"
"testing"
"github.com/hashicorp/vault/api"
"github.com/hashicorp/vault/builtin/logical/transit"
vhttp "github.com/hashicorp/vault/http"
"github.com/hashicorp/vault/logical"
"github.com/hashicorp/vault/vault"
"gocloud.dev/secrets"
"gocloud.dev/secrets/driver"
"gocloud.dev/secrets/drivertest"
)
const (
keyID1 = "test-secrets"
keyID2 = "test-secrets2"
apiAddress = "http://127.0.0.1:0"
)
type harness struct {
client *api.Client
close func()
}
func (h *harness) MakeDriver(ctx context.Context) (driver.Keeper, driver.Keeper, error) {
return &keeper{keyID: keyID1, client: h.client}, &keeper{keyID: keyID2, client: h.client}, nil
}
func (h *harness) Close() {
h.close()
}
func newHarness(ctx context.Context, t *testing.T) (drivertest.Harness, error) {
// Start a new test server.
c, cleanup := testVaultServer(t)
// Enable the Transit Secrets Engine to use Vault as an Encryption as a Service.
c.Logical().Write("sys/mounts/transit", map[string]interface{}{
"type": "transit",
})
return &harness{
client: c,
close: cleanup,
}, nil
}
func testVaultServer(t *testing.T) (*api.Client, func()) {
coreCfg := &vault.CoreConfig{
DisableMlock: true,
DisableCache: true,
// Enable the testing transit backend.
LogicalBackends: map[string]logical.Factory{
"transit": transit.Factory,
},
}
cluster := vault.NewTestCluster(t, coreCfg, &vault.TestClusterOptions{
HandlerFunc: vhttp.Handler,
})
cluster.Start()
tc := cluster.Cores[0]
vault.TestWaitActive(t, tc.Core)
tc.Client.SetToken(cluster.RootToken)
return tc.Client, cluster.Cleanup
}
func TestConformance(t *testing.T) {
drivertest.RunConformanceTests(t, newHarness, []drivertest.AsTest{verifyAs{}})
}
type verifyAs struct{}
func (v verifyAs) Name() string {
return "verify As function"
}
func (v verifyAs) ErrorCheck(k *secrets.Keeper, err error) error {
var s string
if k.ErrorAs(err, &s) {
return errors.New("Keeper.ErrorAs expected to fail")
}
return nil
}
// Vault-specific tests.
func TestNoSessionProvidedError(t *testing.T) {
if _, err := Dial(context.Background(), nil); err == nil {
t.Error("got nil, want no auth Config provided")
}
}
func TestNoConnectionError(t *testing.T) {
ctx := context.Background()
// Dial calls vault's NewClient method, which doesn't make the connection. Try
// doing encryption which should fail by no connection.
client, err := Dial(ctx, &Config{
Token: "<Client (Root) Token>",
APIConfig: api.Config{
Address: apiAddress,
},
})
if err != nil {
t.Fatal(err)
}
keeper := OpenKeeper(client, "my-key", nil)
defer keeper.Close()
if _, err := keeper.Encrypt(ctx, []byte("test")); err == nil {
t.Error("got nil, want connection refused")
}
}
func fakeConnectionStringInEnv() func() {
oldURLVal := os.Getenv("VAULT_SERVER_URL")
oldTokenVal := os.Getenv("VAULT_SERVER_TOKEN")
os.Setenv("VAULT_SERVER_URL", "http://myvaultserver")
os.Setenv("VAULT_SERVER_TOKEN", "faketoken")
return func() {
os.Setenv("VAULT_SERVER_URL", oldURLVal)
os.Setenv("VAULT_SERVER_TOKEN", oldTokenVal)
}
}
func TestOpenKeeper(t *testing.T) {
cleanup := fakeConnectionStringInEnv()
defer cleanup()
tests := []struct {
URL string
WantErr bool
}{
// OK.
{"vault://mykey", false},
// Invalid parameter.
{"vault://mykey?param=value", true},
}
ctx := context.Background()
for _, test := range tests {
keeper, err := secrets.OpenKeeper(ctx, test.URL)
if (err != nil) != test.WantErr {
t.Errorf("%s: got error %v, want error %v", test.URL, err, test.WantErr)
}
if err == nil {
if err = keeper.Close(); err != nil {
t.Errorf("%s: got error during close: %v", test.URL, err)
}
}
}
}
|
[
"\"VAULT_SERVER_URL\"",
"\"VAULT_SERVER_TOKEN\""
] |
[] |
[
"VAULT_SERVER_URL",
"VAULT_SERVER_TOKEN"
] |
[]
|
["VAULT_SERVER_URL", "VAULT_SERVER_TOKEN"]
|
go
| 2 | 0 | |
cmd/clean.go
|
/*
Copyright © 2021 NAME HERE <EMAIL ADDRESS>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package cmd
import (
"github.com/sealyun/cloud-kernel-rootfs/pkg/ecs"
"github.com/sealyun/cloud-kernel-rootfs/pkg/logger"
"github.com/sealyun/cloud-kernel-rootfs/pkg/vars"
"os"
"github.com/spf13/cobra"
)
var cloud string
var instanceIds []string
// cleanCmd represents the clean command
var cleanCmd = &cobra.Command{
Use: "clean",
Short: "删除已经创建的ecs",
Run: func(cmd *cobra.Command, args []string) {
var c ecs.Cloud
switch cloud {
case "aliyun":
c = &ecs.AliyunEcs{}
case "huaweiyun":
c = &ecs.HuaweiEcs{}
default:
logger.Fatal("不支持该类型的云厂商")
_ = cmd.Help()
os.Exit(0)
}
c.Delete(instanceIds, 10)
},
PreRun: func(cmd *cobra.Command, args []string) {
if vars.AkID == "" {
if v := os.Getenv("ECS_AKID"); v != "" {
vars.AkID = v
}
}
if vars.AkSK == "" {
if v := os.Getenv("ECS_AKSK"); v != "" {
vars.AkSK = v
}
}
if vars.AkID == "" {
logger.Fatal("云厂商的akId为空,无法清空虚拟机")
cmd.Help()
os.Exit(-1)
}
if vars.AkSK == "" {
logger.Fatal("云厂商的akSK为空,无法清空虚拟机")
_ = cmd.Help()
os.Exit(0)
}
if len(instanceIds) == 0 {
logger.Fatal("instance id为空,无法清空虚拟机")
cmd.Help()
os.Exit(0)
}
},
}
func init() {
rootCmd.AddCommand(cleanCmd)
// Here you will define your flags and configuration settings.
cleanCmd.Flags().StringVar(&vars.AkID, "akid", "", "云厂商的 akId")
cleanCmd.Flags().StringVar(&vars.AkSK, "aksk", "", "云厂商的 akSK")
cleanCmd.Flags().StringVar(&cloud, "cloud", "aliyun", "云厂商类型（aliyun,huaweiyun）")
cleanCmd.Flags().StringSliceVar(&instanceIds, "instance", []string{}, "删除ecs的instanceID")
// Cobra supports Persistent Flags which will work for this command
// and all subcommands, e.g.:
// cleanCmd.PersistentFlags().String("foo", "", "A help for foo")
// Cobra supports local flags which will only run when this command
// is called directly, e.g.:
// cleanCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}
|
[
"\"ECS_AKID\"",
"\"ECS_AKSK\""
] |
[] |
[
"ECS_AKSK",
"ECS_AKID"
] |
[]
|
["ECS_AKSK", "ECS_AKID"]
|
go
| 2 | 0 | |
simple_service_registration/vendor/fetchai/connections/p2p_libp2p/libp2p_node/aea/api.go
|
/* -*- coding: utf-8 -*-
* ------------------------------------------------------------------------------
*
* Copyright 2018-2019 Fetch.AI Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* ------------------------------------------------------------------------------
*/
package aea
import (
"errors"
"log"
"net"
"os"
"strconv"
"strings"
"time"
"github.com/joho/godotenv"
"github.com/rs/zerolog"
proto "google.golang.org/protobuf/proto"
)
// code redandency to avoid import cycle
var logger zerolog.Logger = zerolog.New(zerolog.ConsoleWriter{
Out: os.Stdout,
NoColor: false,
TimeFormat: "15:04:05.000",
}).
With().Timestamp().
Str("package", "AeaApi").
Logger()
type Pipe interface {
Connect() error
Read() ([]byte, error)
Write(data []byte) error
Close() error
}
// Needed to break import cycle
type AgentRecord struct {
ServiceId string
LedgerId string
Address string
PublicKey string
PeerPublicKey string
Signature string
}
/*
AeaApi type
*/
type AeaApi struct {
msgin_path string
msgout_path string
agent_addr string
agent_record *AgentRecord
id string
entry_peers []string
host string
port uint16
host_public string
port_public uint16
host_delegate string
port_delegate uint16
host_monitoring string
port_monitoring uint16
registrationDelay float64
recordsStoragePath string
pipe Pipe
out_queue chan *Envelope
closing bool
connected bool
sandbox bool
standalone bool
}
func (aea AeaApi) AeaAddress() string {
return aea.agent_addr
}
func (aea AeaApi) PrivateKey() string {
return aea.id
}
func (aea AeaApi) Address() (string, uint16) {
return aea.host, aea.port
}
func (aea AeaApi) PublicAddress() (string, uint16) {
return aea.host_public, aea.port_public
}
func (aea AeaApi) DelegateAddress() (string, uint16) {
return aea.host_delegate, aea.port_delegate
}
func (aea AeaApi) MonitoringAddress() (string, uint16) {
return aea.host_monitoring, aea.port_monitoring
}
func (aea AeaApi) EntryPeers() []string {
return aea.entry_peers
}
func (aea AeaApi) AgentRecord() *AgentRecord {
return aea.agent_record
}
func (aea AeaApi) RegistrationDelayInSeconds() float64 {
return aea.registrationDelay
}
func (aea AeaApi) RecordStoragePath() string {
return aea.recordsStoragePath
}
func (aea AeaApi) Put(envelope *Envelope) error {
if aea.standalone {
errorMsg := "node running in standalone mode"
logger.Warn().Msgf(errorMsg)
return errors.New(errorMsg)
}
return write_envelope(aea.pipe, envelope)
}
func (aea *AeaApi) Get() *Envelope {
if aea.standalone {
errorMsg := "node running in standalone mode"
logger.Warn().Msgf(errorMsg)
return nil
}
return <-aea.out_queue
}
func (aea *AeaApi) Queue() <-chan *Envelope {
return aea.out_queue
}
func (aea *AeaApi) Connected() bool {
return aea.connected || aea.standalone
}
func (aea *AeaApi) Stop() {
aea.closing = true
aea.stop()
close(aea.out_queue)
}
func (aea *AeaApi) Init() error {
zerolog.TimeFieldFormat = time.RFC3339Nano
if aea.sandbox {
return nil
}
if aea.connected {
return nil
}
aea.connected = false
env_file := os.Args[1]
logger.Debug().Msgf("env_file: %s", env_file)
// get config
err := godotenv.Overload(env_file)
if err != nil {
log.Fatal("Error loading env file")
}
aea.msgin_path = os.Getenv("AEA_TO_NODE")
aea.msgout_path = os.Getenv("NODE_TO_AEA")
aea.agent_addr = os.Getenv("AEA_AGENT_ADDR")
aea.id = os.Getenv("AEA_P2P_ID")
entry_peers := os.Getenv("AEA_P2P_ENTRY_URIS")
uri := os.Getenv("AEA_P2P_URI")
uri_public := os.Getenv("AEA_P2P_URI_PUBLIC")
uri_delegate := os.Getenv("AEA_P2P_DELEGATE_URI")
uri_monitoring := os.Getenv("AEA_P2P_URI_MONITORING")
por_address := os.Getenv("AEA_P2P_POR_ADDRESS")
if por_address != "" {
record := &AgentRecord{Address: por_address}
record.PublicKey = os.Getenv("AEA_P2P_POR_PUBKEY")
record.PeerPublicKey = os.Getenv("AEA_P2P_POR_PEER_PUBKEY")
record.Signature = os.Getenv("AEA_P2P_POR_SIGNATURE")
record.ServiceId = os.Getenv("AEA_P2P_POR_SERVICE_ID")
record.LedgerId = os.Getenv("AEA_P2P_POR_LEDGER_ID")
aea.agent_record = record
}
registrationDelay := os.Getenv("AEA_P2P_CFG_REGISTRATION_DELAY")
aea.recordsStoragePath = os.Getenv("AEA_P2P_CFG_STORAGE_PATH")
logger.Debug().Msgf("msgin_path: %s", aea.msgin_path)
logger.Debug().Msgf("msgout_path: %s", aea.msgout_path)
logger.Debug().Msgf("id: %s", aea.id)
logger.Debug().Msgf("addr: %s", aea.agent_addr)
logger.Debug().Msgf("entry_peers: %s", entry_peers)
logger.Debug().Msgf("uri: %s", uri)
logger.Debug().Msgf("uri public: %s", uri_public)
logger.Debug().Msgf("uri delegate service: %s", uri_delegate)
if aea.id == "" || uri == "" {
err := errors.New("couldn't get AEA configuration: key and uri are required")
logger.Error().Str("err", err.Error()).Msg("")
return err
}
if aea.msgin_path == "" && aea.msgout_path == "" && aea.agent_addr == "" {
aea.standalone = true
} else if aea.msgin_path == "" || aea.msgout_path == "" || aea.agent_addr == "" {
err := errors.New("couldn't get AEA configuration: pipes paths are required when agent address is provided")
logger.Error().Str("err", err.Error()).Msg("")
return err
}
// parse uri
parts := strings.SplitN(uri, ":", -1)
if len(parts) < 2 {
err := errors.New("malformed Uri " + uri)
logger.Error().Str("err", err.Error()).Msg("")
return err
}
aea.host = parts[0]
port, _ := strconv.ParseUint(parts[1], 10, 16)
aea.port = uint16(port)
// hack: test if port is taken
addr, err := net.ResolveTCPAddr("tcp", uri)
if err != nil {
return err
}
listener, err := net.ListenTCP("tcp", addr)
if err != nil {
logger.Error().Str("err", err.Error()).Msgf("Uri already taken %s", uri)
return err
}
listener.Close()
// parse public uri
if uri_public != "" {
parts = strings.SplitN(uri_public, ":", -1)
if len(parts) < 2 {
err := errors.New("malformed Uri " + uri_public)
logger.Error().Str("err", err.Error()).Msg("")
return err
}
aea.host_public = parts[0]
port, _ = strconv.ParseUint(parts[1], 10, 16)
aea.port_public = uint16(port)
} else {
aea.host_public = ""
aea.port_public = 0
}
// parse delegate uri
if uri_delegate != "" {
parts = strings.SplitN(uri_delegate, ":", -1)
if len(parts) < 2 {
err := errors.New("malformed Uri " + uri_delegate)
logger.Error().Str("err", err.Error()).Msg("")
return err
}
aea.host_delegate = parts[0]
port, _ = strconv.ParseUint(parts[1], 10, 16)
aea.port_delegate = uint16(port)
} else {
aea.host_delegate = ""
aea.port_delegate = 0
}
// parse monitoring uri
if uri_monitoring != "" {
parts = strings.SplitN(uri_monitoring, ":", -1)
if len(parts) < 2 {
err := errors.New("malformed Uri " + uri_monitoring)
logger.Error().Str("err", err.Error()).Msg("")
return err
}
aea.host_monitoring = parts[0]
port, _ = strconv.ParseUint(parts[1], 10, 16)
aea.port_monitoring = uint16(port)
} else {
aea.host_monitoring = ""
aea.port_monitoring = 0
}
// parse entry peers multiaddrs
if len(entry_peers) > 0 {
aea.entry_peers = strings.SplitN(entry_peers, ",", -1)
}
// parse registration delay
if registrationDelay == "" {
aea.registrationDelay = 0.0
} else {
delay, err := strconv.ParseFloat(registrationDelay, 32)
if err != nil {
logger.Error().Str("err", err.Error()).Msgf("malformed RegistrationDelay value")
return err
}
aea.registrationDelay = delay
}
// setup pipe
if !aea.standalone {
aea.pipe = NewPipe(aea.msgin_path, aea.msgout_path)
}
return nil
}
func (aea *AeaApi) Connect() error {
if aea.standalone {
logger.Info().Msg("Successfully running in standalone mode")
return nil
}
// open pipes
err := aea.pipe.Connect()
if err != nil {
logger.Error().Str("err", err.Error()).
Msg("while connecting to pipe")
return err
}
aea.closing = false
//TOFIX(LR) trade-offs between bufferd vs unbuffered channel
aea.out_queue = make(chan *Envelope, 10)
go aea.listen_for_envelopes()
logger.Info().Msg("connected to agent")
aea.connected = true
return nil
}
func UnmarshalEnvelope(buf []byte) (*Envelope, error) {
envelope := &Envelope{}
err := proto.Unmarshal(buf, envelope)
return envelope, err
}
func (aea *AeaApi) listen_for_envelopes() {
//TOFIX(LR) add an exit strategy
for {
envel, err := read_envelope(aea.pipe)
if err != nil {
logger.Error().Str("err", err.Error()).Msg("while receiving envelope")
logger.Info().Msg("disconnecting")
// TOFIX(LR) see above
if !aea.closing {
aea.stop()
}
return
}
if envel.Sender != aea.agent_record.Address {
logger.Error().
Str("err", "Sender ("+envel.Sender+") must match registered address").
Msg("while processing envelope")
// TODO send error back to agent
continue
}
logger.Debug().Msgf("received envelope from agent")
aea.out_queue <- envel
if aea.closing {
return
}
}
}
func (aea *AeaApi) stop() {
aea.pipe.Close()
}
/*
Pipes helpers
*/
func write_envelope(pipe Pipe, envelope *Envelope) error {
data, err := proto.Marshal(envelope)
if err != nil {
logger.Error().Str("err", err.Error()).Msgf("while serializing envelope: %s", envelope)
return err
}
return pipe.Write(data)
}
func read_envelope(pipe Pipe) (*Envelope, error) {
envelope := &Envelope{}
data, err := pipe.Read()
if err != nil {
logger.Error().Str("err", err.Error()).Msg("while receiving data")
return envelope, err
}
err = proto.Unmarshal(data, envelope)
return envelope, err
}
|
[
"\"AEA_TO_NODE\"",
"\"NODE_TO_AEA\"",
"\"AEA_AGENT_ADDR\"",
"\"AEA_P2P_ID\"",
"\"AEA_P2P_ENTRY_URIS\"",
"\"AEA_P2P_URI\"",
"\"AEA_P2P_URI_PUBLIC\"",
"\"AEA_P2P_DELEGATE_URI\"",
"\"AEA_P2P_URI_MONITORING\"",
"\"AEA_P2P_POR_ADDRESS\"",
"\"AEA_P2P_POR_PUBKEY\"",
"\"AEA_P2P_POR_PEER_PUBKEY\"",
"\"AEA_P2P_POR_SIGNATURE\"",
"\"AEA_P2P_POR_SERVICE_ID\"",
"\"AEA_P2P_POR_LEDGER_ID\"",
"\"AEA_P2P_CFG_REGISTRATION_DELAY\"",
"\"AEA_P2P_CFG_STORAGE_PATH\""
] |
[] |
[
"AEA_AGENT_ADDR",
"AEA_P2P_POR_PEER_PUBKEY",
"AEA_P2P_POR_LEDGER_ID",
"AEA_P2P_DELEGATE_URI",
"AEA_P2P_POR_SIGNATURE",
"AEA_P2P_URI_MONITORING",
"AEA_P2P_ID",
"AEA_P2P_POR_SERVICE_ID",
"NODE_TO_AEA",
"AEA_P2P_CFG_STORAGE_PATH",
"AEA_TO_NODE",
"AEA_P2P_URI",
"AEA_P2P_POR_PUBKEY",
"AEA_P2P_CFG_REGISTRATION_DELAY",
"AEA_P2P_URI_PUBLIC",
"AEA_P2P_POR_ADDRESS",
"AEA_P2P_ENTRY_URIS"
] |
[]
|
["AEA_AGENT_ADDR", "AEA_P2P_POR_PEER_PUBKEY", "AEA_P2P_POR_LEDGER_ID", "AEA_P2P_DELEGATE_URI", "AEA_P2P_POR_SIGNATURE", "AEA_P2P_URI_MONITORING", "AEA_P2P_ID", "AEA_P2P_POR_SERVICE_ID", "NODE_TO_AEA", "AEA_P2P_CFG_STORAGE_PATH", "AEA_TO_NODE", "AEA_P2P_URI", "AEA_P2P_POR_PUBKEY", "AEA_P2P_CFG_REGISTRATION_DELAY", "AEA_P2P_URI_PUBLIC", "AEA_P2P_POR_ADDRESS", "AEA_P2P_ENTRY_URIS"]
|
go
| 17 | 0 | |
handlers/configuration.go
|
package handlers
import (
"os"
"strconv"
)
// LookupCredFile looks up the credential file
func LookupCredFile() string {
val, found := os.LookupEnv("CRED_FILE")
if !found {
val = "/credentials.json"
}
return val
}
// GetMaxJobConfig returns maximum number of jobs allowed
// to run simultanously
func GetMaxJobConfig() int {
maxJobNum, err := strconv.Atoi(os.Getenv("JOB_NUM_MAX"))
// set to 10 if there is no env varibale
if err != nil {
maxJobNum = 10
}
return maxJobNum
}
// GetCleanupTime returns the cleanuo time for completed jobs
func GetCleanupTime() int {
cleanupTime, err := strconv.Atoi(os.Getenv("CLEANUP_TIME"))
if err != nil {
cleanupTime = 120
}
return cleanupTime
}
const (
GRACE_PERIOD int64 = 1 // grace period in seconds before a job is deleted
)
|
[
"\"JOB_NUM_MAX\"",
"\"CLEANUP_TIME\""
] |
[] |
[
"JOB_NUM_MAX",
"CLEANUP_TIME"
] |
[]
|
["JOB_NUM_MAX", "CLEANUP_TIME"]
|
go
| 2 | 0 | |
main.go
|
package main
import (
"crypto/tls"
"log"
"net"
"net/http"
"net/url"
"os"
"time"
"github.com/codegangsta/negroni"
"github.com/lair-framework/api-server/app"
"gopkg.in/mgo.v2"
)
// TLSDial sets up a TLS connection to MongoDb.
func TLSDial(addr net.Addr) (net.Conn, error) {
return tls.Dial(addr.Network(), addr.String(), &tls.Config{InsecureSkipVerify: true})
}
func main() {
murl := os.Getenv("MONGO_URL")
if murl == "" {
log.Fatal("MONGO_URL environment variable not set")
}
apiListener := os.Getenv("API_LISTENER")
if apiListener == "" {
log.Fatal("API_LISTENER environment variable not set")
}
u, err := url.Parse(murl)
if err != nil {
log.Fatal("Erorr parsing MONGO_URL", err.Error())
}
q, err := url.ParseQuery(u.RawQuery)
if err != nil {
log.Fatal("Error parsing query parameters", err.Error())
}
dname := u.Path[1:]
s := &mgo.Session{}
if opt, ok := q["ssl"]; ok && opt[0] == "true" {
var user, pass string
if u.User != nil {
user = u.User.Username()
p, set := u.User.Password()
if set {
pass = p
}
}
d := &mgo.DialInfo{
Addrs: []string{u.Host},
Direct: true,
Database: dname,
Username: user,
Password: pass,
Dial: TLSDial,
Timeout: time.Duration(10) * time.Second,
}
s, err = mgo.DialWithInfo(d)
if err != nil {
log.Fatal("Could not connect to database. Error: ", err.Error())
}
} else {
s, err = mgo.Dial(murl)
if err != nil {
log.Fatal("Could not connect to database. Error: ", err.Error())
}
}
a := app.New(&app.O{
S: s,
DName: dname,
TransformDirectory: os.Getenv("TRANSFORM_DIR"),
})
db := s.DB(dname)
defer s.Close()
db.C(a.C.Hosts).EnsureIndexKey("projectId", "ipv4")
db.C(a.C.Services).EnsureIndexKey("projectId", "hostId", "port", "protocol")
db.C(a.C.Issues).EnsureIndexKey("projectId", "pluginIds")
db.C(a.C.WebDirectories).EnsureIndexKey("projectId", "hostId", "path", "port")
os.Mkdir(a.Filepath, 0775)
rec := negroni.NewRecovery()
rec.PrintStack = false
n := negroni.New(
negroni.NewLogger(),
rec,
)
n.UseHandler(a.Router())
log.Printf("Listening on %s", apiListener)
log.Fatal(http.ListenAndServe(apiListener, n))
}
|
[
"\"MONGO_URL\"",
"\"API_LISTENER\"",
"\"TRANSFORM_DIR\""
] |
[] |
[
"TRANSFORM_DIR",
"MONGO_URL",
"API_LISTENER"
] |
[]
|
["TRANSFORM_DIR", "MONGO_URL", "API_LISTENER"]
|
go
| 3 | 0 | |
cmd/sonarExecuteScan_test.go
|
package cmd
import (
"io/ioutil"
"net/http"
"os"
"os/exec"
"path/filepath"
"testing"
piperHttp "github.com/SAP/jenkins-library/pkg/http"
"github.com/SAP/jenkins-library/pkg/mock"
FileUtils "github.com/SAP/jenkins-library/pkg/piperutils"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
//TODO: extract to mock package
type mockDownloader struct {
shouldFail bool
requestedURL []string
requestedFile []string
}
func (m *mockDownloader) DownloadFile(url, filename string, header http.Header, cookies []*http.Cookie) error {
m.requestedURL = append(m.requestedURL, url)
m.requestedFile = append(m.requestedFile, filename)
if m.shouldFail {
return errors.New("something happened")
}
return nil
}
func (m *mockDownloader) SetOptions(options piperHttp.ClientOptions) {}
func mockFileUtilsExists(exists bool) func(string) (bool, error) {
return func(filename string) (bool, error) {
if exists {
return true, nil
}
return false, errors.New("something happened")
}
}
func mockExecLookPath(executable string) (string, error) {
if executable == "local-sonar-scanner" {
return "/usr/bin/sonar-scanner", nil
}
return "", errors.New("something happened")
}
func mockFileUtilsUnzip(t *testing.T, expectSrc string) func(string, string) ([]string, error) {
return func(src, dest string) ([]string, error) {
assert.Equal(t, filepath.Join(dest, expectSrc), src)
return []string{}, nil
}
}
func mockOsRename(t *testing.T, expectOld, expectNew string) func(string, string) error {
return func(old, new string) error {
assert.Regexp(t, expectOld, old)
assert.Equal(t, expectNew, new)
return nil
}
}
func createTaskReportFile(t *testing.T, workingDir string) {
require.NoError(t, os.MkdirAll(filepath.Join(workingDir, ".scannerwork"), 0755))
require.NoError(t, ioutil.WriteFile(filepath.Join(workingDir, ".scannerwork", "report-task.txt"), []byte("projectKey=piper-test\nserverUrl=https://sonarcloud.io\nserverVersion=8.0.0.12345\ndashboardUrl=https://sonarcloud.io/dashboard/index/piper-test\nceTaskId=AXERR2JBbm9IiM5TEST\nceTaskUrl=https://sonarcloud.io/api/ce/task?id=AXERR2JBbm9IiMTEST"), 0755))
require.FileExists(t, filepath.Join(workingDir, ".scannerwork", "report-task.txt"))
}
func TestRunSonar(t *testing.T) {
mockRunner := mock.ExecMockRunner{}
mockClient := mockDownloader{shouldFail: false}
t.Run("default", func(t *testing.T) {
// init
tmpFolder, err := ioutil.TempDir(".", "test-sonar-")
require.NoError(t, err)
defer os.RemoveAll(tmpFolder)
createTaskReportFile(t, tmpFolder)
sonar = sonarSettings{
workingDir: tmpFolder,
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
options := sonarExecuteScanOptions{
CustomTLSCertificateLinks: "",
Token: "secret-ABC",
Host: "https://sonar.sap.com",
Organization: "SAP",
ProjectVersion: "1.2.3",
}
fileUtilsExists = mockFileUtilsExists(true)
os.Setenv("PIPER_SONAR_LOAD_CERTIFICATES", "true")
require.Equal(t, "true", os.Getenv("PIPER_SONAR_LOAD_CERTIFICATES"), "PIPER_SONAR_LOAD_CERTIFICATES must be set")
defer func() {
fileUtilsExists = FileUtils.FileExists
os.Unsetenv("PIPER_SONAR_LOAD_CERTIFICATES")
}()
// test
err = runSonar(options, &mockClient, &mockRunner)
// assert
assert.NoError(t, err)
assert.Contains(t, sonar.options, "-Dsonar.projectVersion=1.2.3")
assert.Contains(t, sonar.options, "-Dsonar.organization=SAP")
assert.Contains(t, sonar.environment, "SONAR_HOST_URL=https://sonar.sap.com")
assert.Contains(t, sonar.environment, "SONAR_TOKEN=secret-ABC")
assert.Contains(t, sonar.environment, "SONAR_SCANNER_OPTS=-Djavax.net.ssl.trustStore="+filepath.Join(getWorkingDir(), ".certificates", "cacerts"))
assert.FileExists(t, filepath.Join(sonar.workingDir, "sonarExecuteScan_reports.json"))
assert.FileExists(t, filepath.Join(sonar.workingDir, "sonarExecuteScan_links.json"))
})
t.Run("with custom options", func(t *testing.T) {
// init
tmpFolder, err := ioutil.TempDir(".", "test-sonar-")
require.NoError(t, err)
defer os.RemoveAll(tmpFolder)
createTaskReportFile(t, tmpFolder)
sonar = sonarSettings{
workingDir: tmpFolder,
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
options := sonarExecuteScanOptions{
Options: []string{"-Dsonar.projectKey=piper"},
}
fileUtilsExists = mockFileUtilsExists(true)
defer func() {
fileUtilsExists = FileUtils.FileExists
}()
// test
err = runSonar(options, &mockClient, &mockRunner)
// assert
assert.NoError(t, err)
assert.Contains(t, sonar.options, "-Dsonar.projectKey=piper")
})
}
func TestSonarHandlePullRequest(t *testing.T) {
t.Run("default", func(t *testing.T) {
// init
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
options := sonarExecuteScanOptions{
ChangeID: "123",
PullRequestProvider: "GitHub",
ChangeBranch: "feat/bogus",
ChangeTarget: "master",
Owner: "SAP",
Repository: "jenkins-library",
}
// test
err := handlePullRequest(options)
// assert
assert.NoError(t, err)
assert.Contains(t, sonar.options, "sonar.pullrequest.key=123")
assert.Contains(t, sonar.options, "sonar.pullrequest.provider=github")
assert.Contains(t, sonar.options, "sonar.pullrequest.base=master")
assert.Contains(t, sonar.options, "sonar.pullrequest.branch=feat/bogus")
assert.Contains(t, sonar.options, "sonar.pullrequest.github.repository=SAP/jenkins-library")
})
t.Run("unsupported scm provider", func(t *testing.T) {
// init
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
options := sonarExecuteScanOptions{
ChangeID: "123",
PullRequestProvider: "Gerrit",
}
// test
err := handlePullRequest(options)
// assert
assert.Error(t, err)
assert.Equal(t, "Pull-Request provider 'gerrit' is not supported!", err.Error())
})
t.Run("legacy", func(t *testing.T) {
// init
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
options := sonarExecuteScanOptions{
LegacyPRHandling: true,
ChangeID: "123",
Owner: "SAP",
Repository: "jenkins-library",
GithubToken: "some-token",
DisableInlineComments: true,
}
// test
err := handlePullRequest(options)
// assert
assert.NoError(t, err)
assert.Contains(t, sonar.options, "sonar.analysis.mode=preview")
assert.Contains(t, sonar.options, "sonar.github.pullRequest=123")
assert.Contains(t, sonar.options, "sonar.github.oauth=some-token")
assert.Contains(t, sonar.options, "sonar.github.repository=SAP/jenkins-library")
assert.Contains(t, sonar.options, "sonar.github.disableInlineComments=true")
})
}
func TestSonarLoadScanner(t *testing.T) {
mockClient := mockDownloader{shouldFail: false}
t.Run("use preinstalled sonar-scanner", func(t *testing.T) {
// init
ignore := ""
sonar = sonarSettings{
binary: "local-sonar-scanner",
environment: []string{},
options: []string{},
}
execLookPath = mockExecLookPath
defer func() { execLookPath = exec.LookPath }()
// test
err := loadSonarScanner(ignore, &mockClient)
// assert
assert.NoError(t, err)
assert.Equal(t, "local-sonar-scanner", sonar.binary)
})
t.Run("use downloaded sonar-scanner", func(t *testing.T) {
// init
url := "https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-4.3.0.2102-linux.zip"
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
execLookPath = mockExecLookPath
fileUtilsUnzip = mockFileUtilsUnzip(t, "sonar-scanner-cli-4.3.0.2102-linux.zip")
osRename = mockOsRename(t, "sonar-scanner-4.3.0.2102-linux", ".sonar-scanner")
defer func() {
execLookPath = exec.LookPath
fileUtilsUnzip = FileUtils.Unzip
osRename = os.Rename
}()
// test
err := loadSonarScanner(url, &mockClient)
// assert
assert.NoError(t, err)
assert.Equal(t, url, mockClient.requestedURL[0])
assert.Regexp(t, "sonar-scanner-cli-4.3.0.2102-linux.zip$", mockClient.requestedFile[0])
assert.Equal(t, filepath.Join(getWorkingDir(), ".sonar-scanner", "bin", "sonar-scanner"), sonar.binary)
})
}
func TestSonarLoadCertificates(t *testing.T) {
mockRunner := mock.ExecMockRunner{}
mockClient := mockDownloader{shouldFail: false}
t.Run("use local trust store", func(t *testing.T) {
// init
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
fileUtilsExists = mockFileUtilsExists(true)
defer func() { fileUtilsExists = FileUtils.FileExists }()
// test
err := loadCertificates("", &mockClient, &mockRunner)
// assert
assert.NoError(t, err)
assert.Contains(t, sonar.environment, "SONAR_SCANNER_OPTS=-Djavax.net.ssl.trustStore="+filepath.Join(getWorkingDir(), ".certificates", "cacerts"))
})
t.Run("use local trust store with downloaded certificates", func(t *testing.T) {
// init
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
fileUtilsExists = mockFileUtilsExists(false)
os.Setenv("PIPER_SONAR_LOAD_CERTIFICATES", "true")
require.Equal(t, "true", os.Getenv("PIPER_SONAR_LOAD_CERTIFICATES"), "PIPER_SONAR_LOAD_CERTIFICATES must be set")
defer func() {
fileUtilsExists = FileUtils.FileExists
os.Unsetenv("PIPER_SONAR_LOAD_CERTIFICATES")
}()
// test
err := loadCertificates("https://sap.com/custom-1.crt,https://sap.com/custom-2.crt", &mockClient, &mockRunner)
// assert
assert.NoError(t, err)
assert.Equal(t, "https://sap.com/custom-1.crt", mockClient.requestedURL[0])
assert.Equal(t, "https://sap.com/custom-2.crt", mockClient.requestedURL[1])
assert.Regexp(t, "custom-1.crt$", mockClient.requestedFile[0])
assert.Regexp(t, "custom-2.crt$", mockClient.requestedFile[1])
assert.Contains(t, sonar.environment, "SONAR_SCANNER_OPTS=-Djavax.net.ssl.trustStore="+filepath.Join(getWorkingDir(), ".certificates", "cacerts"))
})
t.Run("use local trust store with downloaded certificates - deactivated", func(t *testing.T) {
// init
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
fileUtilsExists = mockFileUtilsExists(false)
require.Empty(t, os.Getenv("PIPER_SONAR_LOAD_CERTIFICATES"), "PIPER_SONAR_LOAD_CERTIFICATES must not be set")
defer func() { fileUtilsExists = FileUtils.FileExists }()
// test
err := loadCertificates("any-certificate-url", &mockClient, &mockRunner)
// assert
assert.NoError(t, err)
assert.NotContains(t, sonar.environment, "SONAR_SCANNER_OPTS=-Djavax.net.ssl.trustStore="+filepath.Join(getWorkingDir(), ".certificates", "cacerts"))
})
t.Run("use no trust store", func(t *testing.T) {
// init
sonar = sonarSettings{
binary: "sonar-scanner",
environment: []string{},
options: []string{},
}
fileUtilsExists = mockFileUtilsExists(false)
os.Setenv("PIPER_SONAR_LOAD_CERTIFICATES", "true")
require.Equal(t, "true", os.Getenv("PIPER_SONAR_LOAD_CERTIFICATES"), "PIPER_SONAR_LOAD_CERTIFICATES must be set")
defer func() {
fileUtilsExists = FileUtils.FileExists
os.Unsetenv("PIPER_SONAR_LOAD_CERTIFICATES")
}()
// test
err := loadCertificates("", &mockClient, &mockRunner)
// assert
assert.NoError(t, err)
assert.Empty(t, sonar.environment)
})
}
|
[
"\"PIPER_SONAR_LOAD_CERTIFICATES\"",
"\"PIPER_SONAR_LOAD_CERTIFICATES\"",
"\"PIPER_SONAR_LOAD_CERTIFICATES\"",
"\"PIPER_SONAR_LOAD_CERTIFICATES\""
] |
[] |
[
"PIPER_SONAR_LOAD_CERTIFICATES"
] |
[]
|
["PIPER_SONAR_LOAD_CERTIFICATES"]
|
go
| 1 | 0 | |
pkg/ddevapp/providerPantheon.go
|
package ddevapp
import (
"github.com/drud/ddev/pkg/globalconfig"
"io/ioutil"
"os"
"path/filepath"
"strings"
"fmt"
"github.com/drud/ddev/pkg/fileutil"
"github.com/drud/ddev/pkg/output"
"github.com/drud/ddev/pkg/util"
"github.com/drud/go-pantheon/pkg/pantheon"
"gopkg.in/yaml.v2"
)
// PantheonProvider provides pantheon-specific import functionality.
type PantheonProvider struct {
ProviderType string `yaml:"provider"`
app *DdevApp `yaml:"-"`
Sitename string `yaml:"site"`
site pantheon.Site `yaml:"-"`
siteEnvironments pantheon.EnvironmentList `yaml:"-"`
EnvironmentName string `yaml:"environment"`
environment pantheon.Environment `yaml:"-"`
}
// Init handles loading data from saved config.
func (p *PantheonProvider) Init(app *DdevApp) error {
var err error
p.app = app
configPath := app.GetConfigPath("import.yaml")
if fileutil.FileExists(configPath) {
err = p.Read(configPath)
}
p.ProviderType = ProviderPantheon
return err
}
// ValidateField provides field level validation for config settings. This is
// used any time a field is set via `ddev config` on the primary app config, and
// allows provider plugins to have additional validation for top level config
// settings.
func (p *PantheonProvider) ValidateField(field, value string) error {
switch field {
case "Name":
_, err := findPantheonSite(value)
if err != nil {
p.Sitename = value
}
return err
}
return nil
}
// SetSiteNameAndEnv sets the environment of the provider (dev/test/live)
func (p *PantheonProvider) SetSiteNameAndEnv(environment string) {
p.Sitename = p.app.Name
p.EnvironmentName = environment
}
// PromptForConfig provides interactive configuration prompts when running `ddev config pantheon`
func (p *PantheonProvider) PromptForConfig() error {
for {
p.SetSiteNameAndEnv("dev")
err := p.environmentPrompt()
if err == nil {
return nil
}
output.UserOut.Errorf("%v\n", err)
}
}
// GetBackup will download the most recent backup specified by backupType in the given environment. If no environment
// is supplied, the configured environment will be used. Valid values for backupType are "database" or "files".
func (p *PantheonProvider) GetBackup(backupType, environment string) (fileLocation string, importPath string, err error) {
if backupType != "database" && backupType != "files" {
return "", "", fmt.Errorf("could not get backup: %s is not a valid backup type", backupType)
}
// If the user hasn't defined an environment override, use the configured value.
if environment == "" {
environment = p.EnvironmentName
}
// Set the import path blank to use the root of the archive by default.
importPath = ""
err = p.environmentExists(environment)
if err != nil {
return "", "", err
}
session := getPantheonSession()
// Find either a files or database backup, depending on what was asked for.
bl := pantheon.NewBackupList(p.site.ID, environment)
err = session.Request("GET", bl)
if err != nil {
return "", "", err
}
backup, err := p.getPantheonBackupLink(backupType, bl, session, environment)
if err != nil {
return "", "", err
}
p.prepDownloadDir()
destFile := filepath.Join(p.getDownloadDir(), backup.FileName)
// Check to see if this file has been downloaded previously.
// Attempt a new download If we can't stat the file or we get a mismatch on the filesize.
stat, err := os.Stat(destFile)
if err != nil || stat.Size() != int64(backup.Size) {
err = util.DownloadFile(destFile, backup.DownloadURL, true)
if err != nil {
return "", "", err
}
}
if backupType == "files" {
importPath = fmt.Sprintf("files_%s", environment)
}
return destFile, importPath, nil
}
// prepDownloadDir ensures the download cache directories are created and writeable.
func (p *PantheonProvider) prepDownloadDir() {
destDir := p.getDownloadDir()
err := os.MkdirAll(destDir, 0755)
util.CheckErr(err)
}
func (p *PantheonProvider) getDownloadDir() string {
globalDir := globalconfig.GetGlobalDdevDir()
destDir := filepath.Join(globalDir, "pantheon", p.app.Name)
return destDir
}
// getPantheonBackupLink will return a URL for the most recent backyp of archiveType that exist with the BackupList specified.
func (p *PantheonProvider) getPantheonBackupLink(archiveType string, bl *pantheon.BackupList, session *pantheon.AuthSession, environment string) (*pantheon.Backup, error) {
latestBackup := pantheon.Backup{}
for i, backup := range bl.Backups {
if backup.ArchiveType == archiveType && backup.Timestamp > latestBackup.Timestamp {
latestBackup = bl.Backups[i]
}
}
if latestBackup.Timestamp != 0 {
// Get a time-limited backup URL from Pantheon. This requires a POST of the backup type to their API.
err := session.Request("POST", &latestBackup)
if err != nil {
return &pantheon.Backup{}, fmt.Errorf("could not get backup URL: %v", err)
}
return &latestBackup, nil
}
// If no matches were found, just return an empty backup along with an error.
return &pantheon.Backup{}, fmt.Errorf("could not find a backup of type %s. Please visit your pantheon dashboard and ensure the '%s' environment has a backup available", archiveType, environment)
}
// environmentPrompt contains the user prompts for interactive configuration of the pantheon environment.
func (p *PantheonProvider) environmentPrompt() error {
_, err := p.GetEnvironments()
if err != nil {
return err
}
if p.EnvironmentName == "" {
p.EnvironmentName = "dev"
}
fmt.Println("\nConfigure import environment:")
keys := make([]string, 0, len(p.siteEnvironments.Environments))
for k := range p.siteEnvironments.Environments {
keys = append(keys, k)
}
fmt.Println("\n\t- " + strings.Join(keys, "\n\t- ") + "\n")
var environmentPrompt = "Type the name to select an environment to import from"
if p.EnvironmentName != "" {
environmentPrompt = fmt.Sprintf("%s (%s)", environmentPrompt, p.EnvironmentName)
}
fmt.Print(environmentPrompt + ": ")
envName := util.GetInput(p.EnvironmentName)
_, ok := p.siteEnvironments.Environments[envName]
if !ok {
return fmt.Errorf("could not find an environment named '%s'", envName)
}
p.SetSiteNameAndEnv(envName)
return nil
}
// Write the pantheon provider configuration to a spcified location on disk.
func (p *PantheonProvider) Write(configPath string) error {
err := PrepDdevDirectory(filepath.Dir(configPath))
if err != nil {
return err
}
cfgbytes, err := yaml.Marshal(p)
if err != nil {
return err
}
err = ioutil.WriteFile(configPath, cfgbytes, 0644)
if err != nil {
return err
}
return nil
}
// Read pantheon provider configuration from a specified location on disk.
func (p *PantheonProvider) Read(configPath string) error {
source, err := ioutil.ReadFile(configPath)
if err != nil {
return err
}
// Read config values from file.
err = yaml.Unmarshal(source, p)
if err != nil {
return err
}
return nil
}
// GetEnvironments will return a list of environments for the currently configured upstream pantheon site.
func (p *PantheonProvider) GetEnvironments() (pantheon.EnvironmentList, error) {
var el *pantheon.EnvironmentList
// If we've got an already populated environment list, then just use that.
if len(p.siteEnvironments.Environments) > 0 {
return p.siteEnvironments, nil
}
// Otherwise we need to find our environments.
session := getPantheonSession()
if p.site.ID == "" {
site, err := findPantheonSite(p.Sitename)
if err != nil {
return p.siteEnvironments, err
}
p.site = site
}
// Get a list of all active environments for the current site.
el = pantheon.NewEnvironmentList(p.site.ID)
err := session.Request("GET", el)
p.siteEnvironments = *el
return *el, err
}
// Validate ensures that the current configuration is valid (i.e. the configured pantheon site/environment exists)
func (p *PantheonProvider) Validate() error {
return p.environmentExists(p.EnvironmentName)
}
// environmentExists ensures the currently configured pantheon site & environment exists.
func (p *PantheonProvider) environmentExists(environment string) error {
_, err := p.GetEnvironments()
if err != nil {
return err
}
if _, ok := p.siteEnvironments.Environments[environment]; !ok {
return fmt.Errorf("could not find an environment named '%s'", environment)
}
return nil
}
// findPantheonSite ensures the pantheon site specified by name exists, and the current user has access to it.
func findPantheonSite(name string) (pantheon.Site, error) {
session := getPantheonSession()
// Get a list of all sites the current user has access to. Ensure we can find the site which was used in the CLI arguments in that list.
sl := &pantheon.SiteList{}
err := session.Request("GET", sl)
if err != nil {
return pantheon.Site{}, err
}
// Get a list of environments for a given site.
for i, site := range sl.Sites {
if site.Site.Name == name {
return sl.Sites[i], nil
}
}
return pantheon.Site{}, fmt.Errorf("could not find a pantheon site named %s", name)
}
// getPantheonSession loads the pantheon API config from disk and returns a pantheon session struct.
func getPantheonSession() *pantheon.AuthSession {
globalDir := globalconfig.GetGlobalDdevDir()
sessionLocation := filepath.Join(globalDir, "pantheonconfig.json")
// Generate a session object based on the DDEV_PANTHEON_API_TOKEN environment var.
session := &pantheon.AuthSession{}
// Read a previously saved session.
err := session.Read(sessionLocation)
if err != nil {
// If we can't read a previous session fall back to using the API token.
apiToken := os.Getenv("DDEV_PANTHEON_API_TOKEN")
if apiToken == "" {
util.Failed("No saved session could be found and the environment variable DDEV_PANTHEON_API_TOKEN is not set. Please use ddev auth-pantheon or set a DDEV_PANTHEON_API_TOKEN. https://pantheon.io/docs/machine-tokens/ provides instructions on creating a token.")
}
session = pantheon.NewAuthSession(os.Getenv("DDEV_PANTHEON_API_TOKEN"))
}
err = session.Auth()
if err != nil {
output.UserOut.Fatalf("Could not authenticate with pantheon: %v", err)
}
err = session.Write(sessionLocation)
util.CheckErr(err)
return session
}
|
[
"\"DDEV_PANTHEON_API_TOKEN\"",
"\"DDEV_PANTHEON_API_TOKEN\""
] |
[] |
[
"DDEV_PANTHEON_API_TOKEN"
] |
[]
|
["DDEV_PANTHEON_API_TOKEN"]
|
go
| 1 | 0 | |
conf/setting.go
|
package conf
import (
"encoding/json"
"errors"
"fmt"
"os"
"path"
"strings"
"time"
log "github.com/sirupsen/logrus"
"gopkg.in/yaml.v2"
"gonelist/pkg/file"
)
// 服务器设置
type Server struct {
ReadTimeout time.Duration `yaml:"read_timeout"`
WriteTimeout time.Duration `yaml:"write_timeout"`
BindGlobal bool `json:"bind_global" yaml:"bind_global"` // 是否绑定到0.0.0.0
DistPATH string `json:"dist_path" yaml:"dist_path"` // 静态文件目录
Gzip bool `json:"gzip" yaml:"gzip"` // 是否打开 Gzip 加速
Port int `json:"port" yaml:"port"` // 绑定端口
SiteUrl string `json:"site_url" yaml:"site_url"` // 网站网址，如 https://gonelist.cugxuan.cn
}
var defaultServerSetting = &Server{
ReadTimeout: 60,
WriteTimeout: 60,
BindGlobal: true,
DistPATH: "./dist/",
Port: 8000,
Gzip: true,
SiteUrl: "https://gonelist.cugxuan.cn",
}
type Admin struct {
EnableWrite bool `json:"enable_write" yaml:"enable_write"` // 是否允许客户端写入文件到onedrive服务端，写入包括创建文件夹，上传文件，删除文件
Secret string `json:"secret" yaml:"secret"` // 写入权限的secret，前端升级权限时需要，建议更改默认secret
UploadSliceSize int `json:"upload_slice_size" yaml:"upload_slice_size"` // 大文件分片上传时得分片大小，默认为32MB,数字为1表示320kb
}
// Local
// 本地目录挂载配置
type Local struct {
Enable bool `json:"enable" yaml:"enable"` // 是否开启本地挂载
Name string `json:"name" yaml:"name"` // 本地挂载的目录在gonelist中显示的名称
Path string `json:"path" yaml:"path"` // 本地挂载目录的路径
}
type Onedrive struct {
// Remote to load RemoteConf
Remote string `json:"remote" yaml:"remote"`
RemoteConf Remote `json:"-" yaml:"-"`
// 刷新模式
Model string `json:"model" yaml:"model"` // 刷新模式
Level int `json:"level" yaml:"level"` // 刷新层级
RefreshTime int `json:"refresh_time" yaml:"refresh_time"` // 自动刷新时间，单位为分钟
// 获取授权代码
ResponseType string `json:"-" yaml:"-"` // 值为 code
ClientID string `json:"client_id" yaml:"client_id"`
RedirectURL string `json:"redirect_url" yaml:"redirect_url"`
State string `json:"state" yaml:"state"` // 用户设置的标识
// 获取 access_token
ClientSecret string `json:"client_secret" yaml:"client_secret"`
Code string `json:"-" yaml:"-"` // 服务器收到的中间内容
GrantType string `json:"-" yaml:"-"` // 值为 authorization_code
Scope string `json:"-" yaml:"-"` // 值为 offline_access files.readwrite.all
AccessToken string `json:"-" yaml:"-"` // 令牌
RefreshToken string `json:"-" yaml:"-"` // 刷新令牌
TokenPath string `json:"token_path" yaml:"token_path"` // token 文件位置
// 其他设置
FolderSub string `json:"folder_sub" yaml:"folder_sub"` // onedrive 的子文件夹
DownloadRedirectPrefix string `json:"download_redirect_prefix" yaml:"download_redirect_prefix"` // 下载重定向前缀
// 目录密码
PassList []*Pass `json:"pass_list" yaml:"pass_list"`
}
// 用户信息设置
type AllSet struct {
Name string `json:"name" yaml:"name"`
PageTitle string `json:"page_title" yaml:"page_title"`
Version string `json:"version" yaml:"version"`
// Server 配置，用于定义服务的特性
Server *Server `json:"server" yaml:"server"`
// 网盘挂载类型
ListType string `json:"list_type" yaml:"list_type"`
// Onedrive
Onedrive *Onedrive `json:"onedrive" yaml:"onedrive"`
// 权限管理
Admin *Admin `json:"admin" yaml:"admin"`
// 本地目录挂载
Local *Local `json:"local" yaml:"local"`
}
var UserSet = &AllSet{}
func LoadUserConfig(configPath string) error {
var (
content []byte
err error
)
if len(configPath) == 0 {
return errors.New("配置文件名不能为空")
}
envValue := os.Getenv("CONF_PATH")
if envValue != "" {
configPath = envValue
}
log.Infof("当前使用的配置文件为:%s", configPath)
if content, err = file.ReadFromFile(configPath); err != nil {
return fmt.Errorf("read config err,path: %s", configPath)
}
err = yaml.Unmarshal(content, &UserSet)
if err != nil {
return fmt.Errorf("导入用户配置出现错误: %w", err)
}
// Server 的设置
if UserSet.Server == nil {
return fmt.Errorf("Server 设置读取出现错误")
}
switch UserSet.ListType {
case "onedrive":
// 处理 Remote 地址
switch UserSet.Onedrive.Remote {
case "onedrive":
UserSet.Onedrive.RemoteConf = OneDrive
case "chinacloud":
UserSet.Onedrive.RemoteConf = ChinaCloud
}
// PassList 设置
if UserSet.Onedrive.FolderSub == "" {
UserSet.Onedrive.FolderSub = "/"
}
if UserSet.Onedrive.PassList == nil {
UserSet.Onedrive.PassList = defaultPassListSetting
}
// TokenPath 不为 ""，token 保存在用户设置的目录
// 否则 token 将保存在用户 config.yml 所在的目录
if UserSet.Onedrive.TokenPath == "" {
UserSet.Onedrive.TokenPath = GetTokenPath(configPath)
} else {
// 用户一般写目录，此处转成文件
if !strings.HasSuffix(UserSet.Onedrive.TokenPath, ".token") {
UserSet.Onedrive.TokenPath = path.Join(UserSet.Onedrive.TokenPath, ".token")
}
}
// 设置大文件上传的分片
if UserSet.Admin.UploadSliceSize == 0 {
UserSet.Admin.UploadSliceSize = 100
}
default:
return fmt.Errorf("不支持的网盘挂载类型")
}
setting, _ := json.Marshal(UserSet)
log.Infof("gonelist 监听端口:%v,成功导入用户配置:%+v", UserSet.Server.Port, string(setting))
return nil
}
// return the refresh time from the settings
func GetRefreshTime() time.Duration {
return time.Duration(UserSet.Onedrive.RefreshTime) * time.Minute
}
func GetBindAddr(bind bool, port int) string {
var prefix string
if bind == false {
prefix = "127.0.0.1"
}
return fmt.Sprintf("%s:%d", prefix, port)
}
func GetDistPATH() string {
return UserSet.Server.DistPATH
}
func GetTokenPath(configPath string) string {
lastIndex := strings.LastIndex(configPath, string(os.PathSeparator))
return configPath[:lastIndex+1] + ".token"
}
type Pass struct {
Path string `json:"path"`
Pass string `json:"pass"`
}
var defaultPassListSetting = []*Pass{
{
Path: "",
Pass: "",
},
}
|
[
"\"CONF_PATH\""
] |
[] |
[
"CONF_PATH"
] |
[]
|
["CONF_PATH"]
|
go
| 1 | 0 | |
notebooks/util.py
|
import os
import time
from collections.abc import Iterable
import cftime
import dask
import intake
import numpy as np
import xarray as xr
import yaml
from dask.distributed import Client
from dask_jobqueue import PBSCluster
path_to_here = os.path.dirname(os.path.realpath(__file__))
USER = os.environ['USER']
PBS_PROJECT = 'NCGD0011'
def attrs_label(attrs):
"""generate a label from long_name and units"""
da_name = ''
if isinstance(attrs, xr.DataArray):
da_name = attrs.name
attrs = attrs.attrs
name = da_name if 'long_name' not in attrs else attrs['long_name']
if len(name) > 30:
name = '\n'.join([name[:30], name[30:]])
units = '' if 'units' not in attrs else f' [{attrs["units"]}]'
return name + units
def label_plots(fig, axs, xoff=-0.04, yoff=0.02):
alp = [chr(i).upper() for i in range(97, 97 + 26)]
for i, ax in enumerate(axs):
p = ax.get_position()
x = p.x0 + xoff
y = p.y1 + yoff
fig.text(x, y, f'{alp[i]}', fontsize=14, fontweight='semibold')
def get_ClusterClient(memory='25GB'):
"""get cluster and client"""
cluster = PBSCluster(
cores=1,
memory=memory,
processes=1,
queue='casper',
local_directory=f'/glade/scratch/{USER}/dask-workers',
log_directory=f'/glade/scratch/{USER}/dask-workers',
resource_spec=f'select=1:ncpus=1:mem={memory}',
project=PBS_PROJECT,
walltime='06:00:00',
interface='ib0',
)
jupyterhub_server_name = os.environ.get('JUPYTERHUB_SERVER_NAME', None)
dashboard_link = 'https://jupyterhub.hpc.ucar.edu/stable/user/{USER}/proxy/{port}/status'
if jupyterhub_server_name:
dashboard_link = (
'https://jupyterhub.hpc.ucar.edu/stable/user/'
+ '{USER}'
+ f'/{jupyterhub_server_name}/proxy/'
+ '{port}/status'
)
dask.config.set({'distributed.dashboard.link': dashboard_link})
client = Client(cluster)
return cluster, client
class timer(object):
"""support reporting timing info with named tasks"""
def __init__(self, name=None):
self.name = name
def __enter__(self):
self.tic = time.time()
def __exit__(self, type, value, traceback):
if self.name:
print(f'[{self.name}]: ', end='')
toc = time.time() - self.tic
print(f'{toc:0.5f}s')
def to_datenum(y, m, d, time_units='days since 0001-01-01 00:00:00'):
"""convert year, month, day to number"""
return cftime.date2num(cftime.datetime(y, m, d), units=time_units)
def nday_per_year(year):
return 365
def year_frac(time):
"""compute year fraction"""
year = [d.year for d in time.values]
month = [d.month for d in time.values]
day = [d.day for d in time.values]
t0_year = np.array([to_datenum(y, 1, 1) - 1 for y in year])
t_year = np.array([to_datenum(y, m, d) for y, m, d in zip(year, month, day)])
nday_year = np.array([nday_per_year(y) for y in year])
return year + (t_year - t0_year) / nday_year
def pop_add_cyclic(ds):
"""Make POP grid easily plottable"""
ni = ds.TLONG.shape[1]
xL = int(ni / 2 - 1)
xR = int(xL + ni)
tlon = ds.TLONG.data
tlat = ds.TLAT.data
tlon = np.where(np.greater_equal(tlon, min(tlon[:, 0])), tlon - 360.0, tlon)
lon = np.concatenate((tlon, tlon + 360.0), 1)
lon = lon[:, xL:xR]
if ni == 320:
lon[367:-3, 0] = lon[367:-3, 0] + 360.0
lon = lon - 360.0
lon = np.hstack((lon, lon[:, 0:1] + 360.0))
if ni == 320:
lon[367:, -1] = lon[367:, -1] - 360.0
# -- trick cartopy into doing the right thing:
# it gets confused when the cyclic coords are identical
lon[:, 0] = lon[:, 0] - 1e-8
# -- periodicity
lat = np.concatenate((tlat, tlat), 1)
lat = lat[:, xL:xR]
lat = np.hstack((lat, lat[:, 0:1]))
TLAT = xr.DataArray(lat, dims=('nlat', 'nlon'))
TLONG = xr.DataArray(lon, dims=('nlat', 'nlon'))
dso = xr.Dataset({'TLAT': TLAT, 'TLONG': TLONG})
# copy vars
varlist = [v for v in ds.data_vars if v not in ['TLAT', 'TLONG']]
for v in varlist:
v_dims = ds[v].dims
if not ('nlat' in v_dims and 'nlon' in v_dims):
dso[v] = ds[v]
else:
# determine and sort other dimensions
other_dims = set(v_dims) - {'nlat', 'nlon'}
other_dims = tuple([d for d in v_dims if d in other_dims])
lon_dim = ds[v].dims.index('nlon')
field = ds[v].data
field = np.concatenate((field, field), lon_dim)
field = field[..., :, xL:xR]
field = np.concatenate((field, field[..., :, 0:1]), lon_dim)
dso[v] = xr.DataArray(field, dims=other_dims + ('nlat', 'nlon'), attrs=ds[v].attrs)
# copy coords
for v, da in ds.coords.items():
if not ('nlat' in da.dims and 'nlon' in da.dims):
dso = dso.assign_coords(**{v: da})
return dso
class curator_local_assets(object):
"""Curate an intake catalog with locally-cached assets"""
def __init__(self):
cache_dir = 'data/cache'
os.makedirs(cache_dir, exist_ok=True)
self.catalog_file = f'{path_to_here}/data/catalogs/catalog-local.yml'
if os.path.exists(self.catalog_file):
with open(self.catalog_file, 'r') as fid:
self.catalog = yaml.safe_load(fid)
else:
self.catalog = yaml.safe_load(
"""
description: Local assets
plugins:
source:
- module: intake_xarray
sources: {}
"""
)
def add_source(self, key, urlpath, description, driver='netcdf', overwrite=False, **kwargs):
"""add a new source to the catalog"""
if key in self.catalog['sources']:
if not overwrite:
raise ValueError(f'source {key} exists; set `overwrite` to true to overwrite')
else:
print(f'overwriting "{key}" key in "sources"')
args = dict(urlpath=urlpath)
args.update(kwargs)
self.catalog['sources'][key] = dict(
driver=driver,
description=description,
args=args,
)
self.persist()
def persist(self):
"""write the catalog to disk"""
with open(self.catalog_file, 'w') as fid:
yaml.dump(self.catalog, fid)
def open_catalog(self):
"""return as intake catalog"""
return intake.open_catalog(self.catalog_file)
def __repr__(self):
return self.catalog.__repr__()
def infer_lat_name(ds):
lat_names = ['latitude', 'lat']
for n in lat_names:
if n in ds:
return n
raise ValueError('could not determine lat name')
def infer_lon_name(ds):
lon_names = ['longitude', 'lon']
for n in lon_names:
if n in ds:
return n
raise ValueError('could not determine lon name')
def lat_weights_regular_grid(lat):
"""
Generate latitude weights for equally spaced (regular) global grids.
Weights are computed as sin(lat+dlat/2)-sin(lat-dlat/2) and sum to 2.0.
"""
dlat = np.abs(np.diff(lat))
np.testing.assert_almost_equal(dlat, dlat[0])
w = np.abs(np.sin(np.radians(lat + dlat[0] / 2.0)) - np.sin(np.radians(lat - dlat[0] / 2.0)))
if np.abs(lat[0]) > 89.9999:
w[0] = np.abs(1.0 - np.sin(np.radians(np.pi / 2 - dlat[0])))
if np.abs(lat[-1]) > 89.9999:
w[-1] = np.abs(1.0 - np.sin(np.radians(np.pi / 2 - dlat[0])))
return w
def compute_grid_area(ds, check_total=True):
"""Compute the area of grid cells.
Parameters
----------
ds : xarray.Dataset
Input dataset with latitude and longitude fields
check_total : Boolean, optional
Test that total area is equal to area of the sphere.
Returns
-------
area : xarray.DataArray
DataArray with area field.
"""
radius_earth = 6.37122e6 # m, radius of Earth
area_earth = 4.0 * np.pi * radius_earth ** 2 # area of earth [m^2]e
lon_name = infer_lon_name(ds)
lat_name = infer_lat_name(ds)
weights = lat_weights_regular_grid(ds[lat_name])
area = weights + 0.0 * ds[lon_name] # add 'lon' dimension
area = (area_earth / area.sum(dim=(lat_name, lon_name))) * area
if check_total:
np.testing.assert_approx_equal(np.sum(area), area_earth)
return xr.DataArray(
area, dims=(lat_name, lon_name), attrs={'units': 'm^2', 'long_name': 'area'}
)
|
[] |
[] |
[
"USER",
"JUPYTERHUB_SERVER_NAME"
] |
[]
|
["USER", "JUPYTERHUB_SERVER_NAME"]
|
python
| 2 | 0 | |
helper/config.py
|
"""
Responsible for reading in configuration files, validating the proper
format and providing sane defaults for parts that don't have any.
"""
import json
import logging
import logging.config
import os
from os import path
import sys
try:
from urllib import parse
except ImportError: # Python 2.7 support
import urlparse as parse
import flatdict
import yaml
LOGGER = logging.getLogger(__name__)
APPLICATION = {'wake_interval': 60}
DAEMON = {'user': None,
'group': None,
'pidfile': None,
'prevent_core': True}
LOGGING_FORMAT = ('%(levelname) -10s %(asctime)s %(process)-6d '
'%(processName) -20s %(threadName)-12s %(name) -30s '
'%(funcName) -25s L%(lineno)-6d: %(message)s')
LOGGING = {
'disable_existing_loggers': True,
'filters': {},
'formatters': {
'verbose': {
'datefmt': '%Y-%m-%d %H:%M:%S',
'format': LOGGING_FORMAT
}
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'formatter': 'verbose'
},
'root': {
'class': 'logging.StreamHandler',
'formatter': 'verbose',
'level': logging.CRITICAL
}
},
'incremental': False,
'loggers': {},
'root': {
'handlers': ['root']
},
'version': 1}
class Config(object):
"""The Config object holds the current state of the configuration for an
application. If no configuration file is provided, it will used a set of
defaults with very basic behavior for logging and daemonization.
"""
def __init__(self, file_path=None):
"""Create a new instance of the configuration object, passing in the
path to the configuration file.
:param str file_path: The path to the configuration file
:raises: ValueError
"""
self._values = self._default_configuration()
self._file_path = self._normalize_file_path(file_path)
if self._file_path:
self._values.update(self._load_config_file())
def get(self, name, default=None):
"""Return the value for key if key is in the configuration, else default.
:param str name: The key name to return
:param mixed default: The default value for the key
:return: mixed
"""
return self._values.get(name, default)
@property
def application(self):
return self._values['Application'].as_dict()
@property
def daemon(self):
return self._values['Daemon'].as_dict()
@property
def logging(self):
return self._values['Logging'].as_dict()
def reload(self):
"""Reload the configuration from disk returning True if the
configuration has changed from the previous values.
"""
config = self._default_configuration()
if self._file_path:
config.update(self._load_config_file())
if config != self._values:
self._values = config
return True
return False
@staticmethod
def _default_configuration():
"""Return the default configuration for Helper
:rtype: dict
"""
return flatdict.FlatDict({
'Application': APPLICATION,
'Daemon': DAEMON,
'Logging': LOGGING
})
def _load_config_file(self):
"""Load the configuration file into memory, returning the content.
"""
LOGGER.info('Loading configuration from %s', self._file_path)
if self._file_path.endswith('json'):
config = self._load_json_config()
else:
config = self._load_yaml_config()
for key, value in [(k, v) for k, v in config.items()]:
if key.title() != key:
config[key.title()] = value
del config[key]
return flatdict.FlatDict(config)
def _load_json_config(self):
"""Load the configuration file in JSON format
:rtype: dict
"""
try:
return json.loads(self._read_config())
except ValueError as error:
raise ValueError(
'Could not read configuration file: {}'.format(error))
def _load_yaml_config(self):
"""Loads the configuration file from a .yaml or .yml file
:type: dict
"""
try:
config = self._read_config()
except OSError as error:
raise ValueError('Could not read configuration file: %s' % error)
try:
return yaml.safe_load(config)
except yaml.YAMLError as error:
message = '\n'.join([' > %s' % line
for line in str(error).split('\n')])
sys.stderr.write('\n\n Error in the configuration file:\n\n'
'{}\n\n'.format(message))
sys.stderr.write(' Configuration should be a valid YAML file.\n')
sys.stderr.write(' YAML format validation available at '
'http://yamllint.com\n')
raise ValueError(error)
@staticmethod
def _normalize_file_path(file_path):
"""Normalize the file path value.
:param str file_path: The file path as passed in
:rtype: str
"""
if not file_path:
return None
elif file_path.startswith('s3://') or \
file_path.startswith('http://') or \
file_path.startswith('https://'):
return file_path
return path.abspath(file_path)
def _read_config(self):
"""Read the configuration from the various places it may be read from.
:rtype: str
:raises: ValueError
"""
if not self._file_path:
return None
elif self._file_path.startswith('s3://'):
return self._read_s3_config()
elif self._file_path.startswith('http://') or \
self._file_path.startswith('https://'):
return self._read_remote_config()
elif not path.exists(self._file_path):
raise ValueError(
'Configuration file not found: {}'.format(self._file_path))
with open(self._file_path, 'r') as handle:
return handle.read()
def _read_remote_config(self):
"""Read a remote config via URL.
:rtype: str
:raises: ValueError
"""
try:
import requests
except ImportError:
requests = None
if not requests:
raise ValueError(
'Remote config URL specified but requests not installed')
result = requests.get(self._file_path)
if not result.ok:
raise ValueError(
'Failed to retrieve remote config: {}'.format(
result.status_code))
return result.text
def _read_s3_config(self):
"""Read in the value of the configuration file in Amazon S3.
:rtype: str
:raises: ValueError
"""
try:
import boto3
import botocore.exceptions
except ImportError:
boto3, botocore = None, None
if not boto3:
raise ValueError(
's3 URL specified for configuration but boto3 not installed')
parsed = parse.urlparse(self._file_path)
try:
response = boto3.client(
's3', endpoint_url=os.environ.get('S3_ENDPOINT')).get_object(
Bucket=parsed.netloc, Key=parsed.path.lstrip('/'))
except botocore.exceptions.ClientError as e:
raise ValueError(
'Failed to download configuration from S3: {}'.format(e))
return response['Body'].read().decode('utf-8')
class LoggingConfig(object):
"""The Logging class is used for abstracting away dictConfig logging
semantics and can be used by sub-processes to ensure consistent logging
rule application.
"""
DEBUG_ONLY = 'debug_only'
HANDLERS = 'handlers'
LOGGERS = 'loggers'
def __init__(self, configuration, debug=None):
"""Create a new instance of the Logging object passing in the
DictConfig syntax logging configuration and a debug flag.
:param dict configuration: The logging configuration
:param bool debug: Toggles use of debug_only loggers
"""
# Force a NullLogger for some libraries that require it
root_logger = logging.getLogger()
root_logger.addHandler(logging.NullHandler())
self.config = dict(configuration)
self.debug = debug
self.configure()
def update(self, configuration, debug=None):
"""Update the internal configuration values, removing debug_only
handlers if debug is False. Returns True if the configuration has
changed from previous configuration values.
:param dict configuration: The logging configuration
:param bool debug: Toggles use of debug_only loggers
:rtype: bool
"""
if self.config != dict(configuration) and debug != self.debug:
self.config = dict(configuration)
self.debug = debug
self.configure()
return True
return False
def configure(self):
"""Configure the Python stdlib logger"""
if self.debug is not None and not self.debug:
self._remove_debug_handlers()
self._remove_debug_only()
logging.config.dictConfig(self.config)
try:
logging.captureWarnings(True)
except AttributeError:
pass
def _remove_debug_handlers(self):
"""Remove any handlers with an attribute of debug_only that is True and
remove the references to said handlers from any loggers that are
referencing them.
"""
remove = list()
for handler in self.config[self.HANDLERS]:
if self.config[self.HANDLERS][handler].get('debug_only'):
remove.append(handler)
for handler in remove:
del self.config[self.HANDLERS][handler]
for logger in self.config[self.LOGGERS].keys():
logger = self.config[self.LOGGERS][logger]
if handler in logger[self.HANDLERS]:
logger[self.HANDLERS].remove(handler)
self._remove_debug_only()
def _remove_debug_only(self):
"""Iterate through each handler removing the invalid dictConfig key of
debug_only.
"""
LOGGER.debug('Removing debug only from handlers')
for handler in self.config[self.HANDLERS]:
if self.DEBUG_ONLY in self.config[self.HANDLERS][handler]:
del self.config[self.HANDLERS][handler][self.DEBUG_ONLY]
|
[] |
[] |
[
"S3_ENDPOINT"
] |
[]
|
["S3_ENDPOINT"]
|
python
| 1 | 0 | |
flash/text/seq2seq/core/model.py
|
# Copyright The PyTorch Lightning team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import warnings
from typing import Any, Callable, List, Mapping, Optional, Sequence, Type, Union
import pytorch_lightning as pl
import torch
from pytorch_lightning.utilities import rank_zero_info
from torch import Tensor
from flash.core.finetuning import FlashBaseFinetuning
from flash.core.model import Task
from flash.core.utilities.imports import _TEXT_AVAILABLE
from flash.text.seq2seq.core.finetuning import Seq2SeqFreezeEmbeddings
if _TEXT_AVAILABLE:
from transformers import AutoModelForSeq2SeqLM, PreTrainedTokenizerBase
else:
AutoModelForSeq2SeqLM, PreTrainedTokenizerBase = None, None
def _pad_tensors_to_max_len(model_cfg, tensor, max_length):
pad_token_id = model_cfg.pad_token_id if model_cfg.pad_token_id else model_cfg.eos_token_id
if pad_token_id is None:
raise ValueError(
f"Make sure that either `config.pad_token_id` or `config.eos_token_id` "
f"is defined if tensor has to be padded to `max_length`={max_length}"
)
padded_tensor = pad_token_id * torch.ones((tensor.shape[0], max_length), dtype=tensor.dtype, device=tensor.device)
padded_tensor[:, :tensor.shape[-1]] = tensor
return padded_tensor
class Seq2SeqTask(Task):
"""General Task for Sequence2Sequence.
Args:
loss_fn: Loss function for training
optimizer: Optimizer to use for training, defaults to `torch.optim.Adam`.
metrics: Metrics to compute for training and evaluation.
learning_rate: Learning rate to use for training, defaults to `3e-4`
val_target_max_length: Maximum length of targets in validation. Defaults to `128`
num_beams: Number of beams to use in validation when generating predictions. Defaults to `4`
"""
def __init__(
self,
backbone: str = 't5-small',
loss_fn: Optional[Union[Callable, Mapping, Sequence]] = None,
optimizer: Type[torch.optim.Optimizer] = torch.optim.Adam,
metrics: Union[pl.metrics.Metric, Mapping, Sequence, None] = None,
learning_rate: float = 5e-5,
val_target_max_length: Optional[int] = None,
num_beams: Optional[int] = None,
):
if not _TEXT_AVAILABLE:
raise ModuleNotFoundError("Please, pip install 'lightning-flash[text]'")
os.environ["TOKENIZERS_PARALLELISM"] = "TRUE"
# disable HF thousand warnings
warnings.simplefilter("ignore")
# set os environ variable for multiprocesses
os.environ["PYTHONWARNINGS"] = "ignore"
super().__init__(loss_fn=loss_fn, optimizer=optimizer, metrics=metrics, learning_rate=learning_rate)
self.model = AutoModelForSeq2SeqLM.from_pretrained(backbone)
self.val_target_max_length = val_target_max_length
self.num_beams = num_beams
self._initialize_model_specific_parameters()
def forward(self, x: Any) -> Any:
max_length = self.val_target_max_length if self.val_target_max_length else self.model.config.max_length
num_beams = self.num_beams if self.num_beams else self.model.config.num_beams
generated_tokens = self.model.generate(
input_ids=x['input_ids'], attention_mask=x['attention_mask'], max_length=max_length, num_beams=num_beams
)
# in case the batch is shorter than max length, the output should be padded
if generated_tokens.shape[-1] < max_length:
generated_tokens = _pad_tensors_to_max_len(
model_cfg=self.model.config, tensor=generated_tokens, max_length=max_length
)
return generated_tokens
def training_step(self, batch: Any, batch_idx: int) -> Tensor:
outputs = self.model(**batch)
loss = outputs[0]
self.log("train_loss", loss)
return loss
def common_step(self, prefix: str, batch: Any) -> torch.Tensor:
generated_tokens = self(batch)
self.compute_metrics(generated_tokens, batch, prefix)
def validation_step(self, batch: Any, batch_idx: int, dataloader_idx: int = 0):
self.common_step("val", batch)
def test_step(self, batch: Any, batch_idx: int, dataloader_idx: int = 0):
self.common_step("test", batch)
def compute_metrics(self, generated_tokens, batch, prefix):
pass
@property
def task(self) -> Optional[str]:
"""
Override to define AutoConfig task specific parameters stored within the model.
"""
return
def _initialize_model_specific_parameters(self):
task_specific_params = self.model.config.task_specific_params
if task_specific_params:
pars = task_specific_params.get(self.task, {})
rank_zero_info(f"Overriding model paramameters for {self.task} as defined within the model:\n {pars}")
self.model.config.update(pars)
@property
def tokenizer(self) -> 'PreTrainedTokenizerBase':
return self.data_pipeline.data_source.tokenizer
def tokenize_labels(self, labels: Tensor) -> List[str]:
label_str = self.tokenizer.batch_decode(labels, skip_special_tokens=True)
return [str.strip(s) for s in label_str]
def configure_finetune_callback(self) -> List[FlashBaseFinetuning]:
return [Seq2SeqFreezeEmbeddings(self.model.config.model_type, train_bn=True)]
|
[] |
[] |
[
"PYTHONWARNINGS",
"TOKENIZERS_PARALLELISM"
] |
[]
|
["PYTHONWARNINGS", "TOKENIZERS_PARALLELISM"]
|
python
| 2 | 0 | |
github/client.go
|
package github
import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"github.com/github/hub/version"
)
const (
GitHubHost string = "github.com"
GitHubApiHost string = "api.github.com"
OAuthAppURL string = "http://hub.github.com/"
)
var UserAgent = "Hub " + version.Version
func NewClient(h string) *Client {
return NewClientWithHost(&Host{Host: h})
}
func NewClientWithHost(host *Host) *Client {
return &Client{host}
}
type Client struct {
Host *Host
}
func (client *Client) FetchPullRequests(project *Project, filterParams map[string]interface{}, limit int, filter func(*PullRequest) bool) (pulls []PullRequest, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
path := fmt.Sprintf("repos/%s/%s/pulls?per_page=%d", project.Owner, project.Name, perPage(limit, 100))
if filterParams != nil {
query := url.Values{}
for key, value := range filterParams {
switch v := value.(type) {
case string:
query.Add(key, v)
}
}
path += "&" + query.Encode()
}
pulls = []PullRequest{}
var res *simpleResponse
for path != "" {
res, err = api.Get(path)
if err = checkStatus(200, "fetching pull requests", res, err); err != nil {
return
}
path = res.Link("next")
pullsPage := []PullRequest{}
if err = res.Unmarshal(&pullsPage); err != nil {
return
}
for _, pr := range pullsPage {
if filter == nil || filter(&pr) {
pulls = append(pulls, pr)
if limit > 0 && len(pulls) == limit {
path = ""
break
}
}
}
}
return
}
func (client *Client) PullRequest(project *Project, id string) (pr *PullRequest, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.Get(fmt.Sprintf("repos/%s/%s/pulls/%s", project.Owner, project.Name, id))
if err = checkStatus(200, "getting pull request", res, err); err != nil {
return
}
pr = &PullRequest{}
err = res.Unmarshal(pr)
return
}
func (client *Client) PullRequestPatch(project *Project, id string) (patch io.ReadCloser, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.GetFile(fmt.Sprintf("repos/%s/%s/pulls/%s", project.Owner, project.Name, id), patchMediaType)
if err = checkStatus(200, "getting pull request patch", res, err); err != nil {
return
}
return res.Body, nil
}
func (client *Client) CreatePullRequest(project *Project, params map[string]interface{}) (pr *PullRequest, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PostJSON(fmt.Sprintf("repos/%s/%s/pulls", project.Owner, project.Name), params)
if err = checkStatus(201, "creating pull request", res, err); err != nil {
if res != nil && res.StatusCode == 404 {
projectUrl := strings.SplitN(project.WebURL("", "", ""), "://", 2)[1]
err = fmt.Errorf("%s\nAre you sure that %s exists?", err, projectUrl)
}
return
}
pr = &PullRequest{}
err = res.Unmarshal(pr)
return
}
func (client *Client) RequestReview(project *Project, prNumber int, params map[string]interface{}) (err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PostJSON(fmt.Sprintf("repos/%s/%s/pulls/%d/requested_reviewers", project.Owner, project.Name, prNumber), params)
if err = checkStatus(201, "requesting reviewer", res, err); err != nil {
return
}
res.Body.Close()
return
}
func (client *Client) CommitPatch(project *Project, sha string) (patch io.ReadCloser, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.GetFile(fmt.Sprintf("repos/%s/%s/commits/%s", project.Owner, project.Name, sha), patchMediaType)
if err = checkStatus(200, "getting commit patch", res, err); err != nil {
return
}
return res.Body, nil
}
type Gist struct {
Files map[string]GistFile `json:"files"`
}
type GistFile struct {
RawUrl string `json:"raw_url"`
}
func (client *Client) GistPatch(id string) (patch io.ReadCloser, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.Get(fmt.Sprintf("gists/%s", id))
if err = checkStatus(200, "getting gist patch", res, err); err != nil {
return
}
gist := Gist{}
if err = res.Unmarshal(&gist); err != nil {
return
}
rawUrl := ""
for _, file := range gist.Files {
rawUrl = file.RawUrl
break
}
res, err = api.GetFile(rawUrl, textMediaType)
if err = checkStatus(200, "getting gist patch", res, err); err != nil {
return
}
return res.Body, nil
}
func (client *Client) Repository(project *Project) (repo *Repository, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.Get(fmt.Sprintf("repos/%s/%s", project.Owner, project.Name))
if err = checkStatus(200, "getting repository info", res, err); err != nil {
return
}
repo = &Repository{}
err = res.Unmarshal(&repo)
return
}
func (client *Client) CreateRepository(project *Project, description, homepage string, isPrivate bool) (repo *Repository, err error) {
repoURL := "user/repos"
if project.Owner != client.Host.User {
repoURL = fmt.Sprintf("orgs/%s/repos", project.Owner)
}
params := map[string]interface{}{
"name": project.Name,
"description": description,
"homepage": homepage,
"private": isPrivate,
}
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PostJSON(repoURL, params)
if err = checkStatus(201, "creating repository", res, err); err != nil {
return
}
repo = &Repository{}
err = res.Unmarshal(repo)
return
}
func (client *Client) DeleteRepository(project *Project) error {
api, err := client.simpleApi()
if err != nil {
return err
}
repoURL := fmt.Sprintf("repos/%s/%s", project.Owner, project.Name)
res, err := api.Delete(repoURL)
return checkStatus(204, "deleting repository", res, err)
}
type Release struct {
Name string `json:"name"`
TagName string `json:"tag_name"`
TargetCommitish string `json:"target_commitish"`
Body string `json:"body"`
Draft bool `json:"draft"`
Prerelease bool `json:"prerelease"`
Assets []ReleaseAsset `json:"assets"`
TarballUrl string `json:"tarball_url"`
ZipballUrl string `json:"zipball_url"`
HtmlUrl string `json:"html_url"`
UploadUrl string `json:"upload_url"`
ApiUrl string `json:"url"`
CreatedAt time.Time `json:"created_at"`
PublishedAt time.Time `json:"published_at"`
}
type ReleaseAsset struct {
Name string `json:"name"`
Label string `json:"label"`
DownloadUrl string `json:"browser_download_url"`
ApiUrl string `json:"url"`
}
func (client *Client) FetchReleases(project *Project, limit int, filter func(*Release) bool) (releases []Release, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
path := fmt.Sprintf("repos/%s/%s/releases?per_page=%d", project.Owner, project.Name, perPage(limit, 100))
releases = []Release{}
var res *simpleResponse
for path != "" {
res, err = api.Get(path)
if err = checkStatus(200, "fetching releases", res, err); err != nil {
return
}
path = res.Link("next")
releasesPage := []Release{}
if err = res.Unmarshal(&releasesPage); err != nil {
return
}
for _, release := range releasesPage {
if filter == nil || filter(&release) {
releases = append(releases, release)
if limit > 0 && len(releases) == limit {
path = ""
break
}
}
}
}
return
}
func (client *Client) FetchRelease(project *Project, tagName string) (*Release, error) {
releases, err := client.FetchReleases(project, 100, func(release *Release) bool {
return release.TagName == tagName
})
if err == nil {
if len(releases) < 1 {
return nil, fmt.Errorf("Unable to find release with tag name `%s'", tagName)
} else {
return &releases[0], nil
}
} else {
return nil, err
}
}
func (client *Client) CreateRelease(project *Project, releaseParams *Release) (release *Release, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PostJSON(fmt.Sprintf("repos/%s/%s/releases", project.Owner, project.Name), releaseParams)
if err = checkStatus(201, "creating release", res, err); err != nil {
return
}
release = &Release{}
err = res.Unmarshal(release)
return
}
func (client *Client) EditRelease(release *Release, releaseParams map[string]interface{}) (updatedRelease *Release, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PatchJSON(release.ApiUrl, releaseParams)
if err = checkStatus(200, "editing release", res, err); err != nil {
return
}
updatedRelease = &Release{}
err = res.Unmarshal(updatedRelease)
return
}
func (client *Client) DeleteRelease(release *Release) (err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.Delete(release.ApiUrl)
if err = checkStatus(204, "deleting release", res, err); err != nil {
return
}
return
}
func (client *Client) UploadReleaseAsset(release *Release, filename, label string) (asset *ReleaseAsset, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
parts := strings.SplitN(release.UploadUrl, "{", 2)
uploadUrl := parts[0]
uploadUrl += "?name=" + url.QueryEscape(filepath.Base(filename))
if label != "" {
uploadUrl += "&label=" + url.QueryEscape(label)
}
res, err := api.PostFile(uploadUrl, filename)
if err = checkStatus(201, "uploading release asset", res, err); err != nil {
return
}
asset = &ReleaseAsset{}
err = res.Unmarshal(asset)
return
}
func (client *Client) DeleteReleaseAsset(asset *ReleaseAsset) (err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.Delete(asset.ApiUrl)
err = checkStatus(204, "deleting release asset", res, err)
return
}
func (client *Client) DownloadReleaseAsset(url string) (asset io.ReadCloser, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
resp, err := api.GetFile(url, "application/octet-stream")
if err = checkStatus(200, "downloading asset", resp, err); err != nil {
return
}
return resp.Body, err
}
type CIStatusResponse struct {
State string `json:"state"`
Statuses []CIStatus `json:"statuses"`
}
type CIStatus struct {
State string `json:"state"`
Context string `json:"context"`
TargetUrl string `json:"target_url"`
}
type CheckRunsResponse struct {
CheckRuns []CheckRun `json:"check_runs"`
}
type CheckRun struct {
Status string `json:"status"`
Conclusion string `json:"conclusion"`
Name string `json:"name"`
HtmlUrl string `json:"html_url"`
}
func (client *Client) FetchCIStatus(project *Project, sha string) (status *CIStatusResponse, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.Get(fmt.Sprintf("repos/%s/%s/commits/%s/status", project.Owner, project.Name, sha))
if err = checkStatus(200, "fetching statuses", res, err); err != nil {
return
}
status = &CIStatusResponse{}
if err = res.Unmarshal(status); err != nil {
return
}
res, err = api.GetFile(fmt.Sprintf("repos/%s/%s/commits/%s/check-runs", project.Owner, project.Name, sha), checksType)
if err == nil && (res.StatusCode == 403 || res.StatusCode == 404 || res.StatusCode == 422) {
return
}
if err = checkStatus(200, "fetching checks", res, err); err != nil {
return
}
checks := &CheckRunsResponse{}
if err = res.Unmarshal(checks); err != nil {
return
}
for _, checkRun := range checks.CheckRuns {
state := "pending"
if checkRun.Status == "completed" {
state = checkRun.Conclusion
}
checkStatus := CIStatus{
State: state,
Context: checkRun.Name,
TargetUrl: checkRun.HtmlUrl,
}
status.Statuses = append(status.Statuses, checkStatus)
}
return
}
type Repository struct {
Name string `json:"name"`
FullName string `json:"full_name"`
Parent *Repository `json:"parent"`
Owner *User `json:"owner"`
Private bool `json:"private"`
HasWiki bool `json:"has_wiki"`
Permissions *RepositoryPermissions `json:"permissions"`
HtmlUrl string `json:"html_url"`
DefaultBranch string `json:"default_branch"`
}
type RepositoryPermissions struct {
Admin bool `json:"admin"`
Push bool `json:"push"`
Pull bool `json:"pull"`
}
func (client *Client) ForkRepository(project *Project, params map[string]interface{}) (repo *Repository, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PostJSON(fmt.Sprintf("repos/%s/%s/forks", project.Owner, project.Name), params)
if err = checkStatus(202, "creating fork", res, err); err != nil {
return
}
repo = &Repository{}
err = res.Unmarshal(repo)
return
}
type Issue struct {
Number int `json:"number"`
State string `json:"state"`
Title string `json:"title"`
Body string `json:"body"`
User *User `json:"user"`
PullRequest *PullRequest `json:"pull_request"`
Head *PullRequestSpec `json:"head"`
Base *PullRequestSpec `json:"base"`
MaintainerCanModify bool `json:"maintainer_can_modify"`
Comments int `json:"comments"`
Labels []IssueLabel `json:"labels"`
Assignees []User `json:"assignees"`
Milestone *Milestone `json:"milestone"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
RequestedReviewers []User `json:"requested_reviewers"`
RequestedTeams []Team `json:"requested_teams"`
ApiUrl string `json:"url"`
HtmlUrl string `json:"html_url"`
}
type PullRequest Issue
type PullRequestSpec struct {
Label string `json:"label"`
Ref string `json:"ref"`
Sha string `json:"sha"`
Repo *Repository `json:"repo"`
}
func (pr *PullRequest) IsSameRepo() bool {
return pr.Head != nil && pr.Head.Repo != nil &&
pr.Head.Repo.Name == pr.Base.Repo.Name &&
pr.Head.Repo.Owner.Login == pr.Base.Repo.Owner.Login
}
func (pr *PullRequest) HasRequestedReviewer(name string) bool {
for _, user := range pr.RequestedReviewers {
if strings.EqualFold(user.Login, name) {
return true
}
}
return false
}
func (pr *PullRequest) HasRequestedTeam(name string) bool {
for _, team := range pr.RequestedTeams {
if strings.EqualFold(team.Name, name) {
return true
}
}
return false
}
type IssueLabel struct {
Name string `json:"name"`
Color string `json:"color"`
}
type User struct {
Login string `json:"login"`
}
type Team struct {
Name string `json:"name"`
}
type Milestone struct {
Number int `json:"number"`
Title string `json:"title"`
}
func (client *Client) FetchIssues(project *Project, filterParams map[string]interface{}, limit int, filter func(*Issue) bool) (issues []Issue, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
path := fmt.Sprintf("repos/%s/%s/issues?per_page=%d", project.Owner, project.Name, perPage(limit, 100))
if filterParams != nil {
query := url.Values{}
for key, value := range filterParams {
switch v := value.(type) {
case string:
query.Add(key, v)
}
}
path += "&" + query.Encode()
}
issues = []Issue{}
var res *simpleResponse
for path != "" {
res, err = api.Get(path)
if err = checkStatus(200, "fetching issues", res, err); err != nil {
return
}
path = res.Link("next")
issuesPage := []Issue{}
if err = res.Unmarshal(&issuesPage); err != nil {
return
}
for _, issue := range issuesPage {
if filter == nil || filter(&issue) {
issues = append(issues, issue)
if limit > 0 && len(issues) == limit {
path = ""
break
}
}
}
}
return
}
func (client *Client) CreateIssue(project *Project, params interface{}) (issue *Issue, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PostJSON(fmt.Sprintf("repos/%s/%s/issues", project.Owner, project.Name), params)
if err = checkStatus(201, "creating issue", res, err); err != nil {
return
}
issue = &Issue{}
err = res.Unmarshal(issue)
return
}
func (client *Client) UpdateIssue(project *Project, issueNumber int, params map[string]interface{}) (err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.PatchJSON(fmt.Sprintf("repos/%s/%s/issues/%d", project.Owner, project.Name, issueNumber), params)
if err = checkStatus(200, "updating issue", res, err); err != nil {
return
}
res.Body.Close()
return
}
func (client *Client) FetchLabels(project *Project) (labels []IssueLabel, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
path := fmt.Sprintf("repos/%s/%s/labels?per_page=100", project.Owner, project.Name)
labels = []IssueLabel{}
var res *simpleResponse
for path != "" {
res, err = api.Get(path)
if err = checkStatus(200, "fetching labels", res, err); err != nil {
return
}
path = res.Link("next")
labelsPage := []IssueLabel{}
if err = res.Unmarshal(&labelsPage); err != nil {
return
}
labels = append(labels, labelsPage...)
}
return
}
func (client *Client) FetchMilestones(project *Project) (milestones []Milestone, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
path := fmt.Sprintf("repos/%s/%s/milestones?per_page=100", project.Owner, project.Name)
milestones = []Milestone{}
var res *simpleResponse
for path != "" {
res, err = api.Get(path)
if err = checkStatus(200, "fetching milestones", res, err); err != nil {
return
}
path = res.Link("next")
milestonesPage := []Milestone{}
if err = res.Unmarshal(&milestonesPage); err != nil {
return
}
milestones = append(milestones, milestonesPage...)
}
return
}
func (client *Client) CurrentUser() (user *User, err error) {
api, err := client.simpleApi()
if err != nil {
return
}
res, err := api.Get("user")
if err = checkStatus(200, "getting current user", res, err); err != nil {
return
}
user = &User{}
err = res.Unmarshal(user)
return
}
type AuthorizationEntry struct {
Token string `json:"token"`
}
func isToken(api *simpleClient, password string) bool {
api.PrepareRequest = func(req *http.Request) {
req.Header.Set("Authorization", "token "+password)
}
res, _ := api.Get("user")
if res != nil && res.StatusCode == 200 {
return true
}
return false
}
func (client *Client) FindOrCreateToken(user, password, twoFactorCode string) (token string, err error) {
api := client.apiClient()
if len(password) >= 40 && isToken(api, password) {
return password, nil
}
params := map[string]interface{}{
"scopes": []string{"repo"},
"note_url": OAuthAppURL,
}
api.PrepareRequest = func(req *http.Request) {
req.SetBasicAuth(user, password)
if twoFactorCode != "" {
req.Header.Set("X-GitHub-OTP", twoFactorCode)
}
}
count := 1
maxTries := 9
for {
params["note"], err = authTokenNote(count)
if err != nil {
return
}
res, postErr := api.PostJSON("authorizations", params)
if postErr != nil {
err = postErr
break
}
if res.StatusCode == 201 {
auth := &AuthorizationEntry{}
if err = res.Unmarshal(auth); err != nil {
return
}
token = auth.Token
break
} else if res.StatusCode == 422 && count < maxTries {
count++
} else {
errInfo, e := res.ErrorInfo()
if e == nil {
err = errInfo
} else {
err = e
}
return
}
}
return
}
func (client *Client) ensureAccessToken() (err error) {
if client.Host.AccessToken == "" {
host, err := CurrentConfig().PromptForHost(client.Host.Host)
if err == nil {
client.Host = host
}
}
return
}
func (client *Client) simpleApi() (c *simpleClient, err error) {
err = client.ensureAccessToken()
if err != nil {
return
}
c = client.apiClient()
c.PrepareRequest = func(req *http.Request) {
req.Header.Set("Authorization", "token "+client.Host.AccessToken)
}
return
}
func (client *Client) apiClient() *simpleClient {
httpClient := newHttpClient(os.Getenv("HUB_TEST_HOST"), os.Getenv("HUB_VERBOSE") != "")
apiRoot := client.absolute(normalizeHost(client.Host.Host))
if client.Host != nil && client.Host.Host != GitHubHost {
apiRoot.Path = "/api/v3/"
}
return &simpleClient{
httpClient: httpClient,
rootUrl: apiRoot,
}
}
func (client *Client) absolute(host string) *url.URL {
u, _ := url.Parse("https://" + host + "/")
if client.Host != nil && client.Host.Protocol != "" {
u.Scheme = client.Host.Protocol
}
return u
}
func normalizeHost(host string) string {
host = strings.ToLower(host)
if host == "" {
host = GitHubHost
}
if host == GitHubHost {
host = GitHubApiHost
}
return host
}
func checkStatus(expectedStatus int, action string, response *simpleResponse, err error) error {
if err != nil {
return fmt.Errorf("Error %s: %s", action, err.Error())
} else if response.StatusCode != expectedStatus {
errInfo, err := response.ErrorInfo()
if err == nil {
return FormatError(action, errInfo)
} else {
return fmt.Errorf("Error %s: %s (HTTP %d)", action, err.Error(), response.StatusCode)
}
} else {
return nil
}
}
func FormatError(action string, err error) (ee error) {
switch e := err.(type) {
default:
ee = err
case *errorInfo:
statusCode := e.Response.StatusCode
var reason string
if s := strings.SplitN(e.Response.Status, " ", 2); len(s) >= 2 {
reason = strings.TrimSpace(s[1])
}
errStr := fmt.Sprintf("Error %s: %s (HTTP %d)", action, reason, statusCode)
var errorSentences []string
for _, err := range e.Errors {
switch err.Code {
case "custom":
errorSentences = append(errorSentences, err.Message)
case "missing_field":
errorSentences = append(errorSentences, fmt.Sprintf("Missing field: \"%s\"", err.Field))
case "already_exists":
errorSentences = append(errorSentences, fmt.Sprintf("Duplicate value for \"%s\"", err.Field))
case "invalid":
errorSentences = append(errorSentences, fmt.Sprintf("Invalid value for \"%s\"", err.Field))
case "unauthorized":
errorSentences = append(errorSentences, fmt.Sprintf("Not allowed to change field \"%s\"", err.Field))
}
}
var errorMessage string
if len(errorSentences) > 0 {
errorMessage = strings.Join(errorSentences, "\n")
} else {
errorMessage = e.Message
}
if errorMessage != "" {
errStr = fmt.Sprintf("%s\n%s", errStr, errorMessage)
}
ee = fmt.Errorf(errStr)
}
return
}
func authTokenNote(num int) (string, error) {
n := os.Getenv("USER")
if n == "" {
n = os.Getenv("USERNAME")
}
if n == "" {
whoami := exec.Command("whoami")
whoamiOut, err := whoami.Output()
if err != nil {
return "", err
}
n = strings.TrimSpace(string(whoamiOut))
}
h, err := os.Hostname()
if err != nil {
return "", err
}
if num > 1 {
return fmt.Sprintf("hub for %s@%s %d", n, h, num), nil
}
return fmt.Sprintf("hub for %s@%s", n, h), nil
}
func perPage(limit, max int) int {
if limit > 0 {
limit = limit + (limit / 2)
if limit < max {
return limit
}
}
return max
}
|
[
"\"HUB_TEST_HOST\"",
"\"HUB_VERBOSE\"",
"\"USER\"",
"\"USERNAME\""
] |
[] |
[
"USER",
"USERNAME",
"HUB_VERBOSE",
"HUB_TEST_HOST"
] |
[]
|
["USER", "USERNAME", "HUB_VERBOSE", "HUB_TEST_HOST"]
|
go
| 4 | 0 | |
astrodata/doc/ad_UserManual/conf.py
|
#
# Astrodata User Manual build configuration file, created
# from team template.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# -- Setting up path to import modules ---------------------------------------
on_rtd = os.environ.get('READTHEDOCS') == 'True'
print(' Printing current working directory for debugging:')
print((' ' + os.getcwd()))
if on_rtd:
sys.path.insert(0, os.path.abspath('./../../../'))
else:
sys.path.insert(0, os.path.abspath('./../../../'))
# -- General configuration ---------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.intersphinx',
'sphinx.ext.todo',
'sphinx.ext.coverage',
'sphinx.ext.imgmath',
'sphinx.ext.ifconfig',
'sphinx.ext.viewcode',
'sphinx.ext.napoleon',
'sphinx.ext.graphviz',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'Astrodata User Manual'
copyright = '2020, Association of Universities for Research in Astronomy'
# Note that AURA owns the Copyright, not you.
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '2.1'
# The full version, including alpha/beta/rc tags.
release = '2.1.1'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
today = 'April 2020'
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The reST default role (used for this markup: `text`) to use for all documents.
default_role = 'obj'
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#html_theme = 'default'
html_theme = "sphinx_rtd_theme"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'AstrodataUserManual'
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
# This will remove blank pages.
'classoptions': ',openany,oneside',
'babel': '\\usepackage[english]{babel}',
# The paper size ('letterpaper' or 'a4paper').
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
# 'preamble': '',
'preamble': '\\usepackage{appendix} \\setcounter{tocdepth}{0}',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index-latex', 'AstrodataUserManual.tex', 'Astrodata User Manual',
'Kathleen Labrie', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
latex_logo = 'images/GeminiLogo_new_2014.jpg'
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'astrodatausermanual', 'Astrodata User Manual',
['Kathleen Labrie'], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output ------------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'AstrodataUserManual', 'Astrodata User Manual',
'Kathleen Labrie', 'AstrodataUserManual',
'User manual for the astrodata package.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {
'astropy': ('https://docs.astropy.org/en/stable/', None),
'gemini_instruments': ('https://dragons-recipe-system-programmers-manual.readthedocs.io/en/latest/', None),
'geminidr': ('https://dragons-recipe-system-programmers-manual.readthedocs.io/en/latest/', None),
'numpy': ('https://numpy.org/doc/stable/', None),
'python': ('https://docs.python.org/3', None),
}
# Activate the todos
todo_include_todos = True
# -- Automatically generate API documentation --------------------------------
# -- Enable autoapi ----------------------------------------------------------
def run_api_doc(_):
"""
Automatic API generator
This method is used to generate API automatically by importing all the
modules and sub-modules inside a package.
It is equivalent to run:
>>> sphinx-apidoc --force --no-toc --separate --module --output-dir api/ ../../ ../../cal_service
It is useful because it creates .rst files on the file.
NOTE
----
This does not work with PyCharm default build. If you want to trigger
this function, use the standard `$ make html` in the command line.
The .rst files will be generated. After that, you can use PyCharm's
build helper.
"""
build_packages = [
'astrodata',
'gemini_instruments'
]
current_path = os.getcwd()
relative_path = "../../../"
print(("Current Path:", current_path))
for p in build_packages:
build_path = os.path.join(current_path, relative_path, p)
ignore_paths = [
'doc',
'test',
'tests',
]
ignore_paths = [os.path.join(build_path, i) for i in ignore_paths]
argv = [
"--force",
"--no-toc",
# "--separate",
"--module",
"--output-dir", "api/",
build_path
] + ignore_paths
sys.path.insert(0, build_path)
try:
# Sphinx 1.7+
from sphinx.ext import apidoc
apidoc.main(argv)
except ImportError:
# Sphinx 1.6 (and earlier)
from sphinx import apidoc
argv.insert(0, apidoc.__file__)
apidoc.main(argv)
# -- Finishing with a setup that will run always -----------------------------
def setup(app):
# Adding style in order to have the todos show up in a red box.
app.add_css_file('todo-styles.css')
app.add_css_file('rtd_theme_overrides.css')
app.add_css_file('css/rtd_theme_overrides_references.css')
# Automatic API generation
app.connect('builder-inited', run_api_doc)
|
[] |
[] |
[
"READTHEDOCS"
] |
[]
|
["READTHEDOCS"]
|
python
| 1 | 0 | |
consumers/neo4j_connector.py
|
import os
import json
import logging
from neo4j import GraphDatabase
from datetime import datetime, timedelta
logging.basicConfig()
logger = logging.getLogger("neo4j_connector")
logger.setLevel(logging.INFO)
NEO4J_QUERIES_FILES = [
'queries.json',
]
class NeoDB(object):
"""
Neo4j Wrapper around `neo4j.GraphDatabase`,
which is in charge of instaurating a connection with
the backend Neo4j database.
This should never be instantiated directly.
"""
def __init__(self):
self._parse_config()
self._connect()
def _parse_config(self):
"""
uri: The URI of Neo4j (e.g., bolt://neo4j-bolt-service:7687)
username: Username for Neo4j
password: Password for Neo4j
If no config has been passed to __init__,
fetch the connection string from environment variables
"""
self._neo4j_uri = os.environ['NEO4J_URI']
self._neo4j_user = os.environ['NEO4J_USER']
self._neo4j_password = os.environ['NEO4J_SECRETS_PASSWORD']
def _connect(self):
"""
Instantiate the Neo4j python driver
"""
self._driver = GraphDatabase.driver(self._neo4j_uri,
auth=(self._neo4j_user, self._neo4j_password))
logger.info('Neo4J Client instantiated: {}'.format(self._neo4j_uri))
@staticmethod
def _exec_query(tx, query, kwargs):
if kwargs:
result = tx.run(query, **kwargs)
else:
result = tx.run(query)
values = [record.data() for record in result]
return values
def query(self, q, kwargs=None):
with self._driver.session() as session:
return session.read_transaction(self._exec_query, q, kwargs)
def close(self):
self._driver.close()
class Neo4jConnector(object):
"""
Main connector which abstract over the actual execution of queries,
and provide an interface to run queries and obtain results
"""
def __init__(self):
# Initialize DB
self.db = NeoDB()
# Load the queries file into memory
self._load_queries()
def _load_queries(self):
extracted = []
for fname in NEO4J_QUERIES_FILES:
path = os.path.join("/app/", fname)
if not os.path.isfile(path):
logger.warning('File "{}" not found. Skipping...'.format(path))
continue
with open(path, 'r') as fp:
logger.debug('Loading queries file: {}'.format(path))
body = fp.read()
temp = body.strip()[1:-1]
extracted.append(temp)
queries_str = "[%s]" % (",".join(extracted))
self.QUERIES = json.loads(queries_str)
logger.info(f"{len(self.QUERIES)} queries loaded")
#
# UTILS
#
@staticmethod
def _n_recent_days(N):
return (datetime.utcnow() - timedelta(days=N))
def _parse_dynamic_params(self, q):
params = q.get('params', '')
kwargs = ""
if params:
# Iterate through the parameters and verify if one matches the supported types
for p in params.keys():
kwargs = {}
# The query has a parameter specifying to
# retrieve the assets for the N most recent days
if p == "n_recent_days":
kwargs[params[p]["param_name"]] = \
str(self._n_recent_days(params[p]["param_value"]))
return kwargs
#
# FILTERS
#
def _filter_by_tags(self, queries, tags):
"""
Returns all the queries which contain *all* the tags provided
(it is an AND)
"""
if type(tags) is not list:
tags = list(tags)
return [q for q in queries if all(elem in q['tags'] for elem in tags)]
def _filter_by_account(self, cypher, account):
if account:
if 'WHERE' in cypher:
cypher = cypher.replace(
' WHERE ', ' WHERE a.name = "{}" and '.format(account))
else:
cypher = cypher.replace(
' RETURN ', ' WHERE a.name = "{}" RETURN '.format(account))
return cypher
#
# EXECUTE QUERIES
#
def query_raw(self, cypher):
logger.info("Executing a raw query: {}".format(cypher))
return self.db.query(cypher)
def _execute_queries(self, queries, account):
queries_result = []
for q in queries:
# Parse optional dynamic parameters
kwargs = self._parse_dynamic_params(q)
# If an account is provided, inject a WHERE clause to filter by account
cypher = self._filter_by_account(q['query'], account)
# Add return clause
cypher = "{} {}".format(cypher, q['return'])
# Execute the query and parse results as dictionaries
logger.debug(f"Running query: {cypher}")
records = self.db.query(cypher, kwargs)
# Add records to result list
temp = {}
temp['name'] = q['name']
temp['description'] = q['description']
temp['headers'] = q['result_headers']
temp['result'] = records
logger.debug(f"Result: {len(records)} records")
queries_result.append(temp)
return queries_result
def query_by_tag(self, tags, account=None):
logger.info("Executing queries by tag: {}".format(tags))
# Filter queries
selected_queries = self._filter_by_tags(self.QUERIES, tags)
# Run queries
return self._execute_queries(selected_queries, account)
if __name__ == '__main__':
Neo4jConnector()
|
[] |
[] |
[
"NEO4J_SECRETS_PASSWORD",
"NEO4J_URI",
"NEO4J_USER"
] |
[]
|
["NEO4J_SECRETS_PASSWORD", "NEO4J_URI", "NEO4J_USER"]
|
python
| 3 | 0 | |
manage.py
|
import os
from flask_script import Manager
from bdc_geoserver import app
manager = Manager(app)
@manager.command
def run():
HOST = os.environ.get('SERVER_HOST', '0.0.0.0')
try:
PORT = int(os.environ.get('PORT', '5000'))
except ValueError:
PORT = 5000
app.run(HOST, PORT)
@manager.command
def test():
"""Run the unit tests."""
import pytest
pytest.main(["-s", "tests/"])
if __name__ == '__main__':
manager.run()
|
[] |
[] |
[
"PORT",
"SERVER_HOST"
] |
[]
|
["PORT", "SERVER_HOST"]
|
python
| 2 | 0 | |
irregularquiz/irregular_verb.py
|
#!/usr/bin/env python
# -*- mode:python; coding:utf-8; -*-
# author: Ruslan Pisarev
import os
import random
from json import dumps
from sqlite3 import connect
from bottle import route, run, request, redirect
@route('/')
def main_page_irregular():
return open(os.path.join(os.path.abspath(os.path.dirname(__file__)),
"template/main.html")).read()
@route('/en/irregular/verb')
def irr_page_open():
return open(os.path.join(os.path.abspath(os.path.dirname(__file__)),
"template/irregular_verb.html")).read()
@route('/contacts')
def contacts():
return redirect('/')
def check_verb(verb, sample):
return any([verb == v.strip() for v in sample.split(",")])
def gen_correct_tr(correct_verbs, user_verbs, rights):
tr = """<tr>\n<td>{}</td>\n<td>{}</td>\n<td>{}</td>\n</tr>\n"""
tds = []
for x in range(3):
if rights[x]:
content = """<span style="color:green">{}</span>""".format(user_verbs[x])
else:
content = """<span style="color:red">{}</span>
<br><span style="color:blue">{}</span>""".format(
user_verbs[x], correct_verbs[x])
tds.append(content)
return tr.format(tds[0], tds[1], tds[2])
@route('/check/en/irregular_verb', method='POST')
def check_irregular_verb():
position = int(request.forms.get("position"))
num = request.forms.get("verbid")
input1 = request.forms.get("input1")
input2 = request.forms.get("input2")
main = request.forms.get("main")
sqlite_connect = connect(os.path.join(os.path.abspath(os.path.dirname(__file__)),
"irregular_verb_en.db"))
c = sqlite_connect.cursor()
query = "select `infinitive`, `past_simple`, `past_participle` from irregular where id={}"
c.execute(query.format(num))
res = c.fetchall()[0]
c.close()
user_verbs = []
if position == 0:
first = True
user_verbs.append(main)
else:
first = check_verb(input1, res[0])
user_verbs.append(input1)
if position == 1:
user_verbs.append(main)
second = True
elif position == 0:
second = check_verb(input1, res[1])
user_verbs.append(input1)
else:
second = check_verb(input2, res[1])
user_verbs.append(input2)
if position == 2:
third = True
user_verbs.append(main)
else:
third = check_verb(input2, res[2])
user_verbs.append(input2)
verbs_correct = (first, second, third)
checkpoints = len([v for v in verbs_correct if v]) - 1
tr = gen_correct_tr(res, user_verbs, verbs_correct)
return dumps({"tr": tr + create_quiz_tr(),
"checkpoints": checkpoints})
@route('/start/en/irregular_verb', method='POST')
def start_irregular_verb():
return create_quiz_tr()
def irregular(infinitive, kind, forms):
return "<tr><td>{}</td><td>{}</td><td>{}</td></tr>".format(
infinitive, forms[0], forms[1])
def choice_verb(position):
verb_form = {0: "infinitive",
1: "past_simple",
2: "past_participle"}[position]
verb_number = random.choice(range(188))
sqlite_connect = connect(os.path.join(os.path.abspath(os.path.dirname(__file__)),
"irregular_verb_en.db"))
c = sqlite_connect.cursor()
query = "select `{}` from irregular where id = {}"
c.execute(query.format(verb_form, verb_number))
res = c.fetchall()[0][0]
c.close()
return res.split(",")[random.choice(range(2))] if "," in res else res, verb_number
def create_quiz_tr():
position = random.choice(range(3))
verb, num = choice_verb(position)
tr = """<tr data-position="{}">\n<td>{}</td>\n<td>{}</td>\n<td>{}</td>\n</tr>\n"""
tds = []
input_count = 1
for td in range(3):
if td == position:
content = """<span id="main_value" data-num="{}">{}</span>""".format(
num, verb)
else:
content = """<input type="text" size="20" id="input{}">""".format(
input_count)
input_count += 1
tds.append(content)
return tr.format(position, tds[0], tds[1], tds[2])
run(host='0.0.0.0', port=int(os.environ.get("PORT", 5000)))
|
[] |
[] |
[
"PORT"
] |
[]
|
["PORT"]
|
python
| 1 | 0 | |
pkg/utils/rbacevaluate.go
|
// SPDX-FileCopyrightText: 2020-present Open Networking Foundation <[email protected]>
//
// SPDX-License-Identifier: Apache-2.0
package utils
import (
"github.com/grpc-ecosystem/go-grpc-middleware/util/metautils"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"os"
"strings"
)
const semicolon = ";" // From grpcinterceptors.go in onos-lib-go
// TemporaryEvaluate - simple evaluation of rules until OpenPolicyAgent is added
// This is so that aether-config can be deployed to the cloud in 2021 Q1 with simple RBAC
// It applies to Set (gnmi) and CompactChanges(admin) and RollbackNetworkChange(admin)
// TODO replace the following with fine grained RBAC using OpenPolicyAgent Rego in 2021 Q2
func TemporaryEvaluate(md metautils.NiceMD) error {
adminGroups := os.Getenv("ADMINGROUPS")
var match bool
for _, g := range strings.Split(md.Get("groups"), semicolon) {
if strings.Contains(adminGroups, g) {
match = true
break
}
}
if !match {
return status.Errorf(codes.Unauthenticated, "Set allowed only for %s", adminGroups)
}
return nil
}
|
[
"\"ADMINGROUPS\""
] |
[] |
[
"ADMINGROUPS"
] |
[]
|
["ADMINGROUPS"]
|
go
| 1 | 0 | |
example_apps/basic_app.py
|
import os
from flask import Flask, render_template_string
from flask_mail import Mail
from flask_sqlalchemy import SQLAlchemy
from flask_user import login_required, UserManager, UserMixin, SQLAlchemyAdapter
# Use a Class-based config to avoid needing a 2nd file
# os.getenv() enables configuration through OS environment variables
class ConfigClass(object):
# Flask settings
SECRET_KEY = os.getenv('SECRET_KEY', 'THIS IS AN INSECURE SECRET')
SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL', 'sqlite:///basic_app.sqlite')
CSRF_ENABLED = True
# Flask-Mail settings
MAIL_USERNAME = os.getenv('MAIL_USERNAME', '[email protected]')
MAIL_PASSWORD = os.getenv('MAIL_PASSWORD', 'password')
MAIL_DEFAULT_SENDER = os.getenv('MAIL_DEFAULT_SENDER', '"MyApp" <[email protected]>')
MAIL_SERVER = os.getenv('MAIL_SERVER', 'smtp.gmail.com')
MAIL_PORT = int(os.getenv('MAIL_PORT', '465'))
MAIL_USE_SSL = int(os.getenv('MAIL_USE_SSL', True))
# Flask-User settings
USER_APP_NAME = "AppName" # Used by email templates
def create_app():
""" Flask application factory """
# Setup Flask app and app.config
app = Flask(__name__)
app.config.from_object(__name__+'.ConfigClass')
# Initialize Flask extensions
db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy
mail = Mail(app) # Initialize Flask-Mail
# Define the User data model. Make sure to add flask_user UserMixin !!!
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
# User authentication information
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
confirmed_at = db.Column(db.DateTime())
# User information
active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
first_name = db.Column(db.String(100), nullable=False, server_default='')
last_name = db.Column(db.String(100), nullable=False, server_default='')
# Create all database tables
db.create_all()
# Setup Flask-User
db_adapter = SQLAlchemyAdapter(db, User) # Register the User model
user_manager = UserManager(db_adapter, app) # Initialize Flask-User
# The Home page is accessible to anyone
@app.route('/')
def home_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Home page</h2>
<p>This page can be accessed by anyone.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
{% endblock %}
""")
# The Members page is only accessible to authenticated users
@app.route('/members')
@login_required # Use of @login_required decorator
def members_page():
return render_template_string("""
{% extends "base.html" %}
{% block content %}
<h2>Members page</h2>
<p>This page can only be accessed by authenticated users.</p><br/>
<p><a href={{ url_for('home_page') }}>Home page</a> (anyone)</p>
<p><a href={{ url_for('members_page') }}>Members page</a> (login required)</p>
{% endblock %}
""")
return app
# Start development web server
if __name__=='__main__':
app = create_app()
app.run(host='0.0.0.0', port=5000, debug=True)
|
[] |
[] |
[
"MAIL_SERVER",
"MAIL_PASSWORD",
"DATABASE_URL",
"MAIL_PORT",
"MAIL_DEFAULT_SENDER",
"SECRET_KEY",
"MAIL_USERNAME",
"MAIL_USE_SSL"
] |
[]
|
["MAIL_SERVER", "MAIL_PASSWORD", "DATABASE_URL", "MAIL_PORT", "MAIL_DEFAULT_SENDER", "SECRET_KEY", "MAIL_USERNAME", "MAIL_USE_SSL"]
|
python
| 8 | 0 | |
middleware/middleware.go
|
package middleware
import (
"context"
"io/ioutil"
"net"
"net/http"
"net/http/httputil"
"os"
"time"
api "github.com/kubesure/sidecar-security/api"
log "github.com/sirupsen/logrus"
"google.golang.org/grpc"
)
var customerDataSvc = os.Getenv("CUSTOMER_DATA_SVC")
var customerDataSvcPort = os.Getenv("CUSTOMER_DATA_SVC_Port")
var fraudCheckTCPSvc = os.Getenv("FRAUD_CHECK_SVC")
var fraudCheckTCPSvcPort = os.Getenv("FRAUD_CHECK_SVC_Port")
//initializes logurs with info level
func init() {
log.SetFormatter(&log.JSONFormatter{})
log.SetOutput(os.Stdout)
log.SetLevel(log.InfoLevel)
}
//Customer type represents a customer
type Customer struct {
accountNumer string
CIF int64
}
//FraudCheck message is sent to fraud checker to run fraud checks on the request.
type fraudCheck struct {
smhSegIDVersion string
smhMsgVersion string
smhTranType string
smhCustType string
smhActType string
smhSource string
fromAccount string
clientIP string
customerID string
}
//TCP message from FraudCheck is parsed into fraudCheckRes
type fraudCheckRes struct {
isOk bool
}
//TimeoutHandler is a customer timeout handler which return 504 when
//middlewares or origin does not respond with http.Server.WriteTimeout
func TimeoutHandler(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusGatewayTimeout)
})
}
//Logger middleware logs orgin's request
func Logger(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Infof("logging: request middleware")
next.ServeHTTP(w, r)
log.Infof("logging: response middleware")
})
}
//Auth middleware authenticates request
func Auth(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Infof("Authenticating request: ")
if r.Header.Get("user") != "foo" {
w.WriteHeader(http.StatusUnauthorized)
return
}
log.Infof("Auth: Pass")
next.ServeHTTP(w, r)
})
}
//Final middleware forwards request to orgin
func Final(proxy *httputil.ReverseProxy) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Infof("Passing call to origin")
proxy.ServeHTTP(w, r)
})
}
//FraudChecker middleware checks if the request is fradulent.
func FraudChecker(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Infof("Fraud checking request...")
//reterive customerData from GRCP service Customer.getCustomer
c, cerr := customerData(r)
if cerr != nil {
log.Errorf("Error getting customer data %v", cerr)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
//Make the message for Fraud checking TCP service
msg, merr := makeFTCPMessage(r, c)
if merr != nil {
log.Errorf("error while making tcp message %v", merr)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
conn, ferr := fraudSrvConn()
if ferr != nil {
log.Errorf("Error while connecting to Fraud Server %v", cerr)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
defer conn.Close()
_, werr := conn.Write([]byte(*msg))
if werr != nil {
log.Errorf("Error while sending message to TCP server %v", werr)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
//Read message from TCP service until EOF
tcpmsg, rerr := ioutil.ReadAll(conn)
if rerr != nil {
log.Errorf("Error while reading message to TCP server %v", rerr)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
//Parse response from fraud check service
fcheck, ferr := parseFTCPResponse(string(tcpmsg))
if ferr != nil {
log.Errorf("Error while reading message to TCP server %v", rerr)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
//Check if request is fraudulent
if !fcheck.isOk {
log.Infof("Fraudulent request received")
w.WriteHeader(http.StatusUnauthorized)
return
}
//Dispatch to next middleware check
next.ServeHTTP(w, r)
})
}
//make the TCP Fraud check message from request and Customer data
func makeFTCPMessage(r *http.Request, c *Customer) (*string, error) {
message := string("smh_seg_id_version:000004|smh_source:")
return &message, nil
}
//Pulls customer data from Customer.getCustomer GRCP service
func customerData(r *http.Request) (*Customer, error) {
conn, derr := cdataGrpcSrvConn()
if derr != nil {
return nil, derr
}
defer conn.Close()
client := api.NewCustomerClient(conn)
customer, merr := makeCustomerData(r, client)
if merr != nil {
return nil, merr
}
return customer, nil
}
//Makes the customer data using customer data grpc service input for service is
//read from request header and body. Grpc service return datas cached in a in transient store.
func makeCustomerData(r *http.Request, client api.CustomerClient) (*Customer, error) {
req := &api.CustomerRequest{Version: "v1", AccountNumber: "12345"}
res, cerr := client.GetCustomer(context.Background(), req)
if cerr != nil {
return nil, cerr
}
c := &Customer{}
c.CIF = res.CIF
return c, nil
}
//Parses the TCP response from TCP Fraud check service
func parseFTCPResponse(msg string) (*fraudCheckRes, error) {
log.Infof("parsing %v", msg)
return &fraudCheckRes{isOk: true}, nil
}
//Create a GRPC connection to Customer Data Service
func cdataGrpcSrvConn() (*grpc.ClientConn, error) {
//Change to return error instead of defaulting
if len(customerDataSvcPort) == 0 {
customerDataSvcPort = "50051"
}
conn, derr := grpc.Dial(customerDataSvc+":"+customerDataSvcPort, grpc.WithInsecure())
if derr != nil {
return nil, derr
}
return conn, nil
}
//Create a TCP connection to Fraud checking service
func fraudSrvConn() (net.Conn, error) {
//Change to return error instead of defaulting
if len(fraudCheckTCPSvcPort) == 0 {
fraudCheckTCPSvcPort = "8090"
}
log.Infof("connecting to fraud server %v", fraudCheckTCPSvc+":"+fraudCheckTCPSvcPort)
d := net.Dialer{Timeout: 2 * time.Second}
conn, cerr := d.Dial("tcp", fraudCheckTCPSvc+":"+fraudCheckTCPSvcPort)
if cerr != nil {
return nil, cerr
}
return conn, nil
}
|
[
"\"CUSTOMER_DATA_SVC\"",
"\"CUSTOMER_DATA_SVC_Port\"",
"\"FRAUD_CHECK_SVC\"",
"\"FRAUD_CHECK_SVC_Port\""
] |
[] |
[
"FRAUD_CHECK_SVC",
"CUSTOMER_DATA_SVC_Port",
"CUSTOMER_DATA_SVC",
"FRAUD_CHECK_SVC_Port"
] |
[]
|
["FRAUD_CHECK_SVC", "CUSTOMER_DATA_SVC_Port", "CUSTOMER_DATA_SVC", "FRAUD_CHECK_SVC_Port"]
|
go
| 4 | 0 | |
src/test/java/org/mariadb/r2dbc/integration/ConnectionMetadataTest.java
|
/*
* Copyright 2020 MariaDB Ab.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mariadb.r2dbc.integration;
import static org.junit.jupiter.api.Assertions.*;
import io.r2dbc.spi.ConnectionFactoryMetadata;
import io.r2dbc.spi.ConnectionMetadata;
import org.junit.jupiter.api.Test;
import org.mariadb.r2dbc.BaseConnectionTest;
import org.mariadb.r2dbc.api.MariadbConnectionMetadata;
public class ConnectionMetadataTest extends BaseConnectionTest {
@Test
void connectionMeta() {
ConnectionMetadata meta = sharedConn.getMetadata();
assertTrue(
meta.getDatabaseProductName().equals("MariaDB")
|| meta.getDatabaseProductName().equals("MySQL"));
if (isMariaDBServer()) {
assertTrue(meta.getDatabaseVersion().contains("10."));
} else {
assertTrue(
meta.getDatabaseVersion().contains("5.") || meta.getDatabaseVersion().contains("8."));
}
String value = System.getenv("DB");
if (value != null) {
String type;
String version;
// testing env
if (System.getenv("TRAVIS") != null) {
type = value.substring(0, value.indexOf(":"));
version = value.substring(value.indexOf(":") + 1);
} else {
// appveyor test only mariadb
type = "MariaDB";
version = value;
}
assertTrue(meta.getDatabaseVersion().contains(version));
assertEquals(type.toLowerCase(), meta.getDatabaseProductName().toLowerCase());
}
}
@Test
void factoryMeta() {
ConnectionFactoryMetadata meta = factory.getMetadata();
assertEquals("MariaDB", meta.getName());
}
@Test
void metadataInfo() {
MariadbConnectionMetadata meta = sharedConn.getMetadata();
assertTrue(meta.getMajorVersion() >= 5);
assertTrue(meta.getMinorVersion() > -1);
assertTrue(meta.getPatchVersion() > -1);
}
}
|
[
"\"DB\"",
"\"TRAVIS\""
] |
[] |
[
"DB",
"TRAVIS"
] |
[]
|
["DB", "TRAVIS"]
|
java
| 2 | 0 | |
src/art/asgi.py
|
"""
ASGI config for art project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/howto/deployment/asgi/
"""
import os
from django.core.asgi import get_asgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'art.settings')
application = get_asgi_application()
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
cli/commands.go
|
// Copyright (c) 2014-2019 Ludovic Fauvet
// Licensed under the MIT license
package cli
import (
"bufio"
"bytes"
"context"
"flag"
"fmt"
"io/ioutil"
"net/url"
"os"
"os/exec"
"reflect"
"sort"
"strings"
"sync"
"text/tabwriter"
"time"
"github.com/Myself5/mirrorbits/core"
"github.com/Myself5/mirrorbits/filesystem"
"github.com/Myself5/mirrorbits/mirrors"
"github.com/Myself5/mirrorbits/rpc"
"github.com/Myself5/mirrorbits/utils"
"github.com/golang/protobuf/ptypes"
"github.com/golang/protobuf/ptypes/empty"
"github.com/howeyc/gopass"
"github.com/op/go-logging"
"github.com/pkg/errors"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"gopkg.in/yaml.v2"
)
const (
commentSeparator = "##### Comments go below this line #####"
defaultRPCTimeout = time.Second * 10
)
var (
log = logging.MustGetLogger("main")
)
type cli struct {
sync.Mutex
rpcconn *grpc.ClientConn
creds *loginCreds
}
// ParseCommands parses the command line and call the appropriate functions
func ParseCommands(args ...string) error {
c := &cli{
creds: &loginCreds{
Password: core.RPCPassword,
},
}
if len(args) > 0 && args[0] != "help" {
method, exists := c.getMethod(args[0])
if !exists {
fmt.Println("Error: Command not found:", args[0])
return c.CmdHelp()
}
if len(c.creds.Password) == 0 && core.RPCAskPass {
fmt.Print("Password: ")
passwd, err := gopass.GetPasswdMasked()
if err != nil {
return err
}
c.creds.Password = string(passwd)
}
ret := method.Func.CallSlice([]reflect.Value{
reflect.ValueOf(c),
reflect.ValueOf(args[1:]),
})[0].Interface()
if c.rpcconn != nil {
c.rpcconn.Close()
}
if ret == nil {
return nil
}
return ret.(error)
}
return c.CmdHelp()
}
func (c *cli) getMethod(name string) (reflect.Method, bool) {
methodName := "Cmd" + strings.ToUpper(name[:1]) + strings.ToLower(name[1:])
return reflect.TypeOf(c).MethodByName(methodName)
}
func (c *cli) CmdHelp() error {
help := fmt.Sprintf("Usage: mirrorbits [OPTIONS] COMMAND [arg...]\n\nA smart download redirector.\n\n")
help += fmt.Sprintf("Server commands:\n %-10.10s%s\n\n", "daemon", "Start the server")
help += fmt.Sprintf("CLI commands:\n")
for _, command := range [][]string{
{"add", "Add a new mirror"},
{"disable", "Disable a mirror"},
{"edit", "Edit a mirror"},
{"enable", "Enable a mirror"},
{"export", "Export the mirror database"},
{"list", "List all mirrors"},
{"logs", "Print logs of a mirror"},
{"refresh", "Refresh the local repository"},
{"reload", "Reload configuration"},
{"remove", "Remove a mirror"},
{"scan", "(Re-)Scan a mirror"},
{"show", "Print a mirror configuration"},
{"stats", "Show download stats"},
{"upgrade", "Seamless binary upgrade"},
{"version", "Print version information"},
} {
help += fmt.Sprintf(" %-10.10s%s\n", command[0], command[1])
}
fmt.Fprintf(os.Stderr, "%s\n", help)
return nil
}
// SubCmd prints the usage of a subcommand
func SubCmd(name, signature, description string) *flag.FlagSet {
flags := flag.NewFlagSet(name, flag.ContinueOnError)
flags.Usage = func() {
fmt.Fprintf(os.Stderr, "\nUsage: mirrorbits %s %s\n\n%s\n\n", name, signature, description)
flags.PrintDefaults()
}
return flags
}
type ByDate []*rpc.Mirror
func (d ByDate) Len() int { return len(d) }
func (d ByDate) Swap(i, j int) { d[i], d[j] = d[j], d[i] }
func (d ByDate) Less(i, j int) bool { return d[i].StateSince.Seconds > d[j].StateSince.Seconds }
func (c *cli) CmdList(args ...string) error {
cmd := SubCmd("list", "", "Get the list of mirrors")
http := cmd.Bool("http", false, "Print HTTP addresses")
rsync := cmd.Bool("rsync", false, "Print rsync addresses")
ftp := cmd.Bool("ftp", false, "Print FTP addresses")
location := cmd.Bool("location", false, "Print the country and continent code")
state := cmd.Bool("state", true, "Print the state of the mirror")
score := cmd.Bool("score", false, "Print the score of the mirror")
disabled := cmd.Bool("disabled", false, "List disabled mirrors only")
enabled := cmd.Bool("enabled", false, "List enabled mirrors only")
down := cmd.Bool("down", false, "List only mirrors currently down")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 0 {
cmd.Usage()
return nil
}
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
list, err := client.List(ctx, &empty.Empty{})
if err != nil {
log.Fatal("list error:", err)
}
sort.Sort(ByDate(list.Mirrors))
w := new(tabwriter.Writer)
w.Init(os.Stdout, 0, 8, 0, '\t', 0)
fmt.Fprint(w, "Identifier ")
if *score == true {
fmt.Fprint(w, "\tSCORE")
}
if *http == true {
fmt.Fprint(w, "\tHTTP ")
}
if *rsync == true {
fmt.Fprint(w, "\tRSYNC ")
}
if *ftp == true {
fmt.Fprint(w, "\tFTP ")
}
if *location == true {
fmt.Fprint(w, "\tLOCATION ")
}
if *state == true {
fmt.Fprint(w, "\tSTATE\tSINCE")
}
fmt.Fprint(w, "\n")
for _, mirror := range list.Mirrors {
if *disabled == true {
if mirror.Enabled == true {
continue
}
}
if *enabled == true {
if mirror.Enabled == false {
continue
}
}
if *down == true {
if mirror.Up == true {
continue
}
}
stateSince, err := ptypes.Timestamp(mirror.StateSince)
if err != nil {
log.Fatal("list error:", err)
}
fmt.Fprintf(w, "%s ", mirror.Name)
if *score == true {
fmt.Fprintf(w, "\t%d ", mirror.Score)
}
if *http == true {
fmt.Fprintf(w, "\t%s ", mirror.HttpURL)
}
if *rsync == true {
fmt.Fprintf(w, "\t%s ", mirror.RsyncURL)
}
if *ftp == true {
fmt.Fprintf(w, "\t%s ", mirror.FtpURL)
}
if *location == true {
countries := strings.Split(mirror.CountryCodes, " ")
countryCode := "/"
if len(countries) >= 1 {
countryCode = countries[0]
}
fmt.Fprintf(w, "\t%s (%s) ", countryCode, mirror.ContinentCode)
}
if *state == true {
if mirror.Enabled == false {
fmt.Fprintf(w, "\tdisabled")
} else if mirror.Up == true {
fmt.Fprintf(w, "\tup")
} else {
fmt.Fprintf(w, "\tdown")
}
fmt.Fprintf(w, " \t(%s)", stateSince.Format(time.RFC1123))
}
fmt.Fprint(w, "\n")
}
w.Flush()
return nil
}
func (c *cli) CmdAdd(args ...string) error {
cmd := SubCmd("add", "[OPTIONS] IDENTIFIER", "Add a new mirror")
http := cmd.String("http", "", "HTTP base URL")
rsync := cmd.String("rsync", "", "RSYNC base URL (for scanning only)")
ftp := cmd.String("ftp", "", "FTP base URL (for scanning only)")
sponsorName := cmd.String("sponsor-name", "", "Name of the sponsor")
sponsorURL := cmd.String("sponsor-url", "", "URL of the sponsor")
sponsorLogo := cmd.String("sponsor-logo", "", "URL of a logo to display for this mirror")
adminName := cmd.String("admin-name", "", "Admin's name")
adminEmail := cmd.String("admin-email", "", "Admin's email")
customData := cmd.String("custom-data", "", "Associated data to return when the mirror is selected (i.e. json document)")
continentOnly := cmd.Bool("continent-only", false, "The mirror should only handle its continent")
countryOnly := cmd.Bool("country-only", false, "The mirror should only handle its country")
asOnly := cmd.Bool("as-only", false, "The mirror should only handle clients in the same AS number")
score := cmd.Int("score", 0, "Weight to give to the mirror during selection")
comment := cmd.String("comment", "", "Comment")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() < 1 {
cmd.Usage()
return nil
}
if strings.Contains(cmd.Arg(0), " ") {
fmt.Fprintf(os.Stderr, "The identifier cannot contain a space\n")
os.Exit(-1)
}
if *http == "" {
fmt.Fprintf(os.Stderr, "You *must* pass at least an HTTP URL\n")
os.Exit(-1)
}
if !strings.HasPrefix(*http, "http://") && !strings.HasPrefix(*http, "https://") {
*http = "http://" + *http
}
_, err := url.Parse(*http)
if err != nil {
fmt.Fprintf(os.Stderr, "Can't parse url\n")
os.Exit(-1)
}
mirror := &mirrors.Mirror{
Name: cmd.Arg(0),
HttpURL: *http,
RsyncURL: *rsync,
FtpURL: *ftp,
SponsorName: *sponsorName,
SponsorURL: *sponsorURL,
SponsorLogoURL: *sponsorLogo,
AdminName: *adminName,
AdminEmail: *adminEmail,
CustomData: *customData,
ContinentOnly: *continentOnly,
CountryOnly: *countryOnly,
ASOnly: *asOnly,
Score: *score,
Comment: *comment,
}
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
m, err := rpc.MirrorToRPC(mirror)
if err != nil {
log.Fatal("edit error:", err)
}
reply, err := client.AddMirror(ctx, m)
if err != nil {
if err.Error() == rpc.ErrNameAlreadyTaken.Error() {
log.Fatalf("Mirror %s already exists!\n", mirror.Name)
}
log.Fatal("edit error:", err)
}
for i := 0; i < len(reply.Warnings); i++ {
fmt.Println(reply.Warnings[i])
if i == len(reply.Warnings)-1 {
fmt.Println("")
}
}
if reply.Country != "" {
fmt.Println("Mirror location:")
fmt.Printf("Latitude: %.4f\n", reply.Latitude)
fmt.Printf("Longitude: %.4f\n", reply.Longitude)
fmt.Printf("Continent: %s\n", reply.Continent)
fmt.Printf("Country: %s\n", reply.Country)
fmt.Printf("ASN: %s\n", reply.ASN)
fmt.Println("")
}
fmt.Printf("Mirror '%s' added successfully\n", mirror.Name)
fmt.Printf("Enable this mirror using\n $ mirrorbits enable %s\n", mirror.Name)
return nil
}
func (c *cli) CmdRemove(args ...string) error {
cmd := SubCmd("remove", "IDENTIFIER", "Remove an existing mirror")
force := cmd.Bool("f", false, "Never prompt for confirmation")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
id, name := c.matchMirror(cmd.Arg(0))
if *force == false {
fmt.Printf("Removing %s, are you sure? [y/N]", name)
reader := bufio.NewReader(os.Stdin)
s, _ := reader.ReadString('\n')
switch s[0] {
case 'y', 'Y':
break
default:
return nil
}
}
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
_, err := client.RemoveMirror(ctx, &rpc.MirrorIDRequest{
ID: int32(id),
})
if err != nil {
log.Fatal("remove error:", err)
}
fmt.Printf("Mirror '%s' removed successfully\n", name)
return nil
}
func (c *cli) CmdScan(args ...string) error {
cmd := SubCmd("scan", "[IDENTIFIER]", "(Re-)Scan a mirror")
enable := cmd.Bool("enable", false, "Enable the mirror automatically if the scan is successful")
all := cmd.Bool("all", false, "Scan all mirrors at once")
ftp := cmd.Bool("ftp", false, "Force a scan using FTP")
rsync := cmd.Bool("rsync", false, "Force a scan using rsync")
timeout := cmd.Uint("timeout", 0, "Timeout in seconds")
if err := cmd.Parse(args); err != nil {
return nil
}
if !*all && cmd.NArg() != 1 || *all && cmd.NArg() != 0 {
cmd.Usage()
return nil
}
client := c.GetRPC()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
list := make(map[int]string)
// Get the list of mirrors to scan
if *all == true {
reply, err := client.MatchMirror(ctx, &rpc.MatchRequest{
Pattern: "", // Match all of them
})
if err != nil {
return errors.New("Cannot fetch the list of mirrors")
}
for _, m := range reply.Mirrors {
list[int(m.ID)] = m.Name
}
} else {
// Single mirror
id, name := c.matchMirror(cmd.Arg(0))
list[id] = name
}
// Set the method of the scan (if not default)
var method rpc.ScanMirrorRequest_Method
if *ftp == false && *rsync == false {
method = rpc.ScanMirrorRequest_ALL
} else if *rsync == true {
method = rpc.ScanMirrorRequest_RSYNC
} else if *ftp == true {
method = rpc.ScanMirrorRequest_FTP
}
for id, name := range list {
if *timeout > 0 {
ctx, cancel = context.WithTimeout(context.Background(), time.Duration(*timeout)*time.Second)
defer cancel()
}
fmt.Printf("Scanning %s... ", name)
reply, err := client.ScanMirror(ctx, &rpc.ScanMirrorRequest{
ID: int32(id),
AutoEnable: *enable,
Protocol: method,
})
if err != nil {
s := status.Convert(err)
if s.Code() == codes.FailedPrecondition || len(list) == 1 {
return errors.New("\nscan error: " + grpc.ErrorDesc(err))
}
fmt.Println("scan error:", grpc.ErrorDesc(err))
continue
} else {
fmt.Printf("%d files indexed, %d known and %d removed\n", reply.FilesIndexed, reply.KnownIndexed, reply.Removed)
if reply.GetTZOffsetMs() != 0 {
fmt.Printf(" ∟ Timezone offset detected and corrected: %d milliseconds\n", reply.TZOffsetMs)
}
if reply.Enabled {
fmt.Println(" ∟ Enabled")
}
}
}
return nil
}
func (c *cli) CmdRefresh(args ...string) error {
cmd := SubCmd("refresh", "", "Scan the local repository")
rehash := cmd.Bool("rehash", false, "Force a rehash of the files")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 0 {
cmd.Usage()
return nil
}
fmt.Print("Refreshing the local repository... ")
client := c.GetRPC()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
_, err := client.RefreshRepository(ctx, &rpc.RefreshRepositoryRequest{
Rehash: *rehash,
})
if err != nil {
fmt.Println("")
log.Fatal(err)
}
fmt.Println("done")
return nil
}
func (c *cli) matchMirror(pattern string) (id int, name string) {
if len(pattern) == 0 {
return -1, ""
}
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
reply, err := client.MatchMirror(ctx, &rpc.MatchRequest{
Pattern: pattern,
})
if err != nil {
fmt.Fprintf(os.Stderr, "mirror matching: %s\n", err)
os.Exit(1)
}
switch len(reply.Mirrors) {
case 0:
fmt.Fprintf(os.Stderr, "No match for '%s'\n", pattern)
os.Exit(1)
case 1:
id, name, err := GetSingle(reply.Mirrors)
if err != nil {
log.Fatal("unexpected error:", err)
}
return id, name
default:
fmt.Fprintln(os.Stderr, "Multiple match:")
for _, mirror := range reply.Mirrors {
fmt.Fprintf(os.Stderr, " %s\n", mirror.Name)
}
os.Exit(1)
}
return
}
func GetSingle(list []*rpc.MirrorID) (int, string, error) {
if len(list) == 0 {
return -1, "", errors.New("list is empty")
} else if len(list) > 1 {
return -1, "", errors.New("too many results")
}
return int(list[0].ID), list[0].Name, nil
}
func (c *cli) CmdEdit(args ...string) error {
cmd := SubCmd("edit", "[IDENTIFIER]", "Edit a mirror")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
// Find the editor to use
editor := os.Getenv("EDITOR")
if editor == "" {
log.Fatal("Environment variable $EDITOR not set")
}
id, _ := c.matchMirror(cmd.Arg(0))
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
rpcm, err := client.MirrorInfo(ctx, &rpc.MirrorIDRequest{
ID: int32(id),
})
if err != nil {
log.Fatal("edit error:", err)
}
mirror, err := rpc.MirrorFromRPC(rpcm)
if err != nil {
log.Fatal("edit error:", err)
}
// Generate a yaml configuration string from the struct
out, err := yaml.Marshal(mirror)
// Open a temporary file
f, err := ioutil.TempFile(os.TempDir(), "edit")
if err != nil {
log.Fatal("Cannot create temporary file:", err)
}
defer os.Remove(f.Name())
f.WriteString("# You can now edit this mirror configuration.\n" +
"# Just save and quit when you're done.\n\n")
f.WriteString(string(out))
f.WriteString(fmt.Sprintf("\n%s\n\n%s\n", commentSeparator, mirror.Comment))
f.Close()
// Checksum the original file
chk, _ := filesystem.Sha256sum(f.Name())
reopen:
// Launch the editor with the filename as first parameter
exe := exec.Command(editor, f.Name())
exe.Stdin = os.Stdin
exe.Stdout = os.Stdout
exe.Stderr = os.Stderr
err = exe.Run()
if err != nil {
log.Fatal(err)
}
// Read the file back
out, err = ioutil.ReadFile(f.Name())
if err != nil {
log.Fatal("Cannot read file", f.Name())
}
// Checksum the file back and compare
chk2, _ := filesystem.Sha256sum(f.Name())
if bytes.Compare(chk, chk2) == 0 {
fmt.Println("Aborted - settings are unmodified, so there is nothing to change.")
return nil
}
var comment string
yamlstr := string(out)
commentIndex := strings.Index(yamlstr, commentSeparator)
if commentIndex > 0 {
comment = strings.TrimSpace(yamlstr[commentIndex+len(commentSeparator):])
yamlstr = yamlstr[:commentIndex]
}
reopen := func(err error) bool {
eagain:
fmt.Printf("%s\nRetry? [Y/n]", err.Error())
reader := bufio.NewReader(os.Stdin)
s, _ := reader.ReadString('\n')
switch s[0] {
case 'y', 'Y', 10:
return true
case 'n', 'N':
fmt.Println("Aborted")
return false
default:
goto eagain
}
}
// Fill the struct from the yaml
err = yaml.Unmarshal([]byte(yamlstr), &mirror)
if err != nil {
switch reopen(err) {
case true:
goto reopen
case false:
return nil
}
}
mirror.Comment = comment
ctx, cancel = context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
m, err := rpc.MirrorToRPC(mirror)
if err != nil {
log.Fatal("edit error:", err)
}
reply, err := client.UpdateMirror(ctx, m)
if err != nil {
if err.Error() == rpc.ErrNameAlreadyTaken.Error() {
switch reopen(errors.New("Name already taken")) {
case true:
goto reopen
case false:
return nil
}
}
log.Fatal("edit error:", err)
}
if len(reply.Diff) > 0 {
fmt.Println(reply.Diff)
}
fmt.Printf("Mirror '%s' edited successfully\n", mirror.Name)
return nil
}
func (c *cli) CmdShow(args ...string) error {
cmd := SubCmd("show", "[IDENTIFIER]", "Print a mirror configuration")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
id, _ := c.matchMirror(cmd.Arg(0))
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
rpcm, err := client.MirrorInfo(ctx, &rpc.MirrorIDRequest{
ID: int32(id),
})
if err != nil {
log.Fatal("edit error:", err)
}
mirror, err := rpc.MirrorFromRPC(rpcm)
if err != nil {
log.Fatal("edit error:", err)
}
// Generate a yaml configuration string from the struct
out, err := yaml.Marshal(mirror)
if err != nil {
log.Fatal("show error:", err)
}
fmt.Printf("%s\nComment:\n%s\n", out, mirror.Comment)
return nil
}
func (c *cli) CmdExport(args ...string) error {
cmd := SubCmd("export", "[format]", "Export the mirror database.\n\nAvailable formats: mirmon")
rsync := cmd.Bool("rsync", true, "Export rsync URLs")
http := cmd.Bool("http", true, "Export http URLs")
ftp := cmd.Bool("ftp", true, "Export ftp URLs")
disabled := cmd.Bool("disabled", true, "Export disabled mirrors")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
if cmd.Arg(0) != "mirmon" {
fmt.Fprintf(os.Stderr, "Unsupported format\n")
cmd.Usage()
return nil
}
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
list, err := client.List(ctx, &empty.Empty{})
if err != nil {
log.Fatal("export error:", err)
}
w := new(tabwriter.Writer)
w.Init(os.Stdout, 0, 8, 0, '\t', 0)
for _, m := range list.Mirrors {
if *disabled == false {
if m.Enabled == false {
continue
}
}
ccodes := strings.Fields(m.CountryCodes)
urls := make([]string, 0, 3)
if *rsync == true && m.RsyncURL != "" {
urls = append(urls, m.RsyncURL)
}
if *http == true && m.HttpURL != "" {
urls = append(urls, m.HttpURL)
}
if *ftp == true && m.FtpURL != "" {
urls = append(urls, m.FtpURL)
}
for _, u := range urls {
fmt.Fprintf(w, "%s\t%s\t%s\n", ccodes[0], u, m.AdminEmail)
}
}
w.Flush()
return nil
}
func (c *cli) CmdEnable(args ...string) error {
cmd := SubCmd("enable", "[IDENTIFIER]", "Enable a mirror")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
c.changeStatus(cmd.Arg(0), true)
return nil
}
func (c *cli) CmdDisable(args ...string) error {
cmd := SubCmd("disable", "[IDENTIFIER]", "Disable a mirror")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
c.changeStatus(cmd.Arg(0), false)
return nil
}
func (c *cli) changeStatus(pattern string, enabled bool) {
id, name := c.matchMirror(pattern)
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
_, err := client.ChangeStatus(ctx, &rpc.ChangeStatusRequest{
ID: int32(id),
Enabled: enabled,
})
if err != nil {
if enabled {
log.Fatalf("Couldn't enable mirror '%s': %s\n", name, err)
} else {
log.Fatalf("Couldn't disable mirror '%s': %s\n", name, err)
}
}
if enabled {
fmt.Printf("Mirror '%s' enabled successfully\n", name)
} else {
fmt.Printf("Mirror '%s' disabled successfully\n", name)
}
return
}
func (c *cli) CmdStats(args ...string) error {
cmd := SubCmd("stats", "[OPTIONS] [mirror|file] [IDENTIFIER|PATTERN]", "Show download stats for a particular mirror or a file pattern")
dateStart := cmd.String("start-date", "", "Starting date (format YYYY-MM-DD)")
dateEnd := cmd.String("end-date", "", "Ending date (format YYYY-MM-DD)")
human := cmd.Bool("h", true, "Human readable version")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 2 || (cmd.Arg(0) != "mirror" && cmd.Arg(0) != "file") {
cmd.Usage()
return nil
}
start, err := time.Parse("2006-1-2", *dateStart)
if err != nil {
start = time.Now()
}
startproto, _ := ptypes.TimestampProto(start)
end, err := time.Parse("2006-1-2", *dateEnd)
if err != nil {
end = time.Now()
}
endproto, _ := ptypes.TimestampProto(end)
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
if cmd.Arg(0) == "file" {
// File stats
reply, err := client.StatsFile(ctx, &rpc.StatsFileRequest{
Pattern: cmd.Arg(1),
DateStart: startproto,
DateEnd: endproto,
})
if err != nil {
log.Fatal("file stats error:", err)
}
// Format the results
w := new(tabwriter.Writer)
w.Init(os.Stdout, 0, 8, 0, '\t', 0)
// Sort keys and count requests
var keys []string
var requests int64
for k, req := range reply.Files {
requests += req
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
fmt.Fprintf(w, "%s:\t%d\n", k, reply.Files[k])
}
if len(keys) > 0 {
// Add a line separator
fmt.Fprintf(w, "\t\n")
}
fmt.Fprintf(w, "Total download requests: \t%d\n", requests)
w.Flush()
} else if cmd.Arg(0) == "mirror" {
// Mirror stats
id, name := c.matchMirror(cmd.Arg(1))
reply, err := client.StatsMirror(ctx, &rpc.StatsMirrorRequest{
ID: int32(id),
DateStart: startproto,
DateEnd: endproto,
})
if err != nil {
log.Fatal("mirror stats error:", err)
}
// Format the results
w := new(tabwriter.Writer)
w.Init(os.Stdout, 0, 8, 0, '\t', 0)
fmt.Fprintf(w, "Identifier:\t%s\n", name)
if !reply.Mirror.Enabled {
fmt.Fprintf(w, "Status:\tdisabled\n")
} else if reply.Mirror.Up {
fmt.Fprintf(w, "Status:\tup\n")
} else {
fmt.Fprintf(w, "Status:\tdown\n")
}
fmt.Fprintf(w, "Download requests:\t%d\n", reply.Requests)
fmt.Fprint(w, "Bytes transferred:\t")
if *human {
fmt.Fprintln(w, utils.ReadableSize(reply.Bytes))
} else {
fmt.Fprintln(w, reply.Bytes)
}
w.Flush()
}
return nil
}
func (c *cli) CmdLogs(args ...string) error {
cmd := SubCmd("logs", "[IDENTIFIER]", "Print logs of a mirror")
maxResults := cmd.Uint("l", 500, "Maximum number of logs to return")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
id, name := c.matchMirror(cmd.Arg(0))
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
resp, err := client.GetMirrorLogs(ctx, &rpc.GetMirrorLogsRequest{
ID: int32(id),
MaxResults: int32(*maxResults),
})
if err != nil {
log.Fatal("logs error:", err)
}
if len(resp.Line) == 0 {
fmt.Printf("No logs for %s\n", name)
return nil
}
fmt.Printf("Printing logs for %s:\n", name)
for _, l := range resp.Line {
fmt.Println(l)
}
return nil
}
func (c *cli) CmdReload(args ...string) error {
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
_, err := client.Reload(ctx, &empty.Empty{})
if err != nil {
log.Fatal("upgrade error:", err)
}
return nil
}
func (c *cli) CmdUpgrade(args ...string) error {
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
_, err := client.Upgrade(ctx, &empty.Empty{})
if err != nil {
log.Fatal("upgrade error:", err)
}
return nil
}
func (c *cli) CmdVersion(args ...string) error {
fmt.Printf("Client:\n")
core.PrintVersion(core.GetVersionInfo())
fmt.Println()
client := c.GetRPC()
ctx, cancel := context.WithTimeout(context.Background(), defaultRPCTimeout)
defer cancel()
reply, err := client.GetVersion(ctx, &empty.Empty{})
if err != nil {
s := status.Convert(err)
return errors.Wrap(s.Err(), "version error")
}
if reply.Version != "" {
fmt.Printf("Server:\n")
core.PrintVersion(core.VersionInfo{
Version: reply.Version,
Build: reply.Build,
GoVersion: reply.GoVersion,
OS: reply.OS,
Arch: reply.Arch,
GoMaxProcs: int(reply.GoMaxProcs),
})
}
return nil
}
|
[
"\"EDITOR\""
] |
[] |
[
"EDITOR"
] |
[]
|
["EDITOR"]
|
go
| 1 | 0 | |
train_model.py
|
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import time
from PIL import Image
import random
import os
from sample import sample_conf
from tensorflow.python.framework.errors_impl import NotFoundError
# 设置以下环境变量可开启CPU识别
# os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
# os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
class TrainError(Exception):
pass
class TrainModel(object):
def __init__(self, img_path, char_set, model_save_dir, verify=False):
# 模型路径
self.model_save_dir = model_save_dir
# 打乱文件顺序+校验图片格式
self.img_path = img_path
self.img_list = os.listdir(img_path)
# 校验格式
if verify:
self.confirm_image_suffix()
# 打乱文件顺序
random.seed(time.time())
random.shuffle(self.img_list)
# 获得图片宽高和字符长度基本信息
label, captcha_array = self.gen_captcha_text_image(self.img_list[0])
captcha_shape = captcha_array.shape
captcha_shape_len = len(captcha_shape)
if captcha_shape_len == 3:
image_height, image_width, channel = captcha_shape
self.channel = channel
elif captcha_shape_len == 2:
image_height, image_width = captcha_shape
else:
raise TrainError("图片转换为矩阵时出错，请检查图片格式")
# 初始化变量
# 图片尺寸
self.image_height = image_height
self.image_width = image_width
# 验证码长度（位数）
self.max_captcha = len(label)
# 验证码字符类别
self.char_set = char_set
self.char_set_len = len(char_set)
# 相关信息打印
print("-->图片尺寸: {} X {}".format(image_height, image_width))
print("-->验证码长度: {}".format(self.max_captcha))
print("-->验证码共{}类 {}".format(self.char_set_len, char_set))
print("-->使用测试集为 {}".format(img_path))
# tf初始化占位符
self.X = tf.placeholder(tf.float32, [None, image_height * image_width]) # 特征向量
self.Y = tf.placeholder(tf.float32, [None, self.max_captcha * self.char_set_len]) # 标签
self.keep_prob = tf.placeholder(tf.float32) # dropout值
self.w_alpha = 0.01
self.b_alpha = 0.1
# test model input and output
print(">>> Start model test")
batch_x, batch_y = self.get_batch(0, size=100)
print(">>> input batch images shape: {}".format(batch_x.shape))
print(">>> input batch labels shape: {}".format(batch_y.shape))
def gen_captcha_text_image(self, img_name):
"""
返回一个验证码的array形式和对应的字符串标签
:return:tuple (str, numpy.array)
"""
# 标签
label = img_name.split("_")[0]
# 文件
img_file = os.path.join(self.img_path, img_name)
captcha_image = Image.open(img_file)
captcha_array = np.array(captcha_image) # 向量化
return label, captcha_array
@staticmethod
def convert2gray(img):
"""
图片转为灰度图，如果是3通道图则计算，单通道图则直接返回
:param img:
:return:
"""
if len(img.shape) > 2:
r, g, b = img[:, :, 0], img[:, :, 1], img[:, :, 2]
gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
return gray
else:
return img
def text2vec(self, text):
"""
转标签为oneHot编码
:param text: str
:return: numpy.array
"""
text_len = len(text)
if text_len > self.max_captcha:
raise ValueError('验证码最长{}个字符'.format(self.max_captcha))
vector = np.zeros(self.max_captcha * self.char_set_len)
for i, ch in enumerate(text):
idx = i * self.char_set_len + self.char_set.index(ch)
vector[idx] = 1
return vector
def get_batch(self, n, size=128):
batch_x = np.zeros([size, self.image_height * self.image_width]) # 初始化
batch_y = np.zeros([size, self.max_captcha * self.char_set_len]) # 初始化
max_batch = int(len(self.img_list) / size)
# print(max_batch)
if max_batch - 1 < 0:
raise TrainError("训练集图片数量需要大于每批次训练的图片数量")
if n > max_batch - 1:
n = n % max_batch
s = n * size
e = (n + 1) * size
this_batch = self.img_list[s:e]
# print("{}:{}".format(s, e))
for i, img_name in enumerate(this_batch):
label, image_array = self.gen_captcha_text_image(img_name)
image_array = self.convert2gray(image_array) # 灰度化图片
batch_x[i, :] = image_array.flatten() / 255 # flatten 转为一维
batch_y[i, :] = self.text2vec(label) # 生成 oneHot
return batch_x, batch_y
def confirm_image_suffix(self):
# 在训练前校验所有文件格式
print("开始校验所有图片后缀")
for index, img_name in enumerate(self.img_list):
print("{} image pass".format(index), end='\r')
if not img_name.endswith(sample_conf['image_suffix']):
raise TrainError('confirm images suffix：you request [.{}] file but get file [{}]'
.format(sample_conf['image_suffix'], img_name))
print("所有图片格式校验通过")
def model(self):
x = tf.reshape(self.X, shape=[-1, self.image_height, self.image_width, 1])
print(">>> input x: {}".format(x))
# 卷积层1
wc1 = tf.get_variable(name='wc1', shape=[3, 3, 1, 32], dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer())
bc1 = tf.Variable(self.b_alpha * tf.random_normal([32]))
conv1 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, wc1, strides=[1, 1, 1, 1], padding='SAME'), bc1))
conv1 = tf.nn.max_pool(conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
conv1 = tf.nn.dropout(conv1, self.keep_prob)
# 卷积层2
wc2 = tf.get_variable(name='wc2', shape=[3, 3, 32, 64], dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer())
bc2 = tf.Variable(self.b_alpha * tf.random_normal([64]))
conv2 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv1, wc2, strides=[1, 1, 1, 1], padding='SAME'), bc2))
conv2 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
conv2 = tf.nn.dropout(conv2, self.keep_prob)
# 卷积层3
wc3 = tf.get_variable(name='wc3', shape=[3, 3, 64, 128], dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer())
bc3 = tf.Variable(self.b_alpha * tf.random_normal([128]))
conv3 = tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(conv2, wc3, strides=[1, 1, 1, 1], padding='SAME'), bc3))
conv3 = tf.nn.max_pool(conv3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
conv3 = tf.nn.dropout(conv3, self.keep_prob)
print(">>> convolution 3: ", conv3.shape)
next_shape = conv3.shape[1] * conv3.shape[2] * conv3.shape[3]
# 全连接层1
wd1 = tf.get_variable(name='wd1', shape=[next_shape, 1024], dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer())
bd1 = tf.Variable(self.b_alpha * tf.random_normal([1024]))
dense = tf.reshape(conv3, [-1, wd1.get_shape().as_list()[0]])
dense = tf.nn.relu(tf.add(tf.matmul(dense, wd1), bd1))
dense = tf.nn.dropout(dense, self.keep_prob)
# 全连接层2
wout = tf.get_variable('name', shape=[1024, self.max_captcha * self.char_set_len], dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer())
bout = tf.Variable(self.b_alpha * tf.random_normal([self.max_captcha * self.char_set_len]))
y_predict = tf.add(tf.matmul(dense, wout), bout)
return y_predict
def train_cnn(self):
y_predict = self.model()
print(">>> input batch predict shape: {}".format(y_predict.shape))
print(">>> End model test")
# 计算概率 损失
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=y_predict, labels=self.Y))
# 梯度下降
optimizer = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(cost)
# 计算准确率
predict = tf.reshape(y_predict, [-1, self.max_captcha, self.char_set_len]) # 预测结果
max_idx_p = tf.argmax(predict, 2) # 预测结果
max_idx_l = tf.argmax(tf.reshape(self.Y, [-1, self.max_captcha, self.char_set_len]), 2) # 标签
# 计算准确率
correct_pred = tf.equal(max_idx_p, max_idx_l)
accuracy = tf.reduce_mean(tf.reduce_min(tf.cast(correct_pred, tf.float32), axis=1))
# 模型保存对象
saver = tf.train.Saver()
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
# 恢复模型
if os.path.exists(self.model_save_dir):
try:
saver.restore(sess, self.model_save_dir)
# 判断捕获model文件夹中没有模型文件的错误
except NotFoundError:
print("model文件夹为空，将创建新模型")
else:
pass
step = 1
for i in range(3000):
batch_x, batch_y = self.get_batch(i, size=128)
_, cost_ = sess.run([optimizer, cost], feed_dict={self.X: batch_x, self.Y: batch_y, self.keep_prob: 0.75})
if step % 10 == 0:
batch_x_test, batch_y_test = self.get_batch(i, size=100)
acc = sess.run(accuracy, feed_dict={self.X: batch_x_test, self.Y: batch_y_test, self.keep_prob: 1.})
print("第{}次训练 >>> 准确率为 {} >>> loss {}".format(step, acc, cost_))
# 准确率达到99%后保存并停止
if acc > 0.99:
saver.save(sess, self.model_save_dir)
break
# 每训练500轮就保存一次
if i % 500 == 0:
saver.save(sess, self.model_save_dir)
step += 1
saver.save(sess, self.model_save_dir)
def recognize_captcha(self):
label, captcha_array = self.gen_captcha_text_image(random.choice(self.img_list))
f = plt.figure()
ax = f.add_subplot(111)
ax.text(0.1, 0.9, "origin:" + label, ha='center', va='center', transform=ax.transAxes)
plt.imshow(captcha_array)
# 预测图片
image = self.convert2gray(captcha_array)
image = image.flatten() / 255
y_predict = self.model()
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, self.model_save_dir)
predict = tf.argmax(tf.reshape(y_predict, [-1, self.max_captcha, self.char_set_len]), 2)
text_list = sess.run(predict, feed_dict={self.X: [image], self.keep_prob: 1.})
predict_text = text_list[0].tolist()
print("正确: {} 预测: {}".format(label, predict_text))
# 显示图片和预测结果
p_text = ""
for p in predict_text:
p_text += str(self.char_set[p])
print(p_text)
plt.text(20, 1, 'predict:{}'.format(p_text))
plt.show()
def main():
train_image_dir = sample_conf["train_image_dir"]
char_set = sample_conf["char_set"]
model_save_dir = sample_conf["model_save_dir"]
tm = TrainModel(train_image_dir, char_set, model_save_dir, verify=False)
tm.train_cnn() # 开始训练模型
# tm.recognize_captcha() # 识别图片示例
if __name__ == '__main__':
main()
|
[] |
[] |
[
"CUDA_DEVICE_ORDER",
"CUDA_VISIBLE_DEVICES"
] |
[]
|
["CUDA_DEVICE_ORDER", "CUDA_VISIBLE_DEVICES"]
|
python
| 2 | 0 | |
cmd/e2e/e2e.go
|
/*
Copyright 2014 Google Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
"flag"
"io/ioutil"
"os"
"runtime"
"strconv"
"time"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest"
"github.com/GoogleCloudPlatform/kubernetes/pkg/client"
"github.com/GoogleCloudPlatform/kubernetes/pkg/clientauth"
"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
"github.com/golang/glog"
)
var (
authConfig = flag.String("auth_config", os.Getenv("HOME")+"/.kubernetes_auth", "Path to the auth info file.")
host = flag.String("host", "", "The host to connect to")
)
func waitForPodRunning(c *client.Client, id string) {
for {
time.Sleep(5 * time.Second)
pod, err := c.Pods(api.NamespaceDefault).Get(id)
if err != nil {
glog.Warningf("Get pod failed: %v", err)
continue
}
if pod.CurrentState.Status == api.PodRunning {
break
}
glog.Infof("Waiting for pod status to be running (%s)", pod.CurrentState.Status)
}
}
func loadObjectOrDie(filePath string) interface{} {
data, err := ioutil.ReadFile(filePath)
if err != nil {
glog.Fatalf("Failed to read pod: %v", err)
}
obj, err := latest.Codec.Decode(data)
if err != nil {
glog.Fatalf("Failed to decode pod: %v", err)
}
return obj
}
func loadPodOrDie(filePath string) *api.Pod {
obj := loadObjectOrDie(filePath)
pod, ok := obj.(*api.Pod)
if !ok {
glog.Fatalf("Failed to load pod: %v", obj)
}
return pod
}
func loadClientOrDie() *client.Client {
config := client.Config{
Host: *host,
}
auth, err := clientauth.LoadFromFile(*authConfig)
if err != nil {
glog.Fatalf("Error loading auth: %v", err)
}
config, err = auth.MergeWithConfig(config)
if err != nil {
glog.Fatalf("Error creating client")
}
c, err := client.New(&config)
if err != nil {
glog.Fatalf("Error creating client")
}
return c
}
func TestKubernetesROService(c *client.Client) bool {
svc := api.ServiceList{}
err := c.Get().
Namespace("default").
AbsPath("/api/v1beta1/proxy/services/kubernetes-ro/api/v1beta1/services").
Do().
Into(&svc)
if err != nil {
glog.Errorf("unexpected error listing services using ro service: %v", err)
return false
}
var foundRW, foundRO bool
for i := range svc.Items {
if svc.Items[i].Name == "kubernetes" {
foundRW = true
}
if svc.Items[i].Name == "kubernetes-ro" {
foundRO = true
}
}
if !foundRW {
glog.Error("no RW service found")
}
if !foundRO {
glog.Error("no RO service found")
}
if !foundRW || !foundRO {
return false
}
return true
}
func TestPodUpdate(c *client.Client) bool {
podClient := c.Pods(api.NamespaceDefault)
pod := loadPodOrDie("./api/examples/pod.json")
value := strconv.Itoa(time.Now().Nanosecond())
pod.Labels["time"] = value
_, err := podClient.Create(pod)
if err != nil {
glog.Errorf("Failed to create pod: %v", err)
return false
}
defer podClient.Delete(pod.Name)
waitForPodRunning(c, pod.Name)
pods, err := podClient.List(labels.SelectorFromSet(labels.Set(map[string]string{"time": value})))
if len(pods.Items) != 1 {
glog.Errorf("Failed to find the correct pod")
return false
}
podOut, err := podClient.Get(pod.Name)
if err != nil {
glog.Errorf("Failed to get pod: %v", err)
return false
}
value = "time" + value
pod.Labels["time"] = value
pod.ResourceVersion = podOut.ResourceVersion
pod.DesiredState.Manifest.UUID = podOut.DesiredState.Manifest.UUID
pod, err = podClient.Update(pod)
if err != nil {
glog.Errorf("Failed to update pod: %v", err)
return false
}
waitForPodRunning(c, pod.Name)
pods, err = podClient.List(labels.SelectorFromSet(labels.Set(map[string]string{"time": value})))
if len(pods.Items) != 1 {
glog.Errorf("Failed to find the correct pod after update.")
return false
}
glog.Infof("pod update OK")
return true
}
func main() {
flag.Parse()
runtime.GOMAXPROCS(runtime.NumCPU())
util.ReallyCrash = true
util.InitLogs()
defer util.FlushLogs()
go func() {
defer util.FlushLogs()
time.Sleep(3 * time.Minute)
glog.Fatalf("This test has timed out.")
}()
c := loadClientOrDie()
tests := []func(c *client.Client) bool{
TestKubernetesROService,
// TODO(brendandburns): fix this test and re-add it: TestPodUpdate,
}
passed := true
for _, test := range tests {
testPassed := test(c)
if !testPassed {
passed = false
}
}
if !passed {
glog.Fatalf("Tests failed")
}
}
|
[
"\"HOME\""
] |
[] |
[
"HOME"
] |
[]
|
["HOME"]
|
go
| 1 | 0 | |
misc/cgo/testshared/shared_test.go
|
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package shared_test
import (
"bufio"
"bytes"
"debug/elf"
"encoding/binary"
"errors"
"flag"
"fmt"
"go/build"
"io"
"io/ioutil"
"log"
"math/rand"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"strings"
"testing"
"time"
)
var gopathInstallDir, gorootInstallDir, suffix string
// This is the smallest set of packages we can link into a shared
// library (runtime/cgo is built implicitly).
var minpkgs = []string{"runtime", "sync/atomic"}
var soname = "libruntime,sync-atomic.so"
// run runs a command and calls t.Errorf if it fails.
func run(t *testing.T, msg string, args ...string) {
c := exec.Command(args[0], args[1:]...)
if output, err := c.CombinedOutput(); err != nil {
t.Errorf("executing %s (%s) failed %s:\n%s", strings.Join(args, " "), msg, err, output)
}
}
// goCmd invokes the go tool with the installsuffix set up by TestMain. It calls
// t.Fatalf if the command fails.
func goCmd(t *testing.T, args ...string) string {
newargs := []string{args[0], "-installsuffix=" + suffix}
if testing.Verbose() {
newargs = append(newargs, "-x")
}
newargs = append(newargs, args[1:]...)
c := exec.Command("go", newargs...)
stderr := new(strings.Builder)
var output []byte
var err error
if testing.Verbose() {
fmt.Printf("+ go %s\n", strings.Join(args, " "))
c.Stderr = os.Stderr
stderr.WriteString("(output above)")
} else {
c.Stderr = stderr
}
output, err = c.Output()
if err != nil {
if t != nil {
t.Helper()
t.Fatalf("executing %s failed %v:\n%s", strings.Join(c.Args, " "), err, stderr)
} else {
log.Fatalf("executing %s failed %v:\n%s", strings.Join(c.Args, " "), err, stderr)
}
}
return string(bytes.TrimSpace(output))
}
// TestMain calls testMain so that the latter can use defer (TestMain exits with os.Exit).
func testMain(m *testing.M) (int, error) {
// Because go install -buildmode=shared $standard_library_package always
// installs into $GOROOT, here are some gymnastics to come up with a unique
// installsuffix to use in this test that we can clean up afterwards.
myContext := build.Default
runtimeP, err := myContext.Import("runtime", ".", build.ImportComment)
if err != nil {
return 0, fmt.Errorf("import failed: %v", err)
}
for i := 0; i < 10000; i++ {
try := fmt.Sprintf("%s_%d_dynlink", runtimeP.PkgTargetRoot, rand.Int63())
err = os.Mkdir(try, 0700)
if os.IsExist(err) {
continue
}
if err == nil {
gorootInstallDir = try
}
break
}
if err != nil {
return 0, fmt.Errorf("can't create temporary directory: %v", err)
}
if gorootInstallDir == "" {
return 0, errors.New("could not create temporary directory after 10000 tries")
}
if testing.Verbose() {
fmt.Printf("+ mkdir -p %s\n", gorootInstallDir)
}
defer os.RemoveAll(gorootInstallDir)
// Some tests need to edit the source in GOPATH, so copy this directory to a
// temporary directory and chdir to that.
gopath, err := ioutil.TempDir("", "testshared")
if err != nil {
return 0, fmt.Errorf("TempDir failed: %v", err)
}
if testing.Verbose() {
fmt.Printf("+ mkdir -p %s\n", gopath)
}
defer os.RemoveAll(gopath)
modRoot := filepath.Join(gopath, "src", "testshared")
if err := overlayDir(modRoot, "testdata"); err != nil {
return 0, err
}
if testing.Verbose() {
fmt.Printf("+ cd %s\n", modRoot)
}
os.Chdir(modRoot)
os.Setenv("PWD", modRoot)
if err := ioutil.WriteFile("go.mod", []byte("module testshared\n"), 0666); err != nil {
return 0, err
}
os.Setenv("GOPATH", gopath)
if testing.Verbose() {
fmt.Printf("+ export GOPATH=%s\n", gopath)
}
myContext.GOPATH = gopath
// All tests depend on runtime being built into a shared library. Because
// that takes a few seconds, do it here and have all tests use the version
// built here.
suffix = strings.Split(filepath.Base(gorootInstallDir), "_")[2]
goCmd(nil, append([]string{"install", "-buildmode=shared"}, minpkgs...)...)
myContext.InstallSuffix = suffix + "_dynlink"
depP, err := myContext.Import("./depBase", ".", build.ImportComment)
if err != nil {
return 0, fmt.Errorf("import failed: %v", err)
}
if depP.PkgTargetRoot == "" {
gopathInstallDir = filepath.Dir(goCmd(nil, "list", "-buildmode=shared", "-f", "{{.Target}}", "./depBase"))
} else {
gopathInstallDir = filepath.Join(depP.PkgTargetRoot, "testshared")
}
return m.Run(), nil
}
func TestMain(m *testing.M) {
log.SetFlags(log.Lshortfile)
flag.Parse()
// Some of the tests install binaries into a custom GOPATH.
// That won't work if GOBIN is set.
os.Unsetenv("GOBIN")
exitCode, err := testMain(m)
if err != nil {
log.Fatal(err)
}
os.Exit(exitCode)
}
// The shared library was built at the expected location.
func TestSOBuilt(t *testing.T) {
_, err := os.Stat(filepath.Join(gorootInstallDir, soname))
if err != nil {
t.Error(err)
}
}
func hasDynTag(f *elf.File, tag elf.DynTag) bool {
ds := f.SectionByType(elf.SHT_DYNAMIC)
if ds == nil {
return false
}
d, err := ds.Data()
if err != nil {
return false
}
for len(d) > 0 {
var t elf.DynTag
switch f.Class {
case elf.ELFCLASS32:
t = elf.DynTag(f.ByteOrder.Uint32(d[0:4]))
d = d[8:]
case elf.ELFCLASS64:
t = elf.DynTag(f.ByteOrder.Uint64(d[0:8]))
d = d[16:]
}
if t == tag {
return true
}
}
return false
}
// The shared library does not have relocations against the text segment.
func TestNoTextrel(t *testing.T) {
sopath := filepath.Join(gorootInstallDir, soname)
f, err := elf.Open(sopath)
if err != nil {
t.Fatal("elf.Open failed: ", err)
}
defer f.Close()
if hasDynTag(f, elf.DT_TEXTREL) {
t.Errorf("%s has DT_TEXTREL set", soname)
}
}
// The shared library does not contain symbols called ".dup"
func TestNoDupSymbols(t *testing.T) {
sopath := filepath.Join(gorootInstallDir, soname)
f, err := elf.Open(sopath)
if err != nil {
t.Fatal("elf.Open failed: ", err)
}
defer f.Close()
syms, err := f.Symbols()
if err != nil {
t.Errorf("error reading symbols %v", err)
return
}
for _, s := range syms {
if s.Name == ".dup" {
t.Fatalf("%s contains symbol called .dup", sopath)
}
}
}
// The install command should have created a "shlibname" file for the
// listed packages (and runtime/cgo, and math on arm) indicating the
// name of the shared library containing it.
func TestShlibnameFiles(t *testing.T) {
pkgs := append([]string{}, minpkgs...)
pkgs = append(pkgs, "runtime/cgo")
if runtime.GOARCH == "arm" {
pkgs = append(pkgs, "math")
}
for _, pkg := range pkgs {
shlibnamefile := filepath.Join(gorootInstallDir, pkg+".shlibname")
contentsb, err := ioutil.ReadFile(shlibnamefile)
if err != nil {
t.Errorf("error reading shlibnamefile for %s: %v", pkg, err)
continue
}
contents := strings.TrimSpace(string(contentsb))
if contents != soname {
t.Errorf("shlibnamefile for %s has wrong contents: %q", pkg, contents)
}
}
}
// Is a given offset into the file contained in a loaded segment?
func isOffsetLoaded(f *elf.File, offset uint64) bool {
for _, prog := range f.Progs {
if prog.Type == elf.PT_LOAD {
if prog.Off <= offset && offset < prog.Off+prog.Filesz {
return true
}
}
}
return false
}
func rnd(v int32, r int32) int32 {
if r <= 0 {
return v
}
v += r - 1
c := v % r
if c < 0 {
c += r
}
v -= c
return v
}
func readwithpad(r io.Reader, sz int32) ([]byte, error) {
data := make([]byte, rnd(sz, 4))
_, err := io.ReadFull(r, data)
if err != nil {
return nil, err
}
data = data[:sz]
return data, nil
}
type note struct {
name string
tag int32
desc string
section *elf.Section
}
// Read all notes from f. As ELF section names are not supposed to be special, one
// looks for a particular note by scanning all SHT_NOTE sections looking for a note
// with a particular "name" and "tag".
func readNotes(f *elf.File) ([]*note, error) {
var notes []*note
for _, sect := range f.Sections {
if sect.Type != elf.SHT_NOTE {
continue
}
r := sect.Open()
for {
var namesize, descsize, tag int32
err := binary.Read(r, f.ByteOrder, &namesize)
if err != nil {
if err == io.EOF {
break
}
return nil, fmt.Errorf("read namesize failed: %v", err)
}
err = binary.Read(r, f.ByteOrder, &descsize)
if err != nil {
return nil, fmt.Errorf("read descsize failed: %v", err)
}
err = binary.Read(r, f.ByteOrder, &tag)
if err != nil {
return nil, fmt.Errorf("read type failed: %v", err)
}
name, err := readwithpad(r, namesize)
if err != nil {
return nil, fmt.Errorf("read name failed: %v", err)
}
desc, err := readwithpad(r, descsize)
if err != nil {
return nil, fmt.Errorf("read desc failed: %v", err)
}
notes = append(notes, ¬e{name: string(name), tag: tag, desc: string(desc), section: sect})
}
}
return notes, nil
}
func dynStrings(t *testing.T, path string, flag elf.DynTag) []string {
t.Helper()
f, err := elf.Open(path)
if err != nil {
t.Fatalf("elf.Open(%q) failed: %v", path, err)
}
defer f.Close()
dynstrings, err := f.DynString(flag)
if err != nil {
t.Fatalf("DynString(%s) failed on %s: %v", flag, path, err)
}
return dynstrings
}
func AssertIsLinkedToRegexp(t *testing.T, path string, re *regexp.Regexp) {
t.Helper()
for _, dynstring := range dynStrings(t, path, elf.DT_NEEDED) {
if re.MatchString(dynstring) {
return
}
}
t.Errorf("%s is not linked to anything matching %v", path, re)
}
func AssertIsLinkedTo(t *testing.T, path, lib string) {
t.Helper()
AssertIsLinkedToRegexp(t, path, regexp.MustCompile(regexp.QuoteMeta(lib)))
}
func AssertHasRPath(t *testing.T, path, dir string) {
t.Helper()
for _, tag := range []elf.DynTag{elf.DT_RPATH, elf.DT_RUNPATH} {
for _, dynstring := range dynStrings(t, path, tag) {
for _, rpath := range strings.Split(dynstring, ":") {
if filepath.Clean(rpath) == filepath.Clean(dir) {
return
}
}
}
}
t.Errorf("%s does not have rpath %s", path, dir)
}
// Build a trivial program that links against the shared runtime and check it runs.
func TestTrivialExecutable(t *testing.T) {
goCmd(t, "install", "-linkshared", "./trivial")
run(t, "trivial executable", "../../bin/trivial")
AssertIsLinkedTo(t, "../../bin/trivial", soname)
AssertHasRPath(t, "../../bin/trivial", gorootInstallDir)
}
// Build a trivial program in PIE mode that links against the shared runtime and check it runs.
func TestTrivialExecutablePIE(t *testing.T) {
goCmd(t, "build", "-buildmode=pie", "-o", "trivial.pie", "-linkshared", "./trivial")
run(t, "trivial executable", "./trivial.pie")
AssertIsLinkedTo(t, "./trivial.pie", soname)
AssertHasRPath(t, "./trivial.pie", gorootInstallDir)
}
// Build a division test program and check it runs.
func TestDivisionExecutable(t *testing.T) {
goCmd(t, "install", "-linkshared", "./division")
run(t, "division executable", "../../bin/division")
}
// Build an executable that uses cgo linked against the shared runtime and check it
// runs.
func TestCgoExecutable(t *testing.T) {
goCmd(t, "install", "-linkshared", "./execgo")
run(t, "cgo executable", "../../bin/execgo")
}
func checkPIE(t *testing.T, name string) {
f, err := elf.Open(name)
if err != nil {
t.Fatal("elf.Open failed: ", err)
}
defer f.Close()
if f.Type != elf.ET_DYN {
t.Errorf("%s has type %v, want ET_DYN", name, f.Type)
}
if hasDynTag(f, elf.DT_TEXTREL) {
t.Errorf("%s has DT_TEXTREL set", name)
}
}
func TestTrivialPIE(t *testing.T) {
name := "trivial_pie"
goCmd(t, "build", "-buildmode=pie", "-o="+name, "./trivial")
defer os.Remove(name)
run(t, name, "./"+name)
checkPIE(t, name)
}
func TestCgoPIE(t *testing.T) {
name := "cgo_pie"
goCmd(t, "build", "-buildmode=pie", "-o="+name, "./execgo")
defer os.Remove(name)
run(t, name, "./"+name)
checkPIE(t, name)
}
// Build a GOPATH package into a shared library that links against the goroot runtime
// and an executable that links against both.
func TestGopathShlib(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
shlib := goCmd(t, "list", "-f", "{{.Shlib}}", "-buildmode=shared", "-linkshared", "./depBase")
AssertIsLinkedTo(t, shlib, soname)
goCmd(t, "install", "-linkshared", "./exe")
AssertIsLinkedTo(t, "../../bin/exe", soname)
AssertIsLinkedTo(t, "../../bin/exe", filepath.Base(shlib))
AssertHasRPath(t, "../../bin/exe", gorootInstallDir)
AssertHasRPath(t, "../../bin/exe", filepath.Dir(gopathInstallDir))
// And check it runs.
run(t, "executable linked to GOPATH library", "../../bin/exe")
}
// The shared library contains a note listing the packages it contains in a section
// that is not mapped into memory.
func testPkgListNote(t *testing.T, f *elf.File, note *note) {
if note.section.Flags != 0 {
t.Errorf("package list section has flags %v, want 0", note.section.Flags)
}
if isOffsetLoaded(f, note.section.Offset) {
t.Errorf("package list section contained in PT_LOAD segment")
}
if note.desc != "testshared/depBase\n" {
t.Errorf("incorrect package list %q, want %q", note.desc, "testshared/depBase\n")
}
}
// The shared library contains a note containing the ABI hash that is mapped into
// memory and there is a local symbol called go.link.abihashbytes that points 16
// bytes into it.
func testABIHashNote(t *testing.T, f *elf.File, note *note) {
if note.section.Flags != elf.SHF_ALLOC {
t.Errorf("abi hash section has flags %v, want SHF_ALLOC", note.section.Flags)
}
if !isOffsetLoaded(f, note.section.Offset) {
t.Errorf("abihash section not contained in PT_LOAD segment")
}
var hashbytes elf.Symbol
symbols, err := f.Symbols()
if err != nil {
t.Errorf("error reading symbols %v", err)
return
}
for _, sym := range symbols {
if sym.Name == "go.link.abihashbytes" {
hashbytes = sym
}
}
if hashbytes.Name == "" {
t.Errorf("no symbol called go.link.abihashbytes")
return
}
if elf.ST_BIND(hashbytes.Info) != elf.STB_LOCAL {
t.Errorf("%s has incorrect binding %v, want STB_LOCAL", hashbytes.Name, elf.ST_BIND(hashbytes.Info))
}
if f.Sections[hashbytes.Section] != note.section {
t.Errorf("%s has incorrect section %v, want %s", hashbytes.Name, f.Sections[hashbytes.Section].Name, note.section.Name)
}
if hashbytes.Value-note.section.Addr != 16 {
t.Errorf("%s has incorrect offset into section %d, want 16", hashbytes.Name, hashbytes.Value-note.section.Addr)
}
}
// A Go shared library contains a note indicating which other Go shared libraries it
// was linked against in an unmapped section.
func testDepsNote(t *testing.T, f *elf.File, note *note) {
if note.section.Flags != 0 {
t.Errorf("package list section has flags %v, want 0", note.section.Flags)
}
if isOffsetLoaded(f, note.section.Offset) {
t.Errorf("package list section contained in PT_LOAD segment")
}
// libdepBase.so just links against the lib containing the runtime.
if note.desc != soname {
t.Errorf("incorrect dependency list %q, want %q", note.desc, soname)
}
}
// The shared library contains notes with defined contents; see above.
func TestNotes(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
shlib := goCmd(t, "list", "-f", "{{.Shlib}}", "-buildmode=shared", "-linkshared", "./depBase")
f, err := elf.Open(shlib)
if err != nil {
t.Fatal(err)
}
defer f.Close()
notes, err := readNotes(f)
if err != nil {
t.Fatal(err)
}
pkgListNoteFound := false
abiHashNoteFound := false
depsNoteFound := false
for _, note := range notes {
if note.name != "Go\x00\x00" {
continue
}
switch note.tag {
case 1: // ELF_NOTE_GOPKGLIST_TAG
if pkgListNoteFound {
t.Error("multiple package list notes")
}
testPkgListNote(t, f, note)
pkgListNoteFound = true
case 2: // ELF_NOTE_GOABIHASH_TAG
if abiHashNoteFound {
t.Error("multiple abi hash notes")
}
testABIHashNote(t, f, note)
abiHashNoteFound = true
case 3: // ELF_NOTE_GODEPS_TAG
if depsNoteFound {
t.Error("multiple dependency list notes")
}
testDepsNote(t, f, note)
depsNoteFound = true
}
}
if !pkgListNoteFound {
t.Error("package list note not found")
}
if !abiHashNoteFound {
t.Error("abi hash note not found")
}
if !depsNoteFound {
t.Error("deps note not found")
}
}
// Build a GOPATH package (depBase) into a shared library that links against the goroot
// runtime, another package (dep2) that links against the first, and an
// executable that links against dep2.
func TestTwoGopathShlibs(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./dep2")
goCmd(t, "install", "-linkshared", "./exe2")
run(t, "executable linked to GOPATH library", "../../bin/exe2")
}
func TestThreeGopathShlibs(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./dep2")
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./dep3")
goCmd(t, "install", "-linkshared", "./exe3")
run(t, "executable linked to GOPATH library", "../../bin/exe3")
}
// If gccgo is not available or not new enough, call t.Skip.
func requireGccgo(t *testing.T) {
t.Helper()
gccgoName := os.Getenv("GCCGO")
if gccgoName == "" {
gccgoName = "gccgo"
}
gccgoPath, err := exec.LookPath(gccgoName)
if err != nil {
t.Skip("gccgo not found")
}
cmd := exec.Command(gccgoPath, "-dumpversion")
output, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("%s -dumpversion failed: %v\n%s", gccgoPath, err, output)
}
if string(output) < "5" {
t.Skipf("gccgo too old (%s)", strings.TrimSpace(string(output)))
}
gomod, err := exec.Command("go", "env", "GOMOD").Output()
if err != nil {
t.Fatalf("go env GOMOD: %v", err)
}
if len(bytes.TrimSpace(gomod)) > 0 {
t.Skipf("gccgo not supported in module mode; see golang.org/issue/30344")
}
}
// Build a GOPATH package into a shared library with gccgo and an executable that
// links against it.
func TestGoPathShlibGccgo(t *testing.T) {
requireGccgo(t)
libgoRE := regexp.MustCompile("libgo.so.[0-9]+")
goCmd(t, "install", "-compiler=gccgo", "-buildmode=shared", "-linkshared", "./depBase")
// Run 'go list' after 'go install': with gccgo, we apparently don't know the
// shlib location until after we've installed it.
shlib := goCmd(t, "list", "-compiler=gccgo", "-buildmode=shared", "-linkshared", "-f", "{{.Shlib}}", "./depBase")
AssertIsLinkedToRegexp(t, shlib, libgoRE)
goCmd(t, "install", "-compiler=gccgo", "-linkshared", "./exe")
AssertIsLinkedToRegexp(t, "../../bin/exe", libgoRE)
AssertIsLinkedTo(t, "../../bin/exe", filepath.Base(shlib))
AssertHasRPath(t, "../../bin/exe", filepath.Dir(shlib))
// And check it runs.
run(t, "gccgo-built", "../../bin/exe")
}
// The gccgo version of TestTwoGopathShlibs: build a GOPATH package into a shared
// library with gccgo, another GOPATH package that depends on the first and an
// executable that links the second library.
func TestTwoGopathShlibsGccgo(t *testing.T) {
requireGccgo(t)
libgoRE := regexp.MustCompile("libgo.so.[0-9]+")
goCmd(t, "install", "-compiler=gccgo", "-buildmode=shared", "-linkshared", "./depBase")
goCmd(t, "install", "-compiler=gccgo", "-buildmode=shared", "-linkshared", "./dep2")
goCmd(t, "install", "-compiler=gccgo", "-linkshared", "./exe2")
// Run 'go list' after 'go install': with gccgo, we apparently don't know the
// shlib location until after we've installed it.
dep2 := goCmd(t, "list", "-compiler=gccgo", "-buildmode=shared", "-linkshared", "-f", "{{.Shlib}}", "./dep2")
depBase := goCmd(t, "list", "-compiler=gccgo", "-buildmode=shared", "-linkshared", "-f", "{{.Shlib}}", "./depBase")
AssertIsLinkedToRegexp(t, depBase, libgoRE)
AssertIsLinkedToRegexp(t, dep2, libgoRE)
AssertIsLinkedTo(t, dep2, filepath.Base(depBase))
AssertIsLinkedToRegexp(t, "../../bin/exe2", libgoRE)
AssertIsLinkedTo(t, "../../bin/exe2", filepath.Base(dep2))
AssertIsLinkedTo(t, "../../bin/exe2", filepath.Base(depBase))
// And check it runs.
run(t, "gccgo-built", "../../bin/exe2")
}
// Testing rebuilding of shared libraries when they are stale is a bit more
// complicated that it seems like it should be. First, we make everything "old": but
// only a few seconds old, or it might be older than gc (or the runtime source) and
// everything will get rebuilt. Then define a timestamp slightly newer than this
// time, which is what we set the mtime to of a file to cause it to be seen as new,
// and finally another slightly even newer one that we can compare files against to
// see if they have been rebuilt.
var oldTime = time.Now().Add(-9 * time.Second)
var nearlyNew = time.Now().Add(-6 * time.Second)
var stampTime = time.Now().Add(-3 * time.Second)
// resetFileStamps makes "everything" (bin, src, pkg from GOPATH and the
// test-specific parts of GOROOT) appear old.
func resetFileStamps() {
chtime := func(path string, info os.FileInfo, err error) error {
return os.Chtimes(path, oldTime, oldTime)
}
reset := func(path string) {
if err := filepath.Walk(path, chtime); err != nil {
log.Fatalf("resetFileStamps failed: %v", err)
}
}
reset("../../bin")
reset("../../pkg")
reset("../../src")
reset(gorootInstallDir)
}
// touch changes path and returns a function that changes it back.
// It also sets the time of the file, so that we can see if it is rewritten.
func touch(t *testing.T, path string) (cleanup func()) {
data, err := ioutil.ReadFile(path)
if err != nil {
t.Fatal(err)
}
old := make([]byte, len(data))
copy(old, data)
if bytes.HasPrefix(data, []byte("!<arch>\n")) {
// Change last digit of build ID.
// (Content ID in the new content-based build IDs.)
const marker = `build id "`
i := bytes.Index(data, []byte(marker))
if i < 0 {
t.Fatal("cannot find build id in archive")
}
j := bytes.IndexByte(data[i+len(marker):], '"')
if j < 0 {
t.Fatal("cannot find build id in archive")
}
i += len(marker) + j - 1
if data[i] == 'a' {
data[i] = 'b'
} else {
data[i] = 'a'
}
} else {
// assume it's a text file
data = append(data, '\n')
}
if err := ioutil.WriteFile(path, data, 0666); err != nil {
t.Fatal(err)
}
if err := os.Chtimes(path, nearlyNew, nearlyNew); err != nil {
t.Fatal(err)
}
return func() {
if err := ioutil.WriteFile(path, old, 0666); err != nil {
t.Fatal(err)
}
}
}
// isNew returns if the path is newer than the time stamp used by touch.
func isNew(t *testing.T, path string) bool {
t.Helper()
fi, err := os.Stat(path)
if err != nil {
t.Fatal(err)
}
return fi.ModTime().After(stampTime)
}
// Fail unless path has been rebuilt (i.e. is newer than the time stamp used by
// isNew)
func AssertRebuilt(t *testing.T, msg, path string) {
t.Helper()
if !isNew(t, path) {
t.Errorf("%s was not rebuilt (%s)", msg, path)
}
}
// Fail if path has been rebuilt (i.e. is newer than the time stamp used by isNew)
func AssertNotRebuilt(t *testing.T, msg, path string) {
t.Helper()
if isNew(t, path) {
t.Errorf("%s was rebuilt (%s)", msg, path)
}
}
func TestRebuilding(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
goCmd(t, "install", "-linkshared", "./exe")
info := strings.Fields(goCmd(t, "list", "-buildmode=shared", "-linkshared", "-f", "{{.Target}} {{.Shlib}}", "./depBase"))
if len(info) != 2 {
t.Fatalf("go list failed to report Target and/or Shlib")
}
target := info[0]
shlib := info[1]
// If the source is newer than both the .a file and the .so, both are rebuilt.
t.Run("newsource", func(t *testing.T) {
resetFileStamps()
cleanup := touch(t, "./depBase/dep.go")
defer func() {
cleanup()
goCmd(t, "install", "-linkshared", "./exe")
}()
goCmd(t, "install", "-linkshared", "./exe")
AssertRebuilt(t, "new source", target)
AssertRebuilt(t, "new source", shlib)
})
// If the .a file is newer than the .so, the .so is rebuilt (but not the .a)
t.Run("newarchive", func(t *testing.T) {
resetFileStamps()
AssertNotRebuilt(t, "new .a file before build", target)
goCmd(t, "list", "-linkshared", "-f={{.ImportPath}} {{.Stale}} {{.StaleReason}} {{.Target}}", "./depBase")
AssertNotRebuilt(t, "new .a file before build", target)
cleanup := touch(t, target)
defer func() {
cleanup()
goCmd(t, "install", "-v", "-linkshared", "./exe")
}()
goCmd(t, "install", "-v", "-linkshared", "./exe")
AssertNotRebuilt(t, "new .a file", target)
AssertRebuilt(t, "new .a file", shlib)
})
}
func appendFile(t *testing.T, path, content string) {
t.Helper()
f, err := os.OpenFile(path, os.O_WRONLY|os.O_APPEND, 0660)
if err != nil {
t.Fatalf("os.OpenFile failed: %v", err)
}
defer func() {
err := f.Close()
if err != nil {
t.Fatalf("f.Close failed: %v", err)
}
}()
_, err = f.WriteString(content)
if err != nil {
t.Fatalf("f.WriteString failed: %v", err)
}
}
func createFile(t *testing.T, path, content string) {
t.Helper()
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
if err != nil {
t.Fatalf("os.OpenFile failed: %v", err)
}
_, err = f.WriteString(content)
if closeErr := f.Close(); err == nil {
err = closeErr
}
if err != nil {
t.Fatalf("WriteString failed: %v", err)
}
}
func TestABIChecking(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
goCmd(t, "install", "-linkshared", "./exe")
// If we make an ABI-breaking change to depBase and rebuild libp.so but not exe,
// exe will abort with a complaint on startup.
// This assumes adding an exported function breaks ABI, which is not true in
// some senses but suffices for the narrow definition of ABI compatibility the
// toolchain uses today.
resetFileStamps()
createFile(t, "./depBase/break.go", "package depBase\nfunc ABIBreak() {}\n")
defer os.Remove("./depBase/break.go")
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
c := exec.Command("../../bin/exe")
output, err := c.CombinedOutput()
if err == nil {
t.Fatal("executing exe did not fail after ABI break")
}
scanner := bufio.NewScanner(bytes.NewReader(output))
foundMsg := false
const wantPrefix = "abi mismatch detected between the executable and lib"
for scanner.Scan() {
if strings.HasPrefix(scanner.Text(), wantPrefix) {
foundMsg = true
break
}
}
if err = scanner.Err(); err != nil {
t.Errorf("scanner encountered error: %v", err)
}
if !foundMsg {
t.Fatalf("exe failed, but without line %q; got output:\n%s", wantPrefix, output)
}
// Rebuilding exe makes it work again.
goCmd(t, "install", "-linkshared", "./exe")
run(t, "rebuilt exe", "../../bin/exe")
// If we make a change which does not break ABI (such as adding an unexported
// function) and rebuild libdepBase.so, exe still works, even if new function
// is in a file by itself.
resetFileStamps()
createFile(t, "./depBase/dep2.go", "package depBase\nfunc noABIBreak() {}\n")
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./depBase")
run(t, "after non-ABI breaking change", "../../bin/exe")
}
// If a package 'explicit' imports a package 'implicit', building
// 'explicit' into a shared library implicitly includes implicit in
// the shared library. Building an executable that imports both
// explicit and implicit builds the code from implicit into the
// executable rather than fetching it from the shared library. The
// link still succeeds and the executable still runs though.
func TestImplicitInclusion(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./explicit")
goCmd(t, "install", "-linkshared", "./implicitcmd")
run(t, "running executable linked against library that contains same package as it", "../../bin/implicitcmd")
}
// Tests to make sure that the type fields of empty interfaces and itab
// fields of nonempty interfaces are unique even across modules,
// so that interface equality works correctly.
func TestInterface(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./iface_a")
// Note: iface_i gets installed implicitly as a dependency of iface_a.
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./iface_b")
goCmd(t, "install", "-linkshared", "./iface")
run(t, "running type/itab uniqueness tester", "../../bin/iface")
}
// Access a global variable from a library.
func TestGlobal(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./globallib")
goCmd(t, "install", "-linkshared", "./global")
run(t, "global executable", "../../bin/global")
AssertIsLinkedTo(t, "../../bin/global", soname)
AssertHasRPath(t, "../../bin/global", gorootInstallDir)
}
// Run a test using -linkshared of an installed shared package.
// Issue 26400.
func TestTestInstalledShared(t *testing.T) {
goCmd(nil, "test", "-linkshared", "-test.short", "sync/atomic")
}
// Test generated pointer method with -linkshared.
// Issue 25065.
func TestGeneratedMethod(t *testing.T) {
goCmd(t, "install", "-buildmode=shared", "-linkshared", "./issue25065")
}
|
[
"\"GCCGO\""
] |
[] |
[
"GCCGO"
] |
[]
|
["GCCGO"]
|
go
| 1 | 0 | |
gorush/notification_apns_test.go
|
package gorush
import (
"context"
"encoding/json"
"log"
"net/http"
"net/url"
"os"
"testing"
"time"
"github.com/appleboy/gorush/config"
"github.com/buger/jsonparser"
"github.com/sideshow/apns2"
"github.com/stretchr/testify/assert"
)
const certificateValidP12 = `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`
const certificateValidPEM = `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`
const authkeyInvalidP8 = `TUlHSEFnRUFNQk1HQnlxR1NNNDlBZ0VHQ0NxR1NNNDlBd0VIQkcwd2F3SUJBUVFnRWJWemZQblpQeGZBeXhxRQpaVjA1bGFBb0pBbCsvNlh0Mk80bU9CNjExc09oUkFOQ0FBU2dGVEtqd0pBQVU5NWcrKy92ektXSGt6QVZtTk1JCnRCNXZUalpPT0l3bkViNzBNc1daRkl5VUZEMVA5R3dzdHo0K2FrSFg3dkk4Qkg2aEhtQm1mWlpaCg==`
const authkeyValidP8 = `LS0tLS1CRUdJTiBQUklWQVRFIEtFWS0tLS0tCk1JR0hBZ0VBTUJNR0J5cUdTTTQ5QWdFR0NDcUdTTTQ5QXdFSEJHMHdhd0lCQVFRZ0ViVnpmUG5aUHhmQXl4cUUKWlYwNWxhQW9KQWwrLzZYdDJPNG1PQjYxMXNPaFJBTkNBQVNnRlRLandKQUFVOTVnKysvdnpLV0hrekFWbU5NSQp0QjV2VGpaT09Jd25FYjcwTXNXWkZJeVVGRDFQOUd3c3R6NCtha0hYN3ZJOEJINmhIbUJtZmVRbAotLS0tLUVORCBQUklWQVRFIEtFWS0tLS0tCg==`
func TestDisabledAndroidIosConf(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Android.Enabled = false
PushConf.Huawei.Enabled = false
err := CheckPushConf()
assert.Error(t, err)
assert.Equal(t, "Please enable iOS, Android or Huawei config in yml config", err.Error())
}
func TestMissingIOSCertificate(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = ""
PushConf.Ios.KeyBase64 = ""
err := CheckPushConf()
assert.Error(t, err)
assert.Equal(t, "Missing iOS certificate key", err.Error())
PushConf.Ios.KeyPath = "test.pem"
err = CheckPushConf()
assert.Error(t, err)
assert.Equal(t, "certificate file does not exist", err.Error())
}
func TestIOSNotificationStructure(t *testing.T) {
var dat map[string]interface{}
var unix = time.Now().Unix()
test := "test"
expectBadge := 0
message := "Welcome notification Server"
expiration := int64(time.Now().Unix())
req := PushNotification{
ApnsID: test,
Topic: test,
Expiration: &expiration,
Priority: "normal",
Message: message,
Badge: &expectBadge,
Sound: Sound{
Critical: 1,
Name: test,
Volume: 1.0,
},
ContentAvailable: true,
Data: D{
"key1": "test",
"key2": 2,
},
Category: test,
URLArgs: []string{"a", "b"},
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
panic(err)
}
alert, _ := jsonparser.GetString(data, "aps", "alert")
badge, _ := jsonparser.GetInt(data, "aps", "badge")
soundName, _ := jsonparser.GetString(data, "aps", "sound", "name")
soundCritical, _ := jsonparser.GetInt(data, "aps", "sound", "critical")
soundVolume, _ := jsonparser.GetFloat(data, "aps", "sound", "volume")
contentAvailable, _ := jsonparser.GetInt(data, "aps", "content-available")
category, _ := jsonparser.GetString(data, "aps", "category")
key1 := dat["key1"].(interface{})
key2 := dat["key2"].(interface{})
aps := dat["aps"].(map[string]interface{})
urlArgs := aps["url-args"].([]interface{})
assert.Equal(t, test, notification.ApnsID)
assert.Equal(t, test, notification.Topic)
assert.Equal(t, unix, notification.Expiration.Unix())
assert.Equal(t, ApnsPriorityLow, notification.Priority)
assert.Equal(t, message, alert)
assert.Equal(t, expectBadge, int(badge))
assert.Equal(t, expectBadge, *req.Badge)
assert.Equal(t, test, soundName)
assert.Equal(t, 1.0, soundVolume)
assert.Equal(t, int64(1), soundCritical)
assert.Equal(t, 1, int(contentAvailable))
assert.Equal(t, "test", key1)
assert.Equal(t, 2, int(key2.(float64)))
assert.Equal(t, test, category)
assert.Contains(t, urlArgs, "a")
assert.Contains(t, urlArgs, "b")
}
func TestIOSSoundAndVolume(t *testing.T) {
var dat map[string]interface{}
test := "test"
message := "Welcome notification Server"
req := PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
Message: message,
Sound: Sound{
Critical: 3,
Name: test,
Volume: 4.5,
},
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
panic(err)
}
alert, _ := jsonparser.GetString(data, "aps", "alert")
soundName, _ := jsonparser.GetString(data, "aps", "sound", "name")
soundCritical, _ := jsonparser.GetInt(data, "aps", "sound", "critical")
soundVolume, _ := jsonparser.GetFloat(data, "aps", "sound", "volume")
assert.Equal(t, test, notification.ApnsID)
assert.Equal(t, test, notification.Topic)
assert.Equal(t, ApnsPriorityLow, notification.Priority)
assert.Equal(t, message, alert)
assert.Equal(t, test, soundName)
assert.Equal(t, 4.5, soundVolume)
assert.Equal(t, int64(3), soundCritical)
req.SoundName = "foobar"
req.SoundVolume = 5.5
notification = GetIOSNotification(req)
dump, _ = json.Marshal(notification.Payload)
data = []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
panic(err)
}
soundName, _ = jsonparser.GetString(data, "aps", "sound", "name")
soundVolume, _ = jsonparser.GetFloat(data, "aps", "sound", "volume")
soundCritical, _ = jsonparser.GetInt(data, "aps", "sound", "critical")
assert.Equal(t, 5.5, soundVolume)
assert.Equal(t, int64(1), soundCritical)
assert.Equal(t, "foobar", soundName)
req = PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
Message: message,
Sound: map[string]interface{}{
"critical": 3,
"name": "test",
"volume": 4.5,
},
}
notification = GetIOSNotification(req)
dump, _ = json.Marshal(notification.Payload)
data = []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
panic(err)
}
soundName, _ = jsonparser.GetString(data, "aps", "sound", "name")
soundVolume, _ = jsonparser.GetFloat(data, "aps", "sound", "volume")
soundCritical, _ = jsonparser.GetInt(data, "aps", "sound", "critical")
assert.Equal(t, 4.5, soundVolume)
assert.Equal(t, int64(3), soundCritical)
assert.Equal(t, "test", soundName)
req = PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
Message: message,
Sound: "default",
}
notification = GetIOSNotification(req)
dump, _ = json.Marshal(notification.Payload)
data = []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
panic(err)
}
soundName, _ = jsonparser.GetString(data, "aps", "sound")
assert.Equal(t, "default", soundName)
}
func TestIOSSummaryArg(t *testing.T) {
var dat map[string]interface{}
test := "test"
message := "Welcome notification Server"
req := PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
Message: message,
Alert: Alert{
SummaryArg: "test",
SummaryArgCount: 3,
},
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
panic(err)
}
assert.Equal(t, test, notification.ApnsID)
assert.Equal(t, test, notification.Topic)
assert.Equal(t, ApnsPriorityLow, notification.Priority)
assert.Equal(t, "test", dat["aps"].(map[string]interface{})["alert"].(map[string]interface{})["summary-arg"])
assert.Equal(t, float64(3), dat["aps"].(map[string]interface{})["alert"].(map[string]interface{})["summary-arg-count"])
}
// Silent Notification which payload’s aps dictionary must not contain the alert, sound, or badge keys.
// ref: https://goo.gl/m9xyqG
func TestSendZeroValueForBadgeKey(t *testing.T) {
var dat map[string]interface{}
test := "test"
message := "Welcome notification Server"
req := PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
Message: message,
Sound: test,
ContentAvailable: true,
MutableContent: true,
ThreadID: test,
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
alert, _ := jsonparser.GetString(data, "aps", "alert")
badge, _ := jsonparser.GetInt(data, "aps", "badge")
sound, _ := jsonparser.GetString(data, "aps", "sound")
threadID, _ := jsonparser.GetString(data, "aps", "thread-id")
contentAvailable, _ := jsonparser.GetInt(data, "aps", "content-available")
mutableContent, _ := jsonparser.GetInt(data, "aps", "mutable-content")
if req.Badge != nil {
t.Errorf("req.Badge must be nil")
}
assert.Equal(t, test, notification.ApnsID)
assert.Equal(t, test, notification.Topic)
assert.Equal(t, ApnsPriorityLow, notification.Priority)
assert.Equal(t, message, alert)
assert.Equal(t, 0, int(badge))
assert.Equal(t, test, sound)
assert.Equal(t, test, threadID)
assert.Equal(t, 1, int(contentAvailable))
assert.Equal(t, 1, int(mutableContent))
// Add Bage
expectBadge := 10
req.Badge = &expectBadge
notification = GetIOSNotification(req)
dump, _ = json.Marshal(notification.Payload)
data = []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
if req.Badge == nil {
t.Errorf("req.Badge must be equal %d", *req.Badge)
}
badge, _ = jsonparser.GetInt(data, "aps", "badge")
assert.Equal(t, expectBadge, *req.Badge)
assert.Equal(t, expectBadge, int(badge))
}
// Silent Notification:
// The payload’s aps dictionary must include the content-available key with a value of 1.
// The payload’s aps dictionary must not contain the alert, sound, or badge keys.
// ref: https://goo.gl/m9xyqG
func TestCheckSilentNotification(t *testing.T) {
var dat map[string]interface{}
test := "test"
req := PushNotification{
ApnsID: test,
Topic: test,
CollapseID: test,
Priority: "normal",
ContentAvailable: true,
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
assert.Equal(t, test, notification.CollapseID)
assert.Equal(t, test, notification.ApnsID)
assert.Equal(t, test, notification.Topic)
assert.Nil(t, dat["aps"].(map[string]interface{})["alert"])
assert.Nil(t, dat["aps"].(map[string]interface{})["sound"])
assert.Nil(t, dat["aps"].(map[string]interface{})["badge"])
}
// URL: https://goo.gl/5xFo3C
// Example 2
// {
// "aps" : {
// "alert" : {
// "title" : "Game Request",
// "body" : "Bob wants to play poker",
// "action-loc-key" : "PLAY"
// },
// "badge" : 5
// },
// "acme1" : "bar",
// "acme2" : [ "bang", "whiz" ]
// }
func TestAlertStringExample2ForIos(t *testing.T) {
var dat map[string]interface{}
test := "test"
title := "Game Request"
body := "Bob wants to play poker"
actionLocKey := "PLAY"
req := PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
Alert: Alert{
Title: title,
Body: body,
ActionLocKey: actionLocKey,
},
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
assert.Equal(t, title, dat["aps"].(map[string]interface{})["alert"].(map[string]interface{})["title"])
assert.Equal(t, body, dat["aps"].(map[string]interface{})["alert"].(map[string]interface{})["body"])
assert.Equal(t, actionLocKey, dat["aps"].(map[string]interface{})["alert"].(map[string]interface{})["action-loc-key"])
}
// URL: https://goo.gl/5xFo3C
// Example 3
// {
// "aps" : {
// "alert" : "You got your emails.",
// "badge" : 9,
// "sound" : "bingbong.aiff"
// },
// "acme1" : "bar",
// "acme2" : 42
// }
func TestAlertStringExample3ForIos(t *testing.T) {
var dat map[string]interface{}
test := "test"
badge := 9
sound := "bingbong.aiff"
req := PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
ContentAvailable: true,
Message: test,
Badge: &badge,
Sound: sound,
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
assert.Equal(t, sound, dat["aps"].(map[string]interface{})["sound"])
assert.Equal(t, float64(badge), dat["aps"].(map[string]interface{})["badge"].(float64))
assert.Equal(t, test, dat["aps"].(map[string]interface{})["alert"])
}
func TestMessageAndTitle(t *testing.T) {
var dat map[string]interface{}
test := "test"
message := "Welcome notification Server"
title := "Welcome notification Server title"
req := PushNotification{
ApnsID: test,
Topic: test,
Priority: "normal",
Message: message,
Title: title,
ContentAvailable: true,
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
alert, _ := jsonparser.GetString(data, "aps", "alert")
alertBody, _ := jsonparser.GetString(data, "aps", "alert", "body")
alertTitle, _ := jsonparser.GetString(data, "aps", "alert", "title")
assert.Equal(t, test, notification.ApnsID)
assert.Equal(t, ApnsPriorityLow, notification.Priority)
assert.Equal(t, message, alertBody)
assert.Equal(t, title, alertTitle)
assert.NotEqual(t, message, alert)
// Add alert body
messageOverride := "Welcome notification Server overridden"
req.Alert.Body = messageOverride
notification = GetIOSNotification(req)
dump, _ = json.Marshal(notification.Payload)
data = []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
alertBodyOverridden, _ := jsonparser.GetString(data, "aps", "alert", "body")
alertTitle, _ = jsonparser.GetString(data, "aps", "alert", "title")
assert.Equal(t, messageOverride, alertBodyOverridden)
assert.NotEqual(t, message, alertBodyOverridden)
assert.Equal(t, title, alertTitle)
}
func TestIOSAlertNotificationStructure(t *testing.T) {
var dat map[string]interface{}
test := "test"
req := PushNotification{
Message: "Welcome",
Title: test,
Alert: Alert{
Action: test,
ActionLocKey: test,
Body: test,
LaunchImage: test,
LocArgs: []string{"a", "b"},
LocKey: test,
Subtitle: test,
TitleLocArgs: []string{"a", "b"},
TitleLocKey: test,
},
}
notification := GetIOSNotification(req)
dump, _ := json.Marshal(notification.Payload)
data := []byte(string(dump))
if err := json.Unmarshal(data, &dat); err != nil {
log.Println(err)
panic(err)
}
action, _ := jsonparser.GetString(data, "aps", "alert", "action")
actionLocKey, _ := jsonparser.GetString(data, "aps", "alert", "action-loc-key")
body, _ := jsonparser.GetString(data, "aps", "alert", "body")
launchImage, _ := jsonparser.GetString(data, "aps", "alert", "launch-image")
locKey, _ := jsonparser.GetString(data, "aps", "alert", "loc-key")
title, _ := jsonparser.GetString(data, "aps", "alert", "title")
subtitle, _ := jsonparser.GetString(data, "aps", "alert", "subtitle")
titleLocKey, _ := jsonparser.GetString(data, "aps", "alert", "title-loc-key")
aps := dat["aps"].(map[string]interface{})
alert := aps["alert"].(map[string]interface{})
titleLocArgs := alert["title-loc-args"].([]interface{})
locArgs := alert["loc-args"].([]interface{})
assert.Equal(t, test, action)
assert.Equal(t, test, actionLocKey)
assert.Equal(t, test, body)
assert.Equal(t, test, launchImage)
assert.Equal(t, test, locKey)
assert.Equal(t, test, title)
assert.Equal(t, test, subtitle)
assert.Equal(t, test, titleLocKey)
assert.Contains(t, titleLocArgs, "a")
assert.Contains(t, titleLocArgs, "b")
assert.Contains(t, locArgs, "a")
assert.Contains(t, locArgs, "b")
}
func TestDisabledIosNotifications(t *testing.T) {
ctx := context.Background()
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = false
PushConf.Ios.KeyPath = "../certificate/certificate-valid.pem"
err := InitAPNSClient()
assert.Nil(t, err)
PushConf.Android.Enabled = true
PushConf.Android.APIKey = os.Getenv("ANDROID_API_KEY")
androidToken := os.Getenv("ANDROID_TEST_TOKEN")
req := RequestPush{
Notifications: []PushNotification{
//ios
{
Tokens: []string{"11aa01229f15f0f0c52029d8cf8cd0aeaf2365fe4cebc4af26cd6d76b7919ef7"},
Platform: PlatFormIos,
Message: "Welcome",
},
// android
{
Tokens: []string{androidToken, androidToken + "_"},
Platform: PlatFormAndroid,
Message: "Welcome",
},
},
}
count, logs := queueNotification(ctx, req)
assert.Equal(t, 2, count)
assert.Equal(t, 0, len(logs))
}
func TestWrongIosCertificateExt(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "test"
err := InitAPNSClient()
assert.Error(t, err)
assert.Equal(t, "wrong certificate key extension", err.Error())
PushConf.Ios.KeyPath = ""
PushConf.Ios.KeyBase64 = "abcd"
PushConf.Ios.KeyType = "abcd"
err = InitAPNSClient()
assert.Error(t, err)
assert.Equal(t, "wrong certificate key type", err.Error())
}
func TestAPNSClientDevHost(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "../certificate/certificate-valid.p12"
err := InitAPNSClient()
assert.Nil(t, err)
assert.Equal(t, apns2.HostDevelopment, ApnsClient.Host)
PushConf.Ios.KeyPath = ""
PushConf.Ios.KeyBase64 = certificateValidP12
PushConf.Ios.KeyType = "p12"
err = InitAPNSClient()
assert.Nil(t, err)
assert.Equal(t, apns2.HostDevelopment, ApnsClient.Host)
}
func TestAPNSClientProdHost(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.Production = true
PushConf.Ios.KeyPath = "../certificate/certificate-valid.pem"
err := InitAPNSClient()
assert.Nil(t, err)
assert.Equal(t, apns2.HostProduction, ApnsClient.Host)
PushConf.Ios.KeyPath = ""
PushConf.Ios.KeyBase64 = certificateValidPEM
PushConf.Ios.KeyType = "pem"
err = InitAPNSClient()
assert.Nil(t, err)
assert.Equal(t, apns2.HostProduction, ApnsClient.Host)
}
func TestAPNSClientInvaildToken(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "../certificate/authkey-invalid.p8"
err := InitAPNSClient()
assert.Error(t, err)
PushConf.Ios.KeyPath = ""
PushConf.Ios.KeyBase64 = authkeyInvalidP8
PushConf.Ios.KeyType = "p8"
err = InitAPNSClient()
assert.Error(t, err)
//empty key-id or team-id
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "../certificate/authkey-valid.p8"
err = InitAPNSClient()
assert.Error(t, err)
PushConf.Ios.KeyID = "key-id"
PushConf.Ios.TeamID = ""
err = InitAPNSClient()
assert.Error(t, err)
PushConf.Ios.KeyID = ""
PushConf.Ios.TeamID = "team-id"
err = InitAPNSClient()
assert.Error(t, err)
}
func TestAPNSClientVaildToken(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "../certificate/authkey-valid.p8"
PushConf.Ios.KeyID = "key-id"
PushConf.Ios.TeamID = "team-id"
err := InitAPNSClient()
assert.NoError(t, err)
assert.Equal(t, apns2.HostDevelopment, ApnsClient.Host)
PushConf.Ios.Production = true
err = InitAPNSClient()
assert.NoError(t, err)
assert.Equal(t, apns2.HostProduction, ApnsClient.Host)
// test base64
PushConf.Ios.Production = false
PushConf.Ios.KeyPath = ""
PushConf.Ios.KeyBase64 = authkeyValidP8
PushConf.Ios.KeyType = "p8"
err = InitAPNSClient()
assert.NoError(t, err)
assert.Equal(t, apns2.HostDevelopment, ApnsClient.Host)
PushConf.Ios.Production = true
err = InitAPNSClient()
assert.NoError(t, err)
assert.Equal(t, apns2.HostProduction, ApnsClient.Host)
}
func TestAPNSClientUseProxy(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "../certificate/certificate-valid.p12"
PushConf.Core.HTTPProxy = "http://127.0.0.1:8080"
_ = SetProxy(PushConf.Core.HTTPProxy)
err := InitAPNSClient()
assert.Nil(t, err)
assert.Equal(t, apns2.HostDevelopment, ApnsClient.Host)
req, _ := http.NewRequest("GET", apns2.HostDevelopment, nil)
actualProxyURL, err := ApnsClient.HTTPClient.Transport.(*http.Transport).Proxy(req)
assert.Nil(t, err)
expectedProxyURL, _ := url.ParseRequestURI(PushConf.Core.HTTPProxy)
assert.Equal(t, expectedProxyURL, actualProxyURL)
PushConf.Ios.KeyPath = "../certificate/authkey-valid.p8"
PushConf.Ios.TeamID = "example.team"
PushConf.Ios.KeyID = "example.key"
err = InitAPNSClient()
assert.Nil(t, err)
assert.Equal(t, apns2.HostDevelopment, ApnsClient.Host)
assert.NotNil(t, ApnsClient.Token)
req, _ = http.NewRequest("GET", apns2.HostDevelopment, nil)
actualProxyURL, err = ApnsClient.HTTPClient.Transport.(*http.Transport).Proxy(req)
assert.Nil(t, err)
expectedProxyURL, _ = url.ParseRequestURI(PushConf.Core.HTTPProxy)
assert.Equal(t, expectedProxyURL, actualProxyURL)
http.DefaultTransport.(*http.Transport).Proxy = nil
}
func TestPushToIOS(t *testing.T) {
PushConf, _ = config.LoadConf("")
MaxConcurrentIOSPushes = make(chan struct{}, PushConf.Ios.MaxConcurrentPushes)
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "../certificate/certificate-valid.pem"
err := InitAPNSClient()
assert.Nil(t, err)
err = InitAppStatus()
assert.Nil(t, err)
req := PushNotification{
Tokens: []string{"11aa01229f15f0f0c52029d8cf8cd0aeaf2365fe4cebc4af26cd6d76b7919ef7", "11aa01229f15f0f0c52029d8cf8cd0aeaf2365fe4cebc4af26cd6d76b7919ef1"},
Platform: 1,
Message: "Welcome",
}
// send fail
PushToIOS(req)
}
func TestApnsHostFromRequest(t *testing.T) {
PushConf, _ = config.LoadConf("")
PushConf.Ios.Enabled = true
PushConf.Ios.KeyPath = "../certificate/certificate-valid.pem"
err := InitAPNSClient()
assert.Nil(t, err)
err = InitAppStatus()
assert.Nil(t, err)
req := PushNotification{
Production: true,
}
client := getApnsClient(req)
assert.Equal(t, apns2.HostProduction, client.Host)
req = PushNotification{
Development: true,
}
client = getApnsClient(req)
assert.Equal(t, apns2.HostDevelopment, client.Host)
req = PushNotification{}
PushConf.Ios.Production = true
client = getApnsClient(req)
assert.Equal(t, apns2.HostProduction, client.Host)
PushConf.Ios.Production = false
client = getApnsClient(req)
assert.Equal(t, apns2.HostDevelopment, client.Host)
}
|
[
"\"ANDROID_API_KEY\"",
"\"ANDROID_TEST_TOKEN\""
] |
[] |
[
"ANDROID_TEST_TOKEN",
"ANDROID_API_KEY"
] |
[]
|
["ANDROID_TEST_TOKEN", "ANDROID_API_KEY"]
|
go
| 2 | 0 | |
pkg/testutils/integrationtestharness.go
|
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package testutils
import (
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/aws/aws-sdk-go/service/route53"
"github.com/golang/glog"
"io/ioutil"
"k8s.io/kops/cloudmock/aws/mockec2"
"k8s.io/kops/cloudmock/aws/mockroute53"
"k8s.io/kops/pkg/apis/kops"
"k8s.io/kops/upup/pkg/fi/cloudup/awsup"
"k8s.io/kops/util/pkg/vfs"
"os"
"path"
"path/filepath"
"testing"
)
type IntegrationTestHarness struct {
TempDir string
T *testing.T
// The original kops DefaultChannelBase value, restored on Close
originalDefaultChannelBase string
}
func NewIntegrationTestHarness(t *testing.T) *IntegrationTestHarness {
h := &IntegrationTestHarness{}
tempDir, err := ioutil.TempDir("", "test")
if err != nil {
t.Fatalf("failed to create temp dir: %v", err)
}
h.TempDir = tempDir
vfs.Context.ResetMemfsContext(true)
// Replace the default channel path with a local filesystem path, so we don't try to retrieve it from a server
{
channelPath, err := filepath.Abs(path.Join("../../channels/"))
if err != nil {
t.Fatalf("error resolving stable channel path: %v", err)
}
channelPath += "/"
h.originalDefaultChannelBase = kops.DefaultChannelBase
kops.DefaultChannelBase = "file://" + channelPath
}
return h
}
func (h *IntegrationTestHarness) Close() {
if h.TempDir != "" {
if os.Getenv("KEEP_TEMP_DIR") != "" {
glog.Infof("NOT removing temp directory, because KEEP_TEMP_DIR is set: %s", h.TempDir)
} else {
err := os.RemoveAll(h.TempDir)
if err != nil {
h.T.Fatalf("failed to remove temp dir %q: %v", h.TempDir, err)
}
}
}
if h.originalDefaultChannelBase != "" {
kops.DefaultChannelBase = h.originalDefaultChannelBase
}
}
func (h *IntegrationTestHarness) SetupMockAWS() {
cloud := awsup.InstallMockAWSCloud("us-test-1", "abc")
mockEC2 := &mockec2.MockEC2{}
cloud.MockEC2 = mockEC2
mockRoute53 := &mockroute53.MockRoute53{}
cloud.MockRoute53 = mockRoute53
mockRoute53.MockCreateZone(&route53.HostedZone{
Id: aws.String("/hostedzone/Z1AFAKE1ZON3YO"),
Name: aws.String("example.com."),
Config: &route53.HostedZoneConfig{
PrivateZone: aws.Bool(false),
},
}, nil)
mockRoute53.MockCreateZone(&route53.HostedZone{
Id: aws.String("/hostedzone/Z2AFAKE1ZON3NO"),
Name: aws.String("internal.example.com."),
Config: &route53.HostedZoneConfig{
PrivateZone: aws.Bool(true),
},
}, []*route53.VPC{{
VPCId: aws.String("vpc-234"),
}})
mockRoute53.MockCreateZone(&route53.HostedZone{
Id: aws.String("/hostedzone/Z3AFAKE1ZOMORE"),
Name: aws.String("private.example.com."),
Config: &route53.HostedZoneConfig{
PrivateZone: aws.Bool(true),
},
}, []*route53.VPC{{
VPCId: aws.String("vpc-123"),
}})
mockEC2.Images = append(mockEC2.Images, &ec2.Image{
ImageId: aws.String("ami-12345678"),
Name: aws.String("k8s-1.4-debian-jessie-amd64-hvm-ebs-2016-10-21"),
OwnerId: aws.String(awsup.WellKnownAccountKopeio),
RootDeviceName: aws.String("/dev/xvda"),
})
mockEC2.Images = append(mockEC2.Images, &ec2.Image{
ImageId: aws.String("ami-15000000"),
Name: aws.String("k8s-1.5-debian-jessie-amd64-hvm-ebs-2017-01-09"),
OwnerId: aws.String(awsup.WellKnownAccountKopeio),
RootDeviceName: aws.String("/dev/xvda"),
})
}
|
[
"\"KEEP_TEMP_DIR\""
] |
[] |
[
"KEEP_TEMP_DIR"
] |
[]
|
["KEEP_TEMP_DIR"]
|
go
| 1 | 0 | |
pilot/pkg/serviceregistry/kube/client.go
|
// Copyright 2017 Istio Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package kube implements the shared and reusable library for Kubernetes
package kube
import (
"fmt"
"os"
// TODO(nmittler): Remove this
_ "github.com/golang/glog"
multierror "github.com/hashicorp/go-multierror"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"os/user"
"istio.io/istio/pkg/log"
// import GKE cluster authentication plugin
_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
// import OIDC cluster authentication plugin, e.g. for Tectonic
_ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
)
// ResolveConfig checks whether to use the in-cluster or out-of-cluster config
func ResolveConfig(kubeconfig string) (string, error) {
// Consistency with kubectl
if kubeconfig == "" {
kubeconfig = os.Getenv("KUBECONFIG")
}
if kubeconfig == "" {
usr, err := user.Current()
if err == nil {
defaultCfg := usr.HomeDir + "/.kube/config"
_, err := os.Stat(kubeconfig)
if err != nil {
kubeconfig = defaultCfg
}
}
}
if kubeconfig != "" {
info, err := os.Stat(kubeconfig)
if err != nil {
if os.IsNotExist(err) {
err = fmt.Errorf("kubernetes configuration file %q does not exist", kubeconfig)
} else {
err = multierror.Append(err, fmt.Errorf("kubernetes configuration file %q", kubeconfig))
}
return "", err
}
// if it's an empty file, switch to in-cluster config
if info.Size() == 0 {
log.Info("using in-cluster configuration")
return "", nil
}
}
return kubeconfig, nil
}
// CreateInterface is a helper function to create Kubernetes interface
func CreateInterface(kubeconfig string) (*rest.Config, kubernetes.Interface, error) {
kube, err := ResolveConfig(kubeconfig)
if err != nil {
return nil, nil, err
}
config, err := clientcmd.BuildConfigFromFlags("", kube)
if err != nil {
return nil, nil, err
}
client, err := kubernetes.NewForConfig(config)
return config, client, err
}
|
[
"\"KUBECONFIG\""
] |
[] |
[
"KUBECONFIG"
] |
[]
|
["KUBECONFIG"]
|
go
| 1 | 0 | |
AMmodel/__init__.py
|
# Copyright 2020 Huy Le Nguyen (@usimarit)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import tensorflow as tf
def transfer_weights(source_model: tf.keras.Model,
target_model: tf.keras.Model):
"""
Function to transfer weights from trained model to other one
Args:
source_model: trained `tf.keras.Model`
target_model: target `tf.keras.Model`
Returns:
trained target_model
"""
target_model.set_weights(source_model.get_weights())
return target_model
def load_from_saved_model(model: tf.keras.Model,
saved_path: str):
"""
Load model from saved model path
Args:
model: newly built `tf.keras.Model`
saved_path: `str` path to saved model
Returns:
loaded model
"""
try:
saved_model = tf.keras.models.load_model(saved_path)
except Exception as e:
raise e
model = transfer_weights(saved_model, model)
return model
def load_from_weights(model: tf.keras.Model,
saved_path: str):
"""
Load model from saved weights path
Args:
model: newly built `tf.keras.Model`
saved_path: `str` path to saved weights
Returns:
loaded model
"""
try:
model.load_weights(saved_path)
except Exception as e:
raise e
return model
|
[] |
[] |
[] |
[]
|
[]
|
python
| null | null | null |
internal/cmdutil/cmdutil.go
|
package cmdutil
import (
"errors"
"fmt"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/planetscale/cli/internal/config"
"github.com/planetscale/cli/internal/printer"
ps "github.com/planetscale/planetscale-go/planetscale"
"github.com/spf13/cobra"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
exec "golang.org/x/sys/execabs"
)
const WarnAuthMessage = "not authenticated yet. Please run 'pscale auth login'" +
"or create a service token with 'pscale service-token create'"
// Helper is passed to every single command and is used by individual
// subcommands.
type Helper struct {
// Config contains globally sourced configuration
Config *config.Config
ConfigFS *config.ConfigFS
// Client returns the PlanetScale API client
Client func() (*ps.Client, error)
// Printer is used to print output of a command to stdout.
Printer *printer.Printer
// bebug defines the debug mode
debug *bool
}
func (h *Helper) SetDebug(debug *bool) {
h.debug = debug
}
func (h *Helper) Debug() bool { return *h.debug }
// required arguments are not available.
func RequiredArgs(reqArgs ...string) cobra.PositionalArgs {
return func(cmd *cobra.Command, args []string) error {
n := len(reqArgs)
if len(args) >= n {
return nil
}
missing := reqArgs[len(args):]
a := fmt.Sprintf("arguments <%s>", strings.Join(missing, ", "))
if len(missing) == 1 {
a = fmt.Sprintf("argument <%s>", missing[0])
}
return fmt.Errorf("missing %s \n\n%s", a, cmd.UsageString())
}
}
// CheckAuthentication checks whether the user is authenticated and returns a
// actionable error message.
func CheckAuthentication(cfg *config.Config) func(cmd *cobra.Command, args []string) error {
return func(cmd *cobra.Command, args []string) error {
if cfg.IsAuthenticated() {
return nil
}
return errors.New(WarnAuthMessage)
}
}
// NewZapLogger returns a logger to be used with the sql-proxy. By default it
// only outputs error leveled messages, unless debug is true.
func NewZapLogger(debug bool) *zap.Logger {
encoderCfg := zapcore.EncoderConfig{
MessageKey: "msg",
LevelKey: "level",
NameKey: "logger",
TimeKey: "T",
EncodeLevel: zapcore.LowercaseColorLevelEncoder,
EncodeTime: zapcore.RFC3339TimeEncoder,
EncodeDuration: zapcore.StringDurationEncoder,
}
level := zap.ErrorLevel
if debug {
level = zap.DebugLevel
}
logger := zap.New(zapcore.NewCore(zapcore.NewConsoleEncoder(encoderCfg), os.Stdout, level))
return logger
}
// IsUnderHomebrew checks whether the given binary is under the homebrew path.
// copied from: https://github.com/cli/cli/blob/trunk/cmd/gh/main.go#L298
func IsUnderHomebrew(binpath string) bool {
if binpath == "" {
return false
}
brewExe, err := exec.LookPath("brew")
if err != nil {
return false
}
brewPrefixBytes, err := exec.Command(brewExe, "--prefix").Output()
if err != nil {
return false
}
brewBinPrefix := filepath.Join(strings.TrimSpace(string(brewPrefixBytes)), "bin") + string(filepath.Separator)
return strings.HasPrefix(binpath, brewBinPrefix)
}
// HasHomebrew check whether the user has installed brew
func HasHomebrew() bool {
_, err := exec.LookPath("brew")
return err == nil
}
// MySQLClientPath checks whether the 'mysql' client exists and returns the
// path to the binary. The returned error contains instructions to install the
// client.
func MySQLClientPath() (string, error) {
// 'brew install mysql-client' installs the client into an unusual path
// https://docs.brew.sh/FAQ#why-should-i-install-homebrew-in-the-default-location
var homebrewPrefix string
switch runtime.GOOS {
case "darwin":
homebrewPrefix = "/usr/local"
if runtime.GOARCH == "arm64" {
homebrewPrefix = "/opt/homebrew"
}
case "linux":
homebrewPrefix = "/home/linuxbrew/.linuxbrew"
}
oldpath := os.Getenv("PATH")
newpath := homebrewPrefix + "/opt/mysql-client/bin/" + string(os.PathListSeparator) + oldpath
defer func() {
if err := os.Setenv("PATH", oldpath); err != nil {
fmt.Println("failed to restore PATH", err)
}
}()
if err := os.Setenv("PATH", newpath); err != nil {
return "", err
}
path, err := exec.LookPath("mysql")
if err == nil {
return path, nil
}
msg := "couldn't find the 'mysql' command-line tool required to run this command."
installURL := "https://docs.planetscale.com/reference/planetscale-environment-setup"
switch runtime.GOOS {
case "darwin":
if HasHomebrew() {
return "", fmt.Errorf("%s\nTo install, run: brew install mysql-client", msg)
}
installURL = "https://docs.planetscale.com/reference/planetscale-environment-setup#macos-instructions"
case "linux":
installURL = "https://docs.planetscale.com/reference/planetscale-environment-setup#linux-instructions"
case "windows":
installURL = "https://docs.planetscale.com/reference/planetscale-environment-setup#windows-instructions"
}
return "", fmt.Errorf("%s\nTo install, follow the instructions: %s", msg, installURL)
}
|
[
"\"PATH\""
] |
[] |
[
"PATH"
] |
[]
|
["PATH"]
|
go
| 1 | 0 | |
tools/openvino_dev/setup.py
|
#!/usr/bin/env python3
# Copyright (C) 2018-2021 Intel Corporation SPDX-License-Identifier: Apache-2.0
""" Use this script to create a openvino-dev wheel package:
$ python3 setup.py bdist_wheel
"""
# pylint: disable-msg=line-too-long
import os
import sys
import platform
import subprocess # nosec
import shutil
from distutils import log
from distutils.command.build import build
from distutils.command.clean import clean
from pathlib import Path
from fnmatch import fnmatchcase
import pkg_resources
from setuptools.command.install import install
from setuptools import setup, find_namespace_packages
PYTHON_VERSION = f'python{sys.version_info.major}.{sys.version_info.minor}'
SCRIPT_DIR = Path(__file__).resolve().parents[0]
OPENVINO_DIR = Path(__file__).resolve().parents[2]
SRC_DIR = SCRIPT_DIR / 'src'
PKG_INSTALL_CFG = {
'openvino-mo': {
'src_dir': OPENVINO_DIR / 'model-optimizer',
'black_list': ['*unit_tests*'],
'prefix': 'mo',
'extract_entry_points': True,
'extract_requirements': True,
'extract_extras': True,
},
'benchmark_tool': {
'src_dir': OPENVINO_DIR / 'tools' / 'benchmark_tool',
'black_list': [],
'prefix': 'benchmark_tool',
'extract_entry_points': True,
},
"accuracy_checker": {
'src_dir': OPENVINO_DIR / 'tools' / 'pot' / 'thirdparty' / 'open_model_zoo' / 'tools' / 'accuracy_checker', # noqa:E501
'black_list': ['*tests*'],
'prefix': 'accuracy_checker',
'extract_entry_points': True,
},
"omz_tools": {
'src_dir': OPENVINO_DIR / 'tools' / 'pot' / 'thirdparty' / 'open_model_zoo' / 'tools' / 'model_tools', # noqa:E501
'black_list': [],
'prefix': 'omz_tools',
'extract_requirements': True,
'extract_entry_points': True,
'extract_extras': True,
},
"pot": {
'src_dir': OPENVINO_DIR / 'tools' / 'pot',
'black_list': ['*tests*'],
'prefix': 'pot',
'extract_entry_points': True,
},
}
def ignore_patterns(*patterns):
"""
Filter names by given patterns
"""
return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns)
class CustomBuild(build):
"""Custom implementation of build"""
def run(self):
# pylint: disable-msg=too-many-locals
self.announce('Installing packages', level=log.INFO)
for cmp, cmp_data in PKG_INSTALL_CFG.items():
self.announce(f'Processing package: {cmp}', level=log.INFO)
subprocess.call([sys.executable, 'setup.py', 'install',
'--root', str(SCRIPT_DIR),
'--prefix', str(cmp_data.get("prefix"))],
cwd=str(cmp_data.get('src_dir')))
# grab installed modules
lib_dir = 'lib/site-packages' if platform.system() == 'Windows' else f'lib/{PYTHON_VERSION}/site-packages'
src = SCRIPT_DIR / cmp_data.get('prefix') / lib_dir
egg_info = list(src.glob('**/*.egg-info'))
if egg_info:
def raw_req(req):
req.marker = None
return str(req)
distributions = pkg_resources.find_distributions(str(Path(egg_info[0]).parent))
for dist in distributions:
self.announce(f'Distribution: {dist.egg_name()}', level=log.INFO)
# load install_requires list
install_requires = list(sorted(map(raw_req, dist.requires())))
self.announce(f'Install requires: {install_requires}', level=log.INFO)
if cmp_data.get("extract_requirements"):
self.distribution.install_requires.extend(install_requires)
# load extras_require
if cmp_data.get("extract_extras"):
for extra in dist.extras:
if extra not in self.distribution.extras_require:
self.distribution.extras_require[extra] = []
extras_require = set(map(raw_req, dist.requires((extra,))))
self.announce(f'Extras: {extra}:{extras_require}', level=log.INFO)
self.distribution.extras_require[extra].extend(extras_require)
# extract console scripts
if cmp_data.get("extract_entry_points"):
for console_scripts in dist.get_entry_map('console_scripts'):
self.announce(f'Entry point: {console_scripts}', level=log.INFO)
entry = dist.get_entry_info('console_scripts', console_scripts)
self.distribution.entry_points['console_scripts'].append(str(entry))
# copy modules to the build directory
dst = Path(self.build_lib)
black_list = cmp_data.get('black_list')
exclude = ignore_patterns('*ez_setup*', '*__pycache__*', '*.egg-info*', *black_list)
for path in src.glob('**/*'):
if path.is_dir() or exclude(str(path)):
continue
path_rel = path.relative_to(src)
(dst / path_rel.parent).mkdir(exist_ok=True, parents=True)
shutil.copyfile(path, dst / path_rel)
# add dependecy on runtime package
runtime_req = [f'openvino=={self.distribution.get_version()}']
self.distribution.install_requires.extend(runtime_req)
self.announce(f'{self.distribution.install_requires}', level=log.DEBUG)
self.announce(f'{self.distribution.extras_require}', level=log.DEBUG)
self.announce(f'{self.distribution.entry_points}', level=log.DEBUG)
class CustomInstall(install):
"""Enable build_clib during the installation"""
def run(self):
self.run_command('build')
install.run(self)
class CustomClean(clean):
"""Clean up staging directories"""
def clean(self, install_cfg):
"""Clean components staging directories"""
for comp, comp_data in install_cfg.items():
install_prefix = comp_data.get('prefix')
self.announce(f'Cleaning {comp}: {install_prefix}', level=log.INFO)
if os.path.exists(install_prefix):
shutil.rmtree(install_prefix)
def run(self):
self.clean(PKG_INSTALL_CFG)
for pattern in './build ./dist **/*.pyc **/*.tgz **/*.egg-info'.split(' '):
paths = SCRIPT_DIR.glob(pattern)
for path in paths:
if path.is_file() and path.exists():
path = path.parent
self.announce(f'Cleaning: {path}', level=log.INFO)
shutil.rmtree(path)
clean.run(self)
def get_description(desc_file_path):
"""read description from README.md"""
with open(desc_file_path, 'r', encoding='utf-8') as fstream:
description = fstream.read()
return description
with (SCRIPT_DIR / 'requirements.txt').open() as requirements:
install_reqs = [
str(requirement)
for requirement
in pkg_resources.parse_requirements(requirements)
]
setup(
name='openvino-dev',
version=os.getenv('OPENVINO_VERSION', '0.0.0'),
author='Intel® Corporation',
license='OSI Approved :: Apache Software License',
author_email='[email protected]',
url='https://docs.openvinotoolkit.org/latest/index.html',
download_url='https://github.com/openvinotoolkit/openvino/tags',
description='OpenVINO™ Developer Package',
long_description=get_description(SCRIPT_DIR.parents[1] / 'docs/install_guides/pypi-openvino-dev.md'),
long_description_content_type='text/markdown',
classifiers=[
'Programming Language :: Python :: 3',
'OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
],
cmdclass={
'build': CustomBuild,
'install': CustomInstall,
'clean': CustomClean,
},
entry_points = {
'console_scripts': [],
},
install_requires=install_reqs,
packages=find_namespace_packages(where=str(SRC_DIR)),
package_dir={'': str(SRC_DIR)},
)
|
[] |
[] |
[
"OPENVINO_VERSION"
] |
[]
|
["OPENVINO_VERSION"]
|
python
| 1 | 0 | |
search-spaces/3rd-round.py
|
# search space for hyperparameter optimization
xgb_space = {'model': xgb.XGBClassifier,
'params': {'n_estimators' : hp.normal('xgb_n', 500, 100),
'learning_rate' : hp.uniform('xgb_eta', 0.01, 0.03),
'max_depth' : hp.quniform('xgb_max_depth', 2, 8, 1),
'min_child_weight' : hp.quniform('xgb_min_child_weight', 1, 6, 1),
'subsample' : hp.uniform('xgb_subsample', 0.8, 1),
'gamma' : hp.uniform('xgb_gamma', 0.0, 0.4),
'colsample_bytree' : hp.uniform('xgb_colsample_bytree', 0.2, 0.8),
'objective': hp.choice('xgb_obj', ['binary:logistic']),
'scale_pos_weight': hp.uniform('xgb_w', 1.0, 4.0)
},
'preproc': {'na_input': {'strategy': 'mean'},
'var_thres': {'threshold': 0.0},
'sel_perc': {'score_func': hp.choice('sel_sf', [f_classif, chi2]),
'percentile': hp.quniform('sel_p', 50, 100, 5)}
},
'resmpl': hp.choice('resmpl', [{'method': False, 'params': False},
{'method': SMOTE,
'params': {'ratio': hp.uniform('rat_s', 1, 24),
'verbose': False,
'kind': 'regular'}},
{'method': NearMiss,
'params': {'ratio': hp.uniform('rat_nm', 1, 24),
'verbose': False,
'version': hp.choice('k_n',[1, 2, 3])}},
]),
'data': hp.choice('dc',[{'real': 'data/engineered-real/train.csv',
'cat': 'data/engineered-cat/train',
'ground-truth': 'data/target.csv'},
{'real': 'data/selected/st-train.csv',
'cat': None,
'ground-truth': 'data/target.csv'}]),
'feat_exp': {'n': 0}, #hp.quniform('exp_n', 0, 100, 20)
'fit_params': {'eval_metric': 'auc'},
'y_transf': hp.choice('trf', [None]),
}
# over and undersampling did not improve results
# just testing stability selection
# search space for hyperparameter optimization
# search space for hyperparameter optimization
# search space for hyperparameter optimization
xgb_space = {'model': xgb.XGBClassifier,
'params': {'n_estimators' : hp.normal('xgb_n', 500, 100),
'learning_rate' : hp.uniform('xgb_eta', 0.01, 0.03),
'max_depth' : hp.quniform('xgb_max_depth', 2, 8, 1),
'min_child_weight' : hp.quniform('xgb_min_child_weight', 1, 6, 1),
'subsample' : hp.uniform('xgb_subsample', 0.8, 1),
'gamma' : hp.uniform('xgb_gamma', 0.0, 0.4),
'colsample_bytree' : hp.uniform('xgb_colsample_bytree', 0.2, 0.8),
'objective': hp.choice('xgb_obj', ['binary:logistic']),
'scale_pos_weight': hp.uniform('xgb_w', 1.0, 4.0)
},
'preproc': {'na_input': {'strategy': 'mean'},
'var_thres': {'threshold': 0.0},
'sel_perc': {False}
},
'resmpl': hp.choice('resmpl', [{'method': False, 'params': False}]),
'data': hp.choice('dc',[{'real': 'data/selected/st-train.csv',
'cat': None,
'ground-truth': 'data/target.csv'}]),
'feat_exp': {'n': 0}, #hp.quniform('exp_n', 0, 100, 20)
'fit_params': {'eval_metric': 'auc'},
'y_transf': hp.choice('trf', [None]),
}
|
[] |
[] |
[] |
[]
|
[]
|
python
| null | null | null |
peer/common/ordererenv.go
|
/*
Copyright IBM Corp. 2016-2017 All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package common
import (
"os"
"time"
"deepchain/common/flogging"
"github.com/spf13/cobra"
"github.com/spf13/viper"
)
var (
OrderingEndpoint string
tlsEnabled bool
clientAuth bool
caFile string
keyFile string
certFile string
ordererTLSHostnameOverride string
connTimeout time.Duration
)
// SetOrdererEnv adds orderer-specific settings to the global Viper environment
func SetOrdererEnv(cmd *cobra.Command, args []string) {
// read in the legacy logging level settings and, if set,
// notify users of the FABRIC_LOGGING_SPEC env variable
var loggingLevel string
if viper.GetString("logging_level") != "" {
loggingLevel = viper.GetString("logging_level")
} else {
loggingLevel = viper.GetString("logging.level")
}
if loggingLevel != "" {
mainLogger.Warning("CORE_LOGGING_LEVEL is no longer supported, please use the FABRIC_LOGGING_SPEC environment variable")
}
// need to init logging here as cobra does not currently support
// chaining PersistentPreRun functions
loggingSpec := os.Getenv("FABRIC_LOGGING_SPEC")
flogging.InitFromSpec(loggingSpec)
// set the orderer environment from flags
viper.Set("orderer.tls.rootcert.file", caFile)
viper.Set("orderer.tls.clientKey.file", keyFile)
viper.Set("orderer.tls.clientCert.file", certFile)
viper.Set("orderer.address", OrderingEndpoint)
viper.Set("orderer.tls.serverhostoverride", ordererTLSHostnameOverride)
viper.Set("orderer.tls.enabled", tlsEnabled)
viper.Set("orderer.tls.clientAuthRequired", clientAuth)
viper.Set("orderer.client.connTimeout", connTimeout)
}
// AddOrdererFlags adds flags for orderer-related commands
func AddOrdererFlags(cmd *cobra.Command) {
flags := cmd.PersistentFlags()
flags.StringVarP(&OrderingEndpoint, "orderer", "o", "", "Ordering service endpoint")
flags.BoolVarP(&tlsEnabled, "tls", "", false, "Use TLS when communicating with the orderer endpoint")
flags.BoolVarP(&clientAuth, "clientauth", "", false,
"Use mutual TLS when communicating with the orderer endpoint")
flags.StringVarP(&caFile, "cafile", "", "",
"Path to file containing PEM-encoded trusted certificate(s) for the ordering endpoint")
flags.StringVarP(&keyFile, "keyfile", "", "",
"Path to file containing PEM-encoded private key to use for mutual TLS "+
"communication with the orderer endpoint")
flags.StringVarP(&certFile, "certfile", "", "",
"Path to file containing PEM-encoded X509 public key to use for "+
"mutual TLS communication with the orderer endpoint")
flags.StringVarP(&ordererTLSHostnameOverride, "ordererTLSHostnameOverride",
"", "", "The hostname override to use when validating the TLS connection to the orderer.")
flags.DurationVarP(&connTimeout, "connTimeout",
"", 3*time.Second, "Timeout for client to connect")
}
|
[
"\"FABRIC_LOGGING_SPEC\""
] |
[] |
[
"FABRIC_LOGGING_SPEC"
] |
[]
|
["FABRIC_LOGGING_SPEC"]
|
go
| 1 | 0 | |
server.go
|
package main
import (
"io"
"math/rand"
"net"
"github.com/ttaylorr/minecraft/chat"
"github.com/ttaylorr/minecraft/protocol"
"github.com/ttaylorr/minecraft/protocol/packet"
)
func main() {
conn, _ := net.Listen("tcp", "0.0.0.0:25565")
for {
client, _ := conn.Accept()
go handleConnection(protocol.NewConnection(client))
}
}
func handleConnection(c *protocol.Connection) {
for {
p, err := c.Next()
if err == io.EOF {
return
}
switch t := p.(type) {
case packet.Handshake:
state := protocol.State(uint8(t.NextState))
c.SetState(state)
case packet.StatusRequest:
resp := packet.StatusResponse{}
resp.Status.Version.Name = "1.8.8"
resp.Status.Version.Protocol = 47
resp.Status.Players.Max = rand.Intn(100)
resp.Status.Players.Online = rand.Intn(101)
resp.Status.Description = chat.TextComponent{
"Hello from Golang!",
chat.Component{
Bold: true,
Color: chat.ColorRed,
},
}
c.Write(resp)
case packet.StatusPing:
pong := packet.StatusPong{}
pong.Payload = t.Payload
c.Write(pong)
}
}
}
|
[] |
[] |
[] |
[]
|
[]
|
go
| null | null | null |
doc/integrations/cortx-s3-slack-bot/app.py
|
import os
import boto3
import asyncio
from csv import reader
from pathlib import Path
from dotenv import load_dotenv
from botocore.exceptions import ClientError
from slack_bolt.async_app import AsyncApp
from slack_sdk.errors import SlackApiError
from elasticsearch_connector import ElasticsearchConnector
from process_resume import process_resume
from upload_file_to_s3 import upload_file_to_s3
from get_file_from_s3 import get_file_from_s3
env_path = Path('.') / '.env'
load_dotenv(dotenv_path=env_path)
# connections
# Create CORTX connector
es_client = ElasticsearchConnector(
elastic_domain=os.environ.get("ELASTIC_DOMAIN"), elastic_port=os.environ.get("ELASTIC_PORT"))
# Creating a Bolt app
app = AsyncApp(
token=os.environ.get("SLACK_BOT_TOKEN"),
signing_secret=os.environ.get("SLACK_SIGNING_SECRET"),
)
# Creating a CORTX S3 client
s3_client = boto3.client(
's3', endpoint_url=str(os.environ.get('ENDPOINT_URL')),
aws_access_key_id=str(os.environ.get('AWS_ACCESS_KEY_ID')), aws_secret_access_key=str(os.environ.get('AWS_SECRET_ACCESS_KEY'))
)
# Creating an AWS Textract client
textract_client = boto3.client('textract', aws_access_key_id=str(os.environ.get('AMAZON_AWS_ACCESS_KEY_ID')),
aws_secret_access_key=str(os.environ.get('AMAZON_AWS_SECRET_ACCESS_KEY')))
# Creating an AWS Comprehend client
comprehend_client = boto3.client('comprehend', aws_access_key_id=str(os.environ.get('AMAZON_AWS_ACCESS_KEY_ID')),
aws_secret_access_key=str(os.environ.get('AMAZON_AWS_SECRET_ACCESS_KEY')))
@app.middleware # or app.use(log_request)
async def log_request(body, next):
return await next()
# cortx_connector.create_new_bucket("test")
@app.event({
"type": "message",
"subtype": "file_share"
})
async def file_shared(event, say, ack):
"""Whenever a new file is shared in any slack channel, add it to cortx"""
await ack()
channel_id = event["channel"]
user_id = event['user']
file_data = event['files'][0]
await say(text="{} uploaded to s3 bucket!".format(file_data["name"]), channel=channel_id)
await upload_file_to_s3(s3_client=s3_client, es_client=es_client, file_data=file_data, token=os.environ.get(
"SLACK_USER_TOKEN"))
@app.command('/cortx-s3-get')
async def cortx_s3_get(ack, say, command, payload, respond):
"""
Find a file from s3 and send it to the user privately
"""
await ack()
file_name = command['text']
channel_id = payload["user_id"]
await say(text="Trying to find {} in the S3 bucket ....".format(
file_name), channel=channel_id)
isFileFound = await get_file_from_s3(s3_client, es_client, file_name)
if isFileFound:
isDownloaded = False
counter = 0
file_path = os.path.join(os.getcwd(), 'downloads', file_name)
await say(text="Found {}!!!".format(
file_name), channel=channel_id)
# Call the files.upload method using the WebClient
# Uploading files requires the `files:write` scope
while(isDownloaded == False and counter < 20):
if(os.path.exists(file_path)):
try:
result = await app.client.files_upload(
channels=channel_id,
# initial_comment="{}".format(
# file_name),
file=file_path,
)
isDownloaded = True
except SlackApiError as e:
print("Error uploading file: {}".format(e))
await say(text="There was an error with slack! Please try again in a while".format(
file_name), channel=channel_id)
else:
await asyncio.sleep(1)
counter += 1
# print(result)
if os.path.exists(file_path):
os.remove(path=file_path)
else:
await say(text="Sorry! No file was found with the name {}".format(
file_name), channel=channel_id)
@app.command("/cortx-s3-search")
async def cortx_s3_search(body, ack, respond, client):
"""Search for a file on the s3 bucket. Enter a first three words"""
await ack(
text="Accepted!",
blocks=[
{
"type": "section",
"block_id": "b",
"text": {
"type": "mrkdwn",
"text": "Opening file search dialog",
},
}
],
)
res = await client.views_open(
trigger_id=body["trigger_id"],
view={
"type": "modal",
"callback_id": "search",
"title": {
"type": "plain_text",
"text": "Cortx S3 Bucket"
},
"submit": {
"type": "plain_text",
"text": "Submit",
"emoji": True
},
"close": {
"type": "plain_text",
"text": "Cancel",
"emoji": True
},
"blocks": [
{
"type": "input",
"block_id": "my_block",
"element": {
"type": "external_select",
"action_id": "file_select",
"min_query_length": 3,
"placeholder": {
"type": "plain_text",
"text": "What are you looking for?"
}
},
"label": {
"type": "plain_text",
"text": "Search for your file!",
"emoji": True
}
}
]
}
)
@app.options("file_select")
async def show_options(ack, body, payload):
"""Populates the options with all the search results from elasticsearch
For Example: -
'abc' will give 'abc.csv', 'abcd.csv' ,'abcde.csv' as results
"""
options = []
search_term = body["value"]
files_found = es_client.search(search_term)
for file in files_found:
options.append(
{"text": {"type": "plain_text", "text": file["_id"]}, "value": file["_id"]})
await ack(options=options)
@app.view("search")
async def view_submission(ack, say, body, respond):
await ack()
file_name = body["view"]["state"]["values"]["my_block"]["file_select"]["selected_option"]["value"]
channel_id = body["user"]["id"]
await say(text="Getting {} ....".format(
file_name), channel=channel_id)
isFileFound = await get_file_from_s3(s3_client, es_client, file_name)
if isFileFound:
isDownloaded = False
counter = 0
# Call the files.upload method using the WebClient
# Uploading files requires the `files:write` scope
while(isDownloaded == False and counter < 20):
file_path = os.path.join(os.getcwd(), 'downloads', file_name)
if(os.path.exists(file_path)):
try:
result = await app.client.files_upload(
channels=channel_id,
# initial_comment="{}".format(
# file_name),
file=file_path,
)
isDownloaded = True
except SlackApiError as e:
print("Error uploading file: {}".format(e))
await say(text="There was an error with slack! Please try again in a while".format(
file_name), channel=channel_id)
else:
await asyncio.sleep(1)
counter += 1
else:
await say(text="Sorry! No file was found with the name {}".format(
file_name), channel=channel_id)
@app.command('/cortx-s3-delete')
async def cortx_s3_delete(ack, say, command, payload, respond):
"""
Delete a file from cortx s3 given the filename
"""
file_name = command['text']
channel_id = payload["user_id"]
if(es_client.check_if_doc_exists(file_name=file_name)):
await ack(blocks=[
{
"type": "section",
"block_id": "b",
"text": {
"type": "mrkdwn",
"text": "Are you sure you want to permanently delete {} from the s3 bucket ?".format(file_name),
},
"accessory": {
"type": "button",
"action_id": "delete_file_button",
"text": {"type": "plain_text", "text": "Delete"},
"value": file_name,
"style": "danger"
},
}
])
else:
await ack(
blocks=[
{
"type": "section",
"block_id": "b",
"text": {
"type": "mrkdwn",
"text": ":negative_squared_cross_mark: No file found with the name {}".format(
file_name
),
},
}
],
)
@app.action('delete_file_button')
async def delete_file_button_clicked(ack, body, respond):
"""
This function is called when the delete file button is clicked on slack
"""
file_name = body["actions"][0]["value"]
await ack()
try:
response = s3_client.delete_object(Bucket='testbucket', Key=file_name)
es_client.delete_doc(file_name)
await respond(
blocks=[
{
"type": "section",
"block_id": "b",
"text": {
"type": "mrkdwn",
"text": ":white_check_mark: {} was deleted :wastebasket: !".format(
file_name
),
},
}
],
)
except ClientError as e:
await respond(
blocks=[
{
"type": "section",
"block_id": "b",
"text": {
"type": "mrkdwn",
"text": ":X: Couldn't delete {} from S3".format(
file_name
),
},
}
],
)
print(e)
@app.command('/cortx-s3-resume-data')
async def cortx_s3_resume_data(ack, body, say, respond, payload):
"""Getting resume data from S3 bucket"""
await ack()
csv_file_path = os.path.join(os.getcwd(), 'resume_data', 'resume_data.csv')
fields = []
with open(csv_file_path, 'r') as read_obj:
csv_reader = reader(read_obj)
for count, row in enumerate(csv_reader):
if count == 0:
fields.append({
"type": "mrkdwn",
"text": "*Name*",
})
fields.append(
{
"type": "mrkdwn",
"text": "*Email*"
}
)
else:
fields.append({
"type": "plain_text",
"text": row[0],
"emoji": True
}
)
fields.append(
{
"type": "mrkdwn",
"text": row[1]
}
)
await respond(
blocks=[{
"type": "section",
"fields": fields
}]
)
@app.event({
"type": "message",
"subtype": "channel_join"
})
async def channel_join(ack, event, respond, say):
"""This function is called when we someone joins the cortx-s3-test slack channel"""
await ack()
user_id = event["user"]
joined_channel_id = event["channel"]
result = await app.client.conversations_list()
channels = result["channels"]
channel_list = ['cortx-s3-test']
general_channel = [
channel for channel in channels if channel['name'] in channel_list]
general_channel_id = general_channel[0]['id']
if(joined_channel_id == general_channel_id):
await say(channel=joined_channel_id, text=f"Hey <@{user_id}> welcome to <#{joined_channel_id}>! \n Please share your resume in this channel.\n Use the /cortx-s3-upload-resume command so that we can process it, upload only .jpeg or .pdf files\n")
@app.command('/cortx-s3-upload-resume')
async def cortx_s3_upload_resume(ack, say, command, payload):
"""Uploading a resume to Slack to process it and add it to the resume-data.csv file"""
await ack()
file_name = command['text']
user_id = payload["user_id"]
channel_id = payload["channel_id"]
isFileFound = await get_file_from_s3(s3_client, es_client, file_name)
if isFileFound:
await say(text=f"Thank you <@{user_id}> for uploading your resume!", channel=channel_id)
isDownloaded = False
counter = 0
while(isDownloaded == False and counter < 20):
file_path = os.path.join(os.getcwd(), 'downloads', file_name)
if(os.path.exists(file_path)):
isDownloaded = True
process_resume(textract_client=textract_client, comprehend_client=comprehend_client,
file_name=file_name, s3_client=s3_client, es_client=es_client)
else:
await asyncio.sleep(1)
counter += 1
if os.path.exists(file_path):
os.remove(path=file_path)
else:
await say(text="Sorry! No file was found with the name {}".format(
file_name), channel=channel_id)
@app.event("file_shared")
async def file_was_shared():
pass
@app.event({
"type": "message",
"subtype": "message_deleted"
})
async def file_delete():
pass
if __name__ == '__main__':
app.start(port=int(os.environ.get("PORT", 3000)))
|
[] |
[] |
[
"PORT",
"AMAZON_AWS_SECRET_ACCESS_KEY",
"ENDPOINT_URL",
"AWS_SECRET_ACCESS_KEY",
"AMAZON_AWS_ACCESS_KEY_ID",
"ELASTIC_DOMAIN",
"ELASTIC_PORT",
"SLACK_USER_TOKEN",
"AWS_ACCESS_KEY_ID",
"SLACK_BOT_TOKEN",
"SLACK_SIGNING_SECRET"
] |
[]
|
["PORT", "AMAZON_AWS_SECRET_ACCESS_KEY", "ENDPOINT_URL", "AWS_SECRET_ACCESS_KEY", "AMAZON_AWS_ACCESS_KEY_ID", "ELASTIC_DOMAIN", "ELASTIC_PORT", "SLACK_USER_TOKEN", "AWS_ACCESS_KEY_ID", "SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"]
|
python
| 11 | 0 | |
ares/static/VolumeGlobal.py
|
"""
IntergalacticMedium.py
Author: Jordan Mirocha
Affiliation: University of Colorado at Boulder
Created on: Fri May 24 11:31:06 2013
Description:
"""
import numpy as np
from ..util.Warnings import *
from ..util import ProgressBar
from ..physics.Constants import *
import types, os, re, sys, pickle
from ..util.Misc import num_freq_bins
from ..physics import SecondaryElectrons
from scipy.integrate import dblquad, romb, simps, quad, trapz
from ..util.Warnings import tau_tab_z_mismatch, tau_tab_E_mismatch
try:
import h5py
have_h5py = True
except ImportError:
have_h5py = False
try:
from mpi4py import MPI
rank = MPI.COMM_WORLD.rank
size = MPI.COMM_WORLD.size
except ImportError:
rank = 0
size = 1
log10 = np.log(10.)
E_th = np.array([13.6, 24.4, 54.4])
defkwargs = \
{
'zf':None,
'xray_flux':None,
'epsilon_X': None,
'Gamma': None,
'gamma': None,
'return_rc': False,
'energy_units':False,
'Emax': None,
#'zxavg':0.0,
#'igm':True,
'xavg': 0.0,
'igm_h_1': 1.0,
'igm_h_2': 0.0,
'igm_he_2': 0.0,
'igm_he_3': 0.0,
'cgm_h_1': 1.0,
'cgm_h_2': 0.0,
'cgm_he_2': 0.0,
'cgm_he_3': 0.0,
'igm_e': 0.0,
}
species_i_to_str = {0:'h_1', 1:'he_1', 2:'he_2'}
class GlobalVolume(object):
def __init__(self, background):
"""
Initialize a GlobalVolume.
Parameters
----------
background : ares.solvers.UniformBackground instance.
"""
self.background = background
self.pf = background.pf
self.grid = background.grid
self.cosm = background.cosm
self.hydr = background.hydr
self.pops = background.pops
self.Npops = len(self.pops)
# Include helium opacities approximately?
self.approx_He = self.pf['include_He'] and self.pf['approx_He']
# Include helium opacities self-consistently?
self.self_consistent_He = self.pf['include_He'] \
and (not self.pf['approx_He'])
self.esec = \
SecondaryElectrons(method=self.pf["secondary_ionization"])
# Choose function for computing bound-free absorption cross-sections
if self.pf['approx_sigma']:
from ..physics.CrossSections import \
ApproximatePhotoIonizationCrossSection as sigma
else:
from ..physics.CrossSections import \
PhotoIonizationCrossSection as sigma
self.sigma = sigma
self.sigma0 = sigma(E_th[0]) # Hydrogen ionization threshold
self._set_integrator()
@property
def rates_no_RT(self):
if not hasattr(self, '_rates_no_RT'):
self._rates_no_RT = \
{'k_ion': np.zeros((self.grid.dims,
self.grid.N_absorbers)),
'k_heat': np.zeros((self.grid.dims,
self.grid.N_absorbers)),
'k_ion2': np.zeros((self.grid.dims,
self.grid.N_absorbers, self.grid.N_absorbers)),
}
return self._rates_no_RT
#def _fetch_tau(self, pop, zpf, Epf):
# """
# Look for optical depth tables. Supply corrected energy and redshift
# arrays if there is a mistmatch between those generated from information
# in the parameter file and those found in the optical depth table.
#
# .. note:: This will only be called from UniformBackground, and on
# populations which are using the generator framework.
#
# Parameters
# ----------
# popid : int
# ID # for population of interest.
# zpf : np.ndarray
# What the redshifts should be according to the parameter file.
# Epf : np.ndarray
# What the energies should be according to the parameter file.
#
# Returns
# -------
# Energies and redshifts, potentially revised from Epf and zpf.
#
# """
#
# for i in range(self.Npops):
# if pop == self.pops[i]:
# band = self.background.bands_by_pop[i]
# break
#
# # First, look in CWD or $ARES (if it exists)
# self.tabname = self._load_tau(pop, pop.pf['tau_prefix'])
#
# if not self.tabname:
# return zpf, Epf, None
#
# # If we made it this far, we found a table that may be suitable
# ztab, Etab, tau = self._read_tau(self.tabname)
#
# # Return right away if there's no potential for conflict
# if (zpf is None) and (Epf is None):
# return ztab, Etab, tau
#
# # Figure out if the tables need fixing
# zmax_ok = \
# (ztab.max() >= zpf.max()) or \
# np.allclose(ztab.max(), zpf.max())
# zmin_ok = \
# (ztab.min() <= zpf.min()) or \
# np.allclose(ztab.min(), zpf.min())
#
# Emin_ok = \
# (Etab.min() <= Epf.min()) or \
# np.allclose(Etab.min(), Epf.min())
#
# # Results insensitive to Emax (so long as its relatively large)
# # so be lenient with this condition (100 eV or 1% difference
# # between parameter file and lookup table)
# Emax_ok = np.allclose(Etab.max(), Epf.max(), atol=100., rtol=1e-2)
#
# # Check redshift bounds
# if not (zmax_ok and zmin_ok):
# if not zmax_ok:
# tau_tab_z_mismatch(self, zmin_ok, zmax_ok, ztab)
# sys.exit(1)
# else:
# if self.pf['verbose']:
# tau_tab_z_mismatch(self, zmin_ok, zmax_ok, ztab)
#
# if not (Emax_ok and Emin_ok):
# if self.pf['verbose']:
# tau_tab_E_mismatch(pop, self.tabname, Emin_ok, Emax_ok, Etab)
#
# if Etab.max() < Epf.max():
# sys.exit(1)
#
# # Correct for inconsistencies between parameter file and table
# # By effectively masking out those elements with tau -> inf
# if Epf.min() > Etab.min():
# Ediff = Etab - Epf.min()
# i_E0 = np.argmin(np.abs(Ediff))
# if Ediff[i_E0] < 0:
# i_E0 += 1
#
# #tau[:,0:i_E0+1] = np.inf
# else:
# i_E0 = 0
#
# if Epf.max() < Etab.max():
# Ediff = Etab - Epf.max()
# i_E1 = np.argmin(np.abs(Ediff))
# if Ediff[i_E1] < 0:
# i_E1 += 1
#
# #tau[:,i_E1+1:] = np.inf
# else:
# i_E1 = None
#
# # We're done!
# return ztab, Etab[i_E0:i_E1], tau[:,i_E0:i_E1]
@property
def E(self):
if not hasattr(self, '_E'):
self._tabulate_atomic_data()
return self._E
@property
def sigma_E(self):
if not hasattr(self, '_sigma_E'):
self._tabulate_atomic_data()
return self._sigma_E
def _tabulate_atomic_data(self):
"""
Pre-compute cross sections and such for each source population.
Returns
-------
Nothing. Sets the following attributes:
sigma_E
log_sigma_E
fheat, flya, fion
"""
# Remember: these will all be [Npops, Nbands/pop, Nenergies/band]
self._E = self.background.energies
self.logE = [[] for k in range(self.Npops)]
self.dlogE = [[] for k in range(self.Npops)]
self.fheat = [[] for k in range(self.Npops)]
self.flya = [[] for k in range(self.Npops)]
# These are species dependent
self._sigma_E = {}
self.fion = {}
for species in ['h_1', 'he_1', 'he_2']:
self._sigma_E[species] = [[] for k in range(self.Npops)]
self.fion[species] = [[] for k in range(self.Npops)]
##
# Note: If secondary_ionization > 1, there will be an ionized fraction
# dimension in fion and fheat.
##
# Loop over populations
for i, pop in enumerate(self.pops):
# This means the population is completely approximate
if not np.any(self.background.solve_rte[i]):
self.logE[i] = [None]
self.dlogE[i] = [None]
self.fheat[i] = [None]
self.flya[i] = [None]
for species in ['h_1', 'he_1', 'he_2']:
self.fion[species][i] = [None]
self._sigma_E[species][i] = [None]
continue
##
# If we make it here, the population has at least one band that
# requires a detailed solution to the RTE
##
Nbands = len(self.background.energies[i])
self.logE[i] = [None for k in range(Nbands)]
self.dlogE[i] = [None for k in range(Nbands)]
self.fheat[i] = [None for k in range(Nbands)]
self.flya[i] = [None for k in range(Nbands)]
for species in ['h_1', 'he_1', 'he_2']:
self.fion[species][i] = [None for k in range(Nbands)]
self._sigma_E[species][i] = [None for k in range(Nbands)]
# Loop over each band for this population
for j, band in enumerate(self.background.bands_by_pop[i]):
if band is None:
continue
need_tab = self.pops[i].is_xray_src \
and np.any(np.array(band) > E_LL)
if (not self.background.solve_rte[i][j]) or \
(not need_tab):
continue
else:
self.fheat[i][j] = \
[np.ones([self.background.energies[i][j].size,
len(self.esec.x)]) \
for j in range(Nbands)]
self.flya[i] = \
[np.ones([self.background.energies[i][j].size,
len(self.esec.x)]) \
for j in range(Nbands)]
for species in ['h_1', 'he_1', 'he_2']:
if self.esec.method > 1:
self._sigma_E[species][i] = \
[np.ones([self.background.energies[i][j].size,
len(self.esec.x)]) \
for j in range(Nbands)]
self.fion[species][i] = \
[np.ones([self.background.energies[i][j].size,
len(self.esec.x)]) \
for j in range(Nbands)]
else:
self._sigma_E[species][i] = [None for k in range(Nbands)]
self.fion[species][i] = [None for k in range(Nbands)]
self.fheat[i] = [None for k in range(Nbands)]
self.flya[i] = [None for k in range(Nbands)]
# More convenient variables
E = self._E[i][j]
N = E.size
# Compute some things we need, like bound-free cross-section
self.logE[i][j] = np.log10(E)
self.dlogE[i][j] = np.diff(self.logE[i][j])
#
for k, species in enumerate(['h_1', 'he_1', 'he_2']):
self._sigma_E[species][i][j] = \
np.array(map(lambda E: self.sigma(E, k), E))
# Pre-compute secondary ionization and heating factors
if self.esec.method > 1:
# Don't worry: we'll fill these in in a sec!
self.fheat[i][j] = np.ones([N, len(self.esec.x)])
self.flya[i][j] = np.ones([N, len(self.esec.x)])
# Must evaluate at ELECTRON energy, not photon energy
for k, nrg in enumerate(E - E_th[0]):
self.fheat[i][j][k] = \
self.esec.DepositionFraction(self.esec.x, E=nrg,
channel='heat')
self.fion['h_1'][i][j][k] = \
self.esec.DepositionFraction(self.esec.x, E=nrg,
channel='h_1')
if self.pf['secondary_lya']:
self.flya[i][j][k] = \
self.esec.DepositionFraction(self.esec.x, E=nrg,
channel='lya')
# Helium
if self.pf['include_He'] and not self.pf['approx_He']:
# Don't worry: we'll fill these in in a sec!
self.fion['he_1'][i][j] = np.ones([N, len(self.esec.x)])
self.fion['he_2'][i][j] = np.ones([N, len(self.esec.x)])
for k, nrg in enumerate(E - E_th[1]):
self.fion['he_1'][i][j][k] = \
self.esec.DepositionFraction(self.esec.x,
E=nrg, channel='he_1')
for k, nrg in enumerate(E - E_th[2]):
self.fion['he_2'][i][j][k] = \
self.esec.DepositionFraction(self.esec.x,
E=nrg, channel='he_2')
else:
self.fion['he_1'][i][j] = np.zeros([N, len(self.esec.x)])
self.fion['he_2'][i][j] = np.zeros([N, len(self.esec.x)])
return
def _set_integrator(self):
self.integrator = self.pf["unsampled_integrator"]
self.sampled_integrator = self.pf["sampled_integrator"]
self.rtol = self.pf["integrator_rtol"]
self.atol = self.pf["integrator_atol"]
self.divmax = int(self.pf["integrator_divmax"])
#def _read_tau(self, fn):
# """ Read optical depth table. """
#
# if type(fn) is dict:
#
# E0 = fn['E'].min()
# E1 = fn['E'].max()
# E = fn['E']
# z = fn['z']
# x = z + 1
# N = E.size
#
# R = x[1] / self.x[0]
#
# tau = fn['tau']
#
# elif re.search('hdf5', fn):
#
# f = h5py.File(self.tabname, 'r')
#
# E0 = min(f['photon_energy'].value)
# E1 = max(f['photon_energy'].value)
# E = f['photon_energy'].value
# z = f['redshift'].value
# x = z + 1
# N = E.size
#
# R = x[1] / x[0]
#
# tau = f['tau'].value
# f.close()
#
# elif re.search('npz', fn) or re.search('pkl', fn):
#
# if re.search('pkl', fn):
# f = open(fn, 'rb')
# data = pickle.load(f)
# else:
# f = open(fn, 'r')
# data = dict(np.load(f))
#
# E0 = data['E'].min()
# E1 = data['E'].max()
# E = data['E']
# z = data['z']
# x = z + 1
# N = E.size
#
# R = x[1] / x[0]
#
# tau = tau = data['tau']
# f.close()
# else:
# raise NotImplemented('Don\'t know how to read %s.' % fn)
#
# return z, E, tau
#def _tau_name(self, pop, suffix='hdf5'):
# """
# Return name of table based on its properties.
# """
#
# if not have_h5py:
# suffix == 'pkl'
#
# HorHe = 'He' if self.pf['include_He'] else 'H'
#
# zf = self.pf['final_redshift']
# zi = self.pf['initial_redshift']
#
# L, N = self._tau_shape(pop)
#
# E0 = pop.pf['pop_Emin']
# E1 = pop.pf['pop_Emax']
#
# fn = lambda z1, z2, E1, E2: \
# 'optical_depth_%s_%ix%i_z_%i-%i_logE_%.2g-%.2g.%s' \
# % (HorHe, L, N, z1, z2, E1, E2, suffix)
#
# return fn(zf, zi, np.log10(E0), np.log10(E1)), fn
#def _load_tau(self, pop, prefix=None):
# """
# Find an optical depth table.
# """
#
# fn, fn_func = self._tau_name(pop)
#
# if prefix is None:
# ares_dir = os.environ.get('ARES')
# if not ares_dir:
# print "No ARES environment variable."
# return None
#
# input_dirs = [os.path.join(ares_dir,'input','optical_depth')]
#
# else:
# if type(prefix) is str:
# input_dirs = [prefix]
# else:
# input_dirs = prefix
#
# guess = os.path.join(input_dirs[0], fn)
# if os.path.exists(guess):
# return guess
#
# ## Find exactly what table should be
# zmin, zmax, Nz, lEmin, lEmax, chem, pre, post = self._parse_tab(fn)
#
# ok_matches = []
# perfect_matches = []
#
# # Loop through input directories
# for input_dir in input_dirs:
#
# # Loop over files in input_dir, look for best match
# for fn1 in os.listdir(input_dir):
#
# if re.search('hdf5', fn1) and (not have_h5py):
# continue
#
# tab_name = os.path.join(input_dir, fn1)
#
# try:
# zmin_f, zmax_f, Nz_f, lEmin_f, lEmax_f, chem_f, p1, p2 = \
# self._parse_tab(fn1)
# except:
# continue
#
# # Dealbreakers
# if Nz_f != Nz:
# continue
# if zmax_f < zmax:
# continue
# if chem_f != chem:
# continue
#
# # Continue with possible matches
# for fmt in ['pkl', 'npz', 'hdf5']:
#
# if fn1 == fn and fmt == self.pf['preferred_format']:
# perfect_matches.append(tab_name)
# continue
#
# if c and fmt == self.pf['preferred_format']:
# perfect_matches.append(tab_name)
# continue
#
# # If number of redshift bins and energy range right...
# if re.search(pre, fn1) and re.search(post, fn1):
# if re.search(fmt, fn1) and fmt == self.pf['preferred_format']:
# perfect_matches.append(tab_name)
# else:
# ok_matches.append(tab_name)
#
# # If number of redshift bins is right...
# elif re.search(pre, fn1):
#
# if re.search(fmt, fn1) and fmt == self.pf['preferred_format']:
# perfect_matches.append(tab_name)
# else:
# ok_matches.append(tab_name)
#
# if perfect_matches:
# return perfect_matches[0]
# elif ok_matches:
# return ok_matches[0]
# else:
# return None
#def _parse_tab(self, fn):
#
# tmp1, tmp2 = fn.split('_z_')
# pre = tmp1[0:tmp1.rfind('x')]
# red, tmp3 = fn.split('_logE_')
# post = '_logE_' + tmp3.replace('.hdf5', '')
#
# # Find exactly what table should be
# zmin, zmax = map(float, red[red.rfind('z')+2:].partition('-')[0::2])
# logEmin, logEmax = map(float, tmp3[tmp3.rfind('E')+1:tmp3.rfind('.')].partition('-')[0::2])
#
# Nz = pre[pre.rfind('_')+1:]
#
# # Hack off Nz string and optical_depth_
# chem = pre.strip(Nz)[14:-1]#.strip('optical_depth_')
#
# return zmin, zmax, int(Nz), logEmin, logEmax, chem, pre, post
#
#def _tau_shape(self, pop):
# """
# Determine dimensions of optical depth table.
#
# Unfortunately, this is a bit redundant with the procedure in
# self._init_xrb, but that's the way it goes.
# """
#
# # Set up log-grid in parameter x = 1 + z
# x = np.logspace(np.log10(1+self.pf['final_redshift']),
# np.log10(1+self.pf['initial_redshift']),
# int(pop.pf['pop_tau_Nz']))
# z = x - 1.
# logx = np.log10(x)
# logz = np.log10(z)
#
# # Constant ratio between elements in x-grid
# R = x[1] / x[0]
# logR = np.log10(R)
#
# E0 = pop.pf['pop_Emin']
#
# # Create mapping to frequency space
# E = 1. * E0
# n = 1
# while E < pop.pf['pop_Emax']:
# E = E0 * R**(n - 1)
# n += 1
#
# # Set attributes for dimensions of optical depth grid
# L = len(x)
#
# # Frequency grid must be index 1-based.
# N = num_freq_bins(L, zi=self.pf['initial_redshift'],
# zf=self.pf['final_redshift'], Emin=E0,
# Emax=pop.pf['pop_Emax'])
# N -= 1
#
# return L, N
def RestFrameEnergy(self, z, E, zp):
"""
Return energy of a photon observed at (z, E) and emitted at zp.
"""
return E * (1. + zp) / (1. + z)
def ObserverFrameEnergy(self, z, Ep, zp):
"""
What is the energy of a photon observed at redshift z and emitted
at redshift zp and energy Ep?
"""
return Ep * (1. + z) / (1. + zp)
def Jc(self, z, E):
"""
Flux corresponding to one photon per hydrogen atom at redshift z.
"""
return c * self.cosm.nH0 * (1. + z)**3 / 4. / np.pi \
/ (E * erg_per_ev / h)
def rate_to_coefficient(self, z, species=0, zone='igm', **kw):
"""
Convert an ionization/heating rate to a rate coefficient.
Provides units of per atom.
"""
if self.pf['photon_counting']:
prefix = zone
else:
prefix = 'igm'
if species == 0:
weight = 1. / self.cosm.nH(z) / kw['%s_h_1' % prefix]
elif species == 1:
weight = 1. / self.cosm.nHe(z) / kw['%s_he_1' % prefix]
elif species == 2:
weight = 1. / self.cosm.nHe(z) / kw['%s_he_2' % prefix]
return weight
def coefficient_to_rate(self, z, species=0, **kw):
return 1. / self.rate_to_coefficient(z, species, **kw)
def _fix_kwargs(self, functionify=False, popid=0, band=0, **kwargs):
kw = defkwargs.copy()
kw.update(kwargs)
pop = self.pops[popid]
if functionify and type(kw['xavg']) is not types.FunctionType:
tmp = kw['xavg']
kw['xavg'] = lambda z: tmp
if kw['zf'] is None and pop is not None:
kw['zf'] = pop.zform
if not self.background.solve_rte[popid][band]:
pass
elif (kw['Emax'] is None) and self.background.solve_rte[popid][band] and \
np.any(self.background.bands_by_pop[popid] > pop.pf['pop_EminX']):
kw['Emax'] = self.background.energies[popid][band][-1]
return kw
def HeatingRate(self, z, species=0, popid=0, band=0, **kwargs):
"""
Compute heating rate density due to emission from this population.
Parameters
----------
z : int, float
Redshift of interest.
species : int
Atom whose liberated electrons cause heating.
Can be 0, 1, or 2 (HI, HeI, and HeII, respectively)
===============
relevant kwargs
===============
xray_flux : np.ndarray
Array of fluxes corresponding to photon energies in self.igm.E.
return_rc : bool
Return actual heating rate, or rate coefficient for heating?
Former has units of erg s**-1 cm**-3, latter has units of
erg s**-1 cm**-3 atom**-1.
Returns
-------
Proper heating rate density in units of in erg s**-1 cm**-3 at redshift z,
due to electrons previously bound to input species.
"""
pop = self.pops[popid]
if not pop.pf['pop_heat_src_igm'] or (z >= pop.zform):
return 0.0
if pop.pf['pop_heat_rate'] is not None:
return pop.HeatingRate(z)
# Grab defaults, do some patches if need be
kw = self._fix_kwargs(**kwargs)
species_str = species_i_to_str[species]
if pop.pf['pop_k_heat_igm'] is not None:
return pop.pf['pop_k_heat_igm'](z)
if band is not None:
solve_rte = self.background.solve_rte[popid][band]
else:
solve_rte = False
# Compute fraction of photo-electron energy deposited as heat
if pop.pf['pop_fXh'] is None:
# Interpolate in energy and ionized fraction
if (self.esec.method > 1) and solve_rte:
if kw['igm_e'] <= self.esec.x[0]:
fheat = self.fheat[popid][band][:,0]
else:
i_x = np.argmin(np.abs(kw['igm_e'] - self.esec.x))
if self.esec.x[i_x] > kw['igm_e']:
i_x -= 1
j = i_x + 1
fheat = self.fheat[popid][band][:,i_x] \
+ (self.fheat[popid][band][:,j] - self.fheat[popid][band][:,i_x]) \
* (kw['igm_e'] - self.esec.x[i_x]) \
/ (self.esec.x[j] - self.esec.x[i_x])
elif self.esec.method > 1:
raise ValueError('Only know how to do advanced secondary ionization with solve_rte=True')
else:
fheat = self.esec.DepositionFraction(kw['igm_e'])[0]
else:
fheat = pop.pf['pop_fXh']
# Assume heating rate density at redshift z is only due to emission
# from sources at redshift z
if not solve_rte:
weight = self.rate_to_coefficient(z, species, **kw)
Lx = pop.LuminosityDensity(z, Emin=pop.pf['pop_Emin_xray'],
Emax=pop.pf['pop_Emax'])
return weight * fheat * Lx * (1. + z)**3
##
# Otherwise, do the full calculation
##
# Re-normalize to help integrator
norm = J21_num * self.sigma0
# Computes excess photo-electron energy due to ionizations by
# photons with energy E (normalized by sigma0 * Jhat)
if kw['fluxes'][popid] is None:
# If we're approximating helium, must add contributions now
# since we'll never explicitly call this method w/ species=1.
if self.approx_He:
integrand = lambda E, zz: \
self.rb.AngleAveragedFluxSlice(z, E, zz, xavg=kw['xavg']) \
* (self.sigma(E) * (E - E_th[0]) \
+ self.cosm.y * self.sigma(E, species=1) * (E - E_th[1])) \
* fheat / norm / ev_per_hz
# Otherwise, just heating via hydrogen photo-electrons
else:
integrand = lambda E, zz: \
self.rb.AngleAveragedFluxSlice(z, E, zz, xavg=kw['xavg'],
zxavg=kw['zxavg']) * self.sigma(E, species=1) \
* (E - E_th[species]) * fheat / norm / ev_per_hz
# This means the fluxes have been computed already - integrate
# over discrete set of points
else:
integrand = self.sigma_E[species_str][popid][band] \
* (self._E[popid][band] - E_th[species])
if self.approx_He:
integrand += self.cosm.y * self.sigma_E['he_1'][popid][band] \
* (self._E[popid][band] - E_th[1])
integrand *= kw['fluxes'][popid][band] * fheat / norm / ev_per_hz
# Compute integral over energy
if type(integrand) == types.FunctionType:
heat, err = dblquad(integrand, z, kw['zf'], lambda a: self.E0,
lambda b: kw['Emax'], epsrel=self.rtol, epsabs=self.atol)
else:
if kw['Emax'] is not None:
imax = np.argmin(np.abs(self._E[popid][band] - kw['Emax']))
if imax == 0:
return 0.0
elif imax == (len(self._E[popid][band]) - 1):
imax = None
if self.sampled_integrator == 'romb':
raise ValueError("Romberg's method cannot be used for integrating subintervals.")
heat = romb(integrand[0:imax] * self.E[0:imax],
dx=self.dlogE[0:imax])[0] * log10
else:
heat = simps(integrand[0:imax] * self._E[popid][band][0:imax],
x=self.logE[popid][band][0:imax]) * log10
else:
imin = np.argmin(np.abs(self._E[popid][band] - pop.pf['pop_Emin']))
if self.sampled_integrator == 'romb':
heat = romb(integrand[imin:] * self._E[popid][band][imin:],
dx=self.dlogE[popid][band][imin:])[0] * log10
elif self.sampled_integrator == 'trapz':
heat = np.trapz(integrand[imin:] * self._E[popid][band][imin:],
x=self.logE[popid][band][imin:]) * log10
else:
heat = simps(integrand[imin:] * self._E[popid][band][imin:],
x=self.logE[popid][band][imin:]) * log10
# Re-normalize, get rid of per steradian units
heat *= 4. * np.pi * norm * erg_per_ev
# Currently a rate coefficient, returned value depends on return_rc
if kw['return_rc']:
pass
else:
heat *= self.coefficient_to_rate(z, species, **kw)
return heat
def IonizationRateCGM(self, z, species=0, popid=0, band=0, **kwargs):
"""
Compute growth rate of HII regions.
Parameters
----------
z : float
current redshift
species : int
Ionization rate for what atom?
Can be 0, 1, or 2 (HI, HeI, and HeII, respectively)
===============
relevant kwargs
===============
fluxes : np.ndarray
Array of fluxes corresponding to photon energies in self.igm.E.
return_rc : bool
Return actual heating rate, or rate coefficient for heating?
Former has units of erg s**-1 cm**-3, latter has units of
erg s**-1 cm**-3 atom**-1.
Returns
-------
Ionization rate. Units determined by value of return_rc keyword
argument, which is False by default.
"""
pop = self.pops[popid]
if band is not None:
b = self.background.bands_by_pop[popid][band]
if not np.any(np.array(b) > E_LL):
return 0.0
if not np.allclose(b[0], E_LL, atol=0.1, rtol=0):
return 0.0
else:
b = [13.6, 24.6]
if (not pop.pf['pop_ion_src_cgm']) or (z > pop.zform):
return 0.0
# Need some guidance from 1-D calculations to do this
if species > 0:
return 0.0
if pop.pf['pop_ion_rate'] is not None:
return pop.IonizationRateCGM(z)
kw = defkwargs.copy()
kw.update(kwargs)
if pop.pf['pop_k_ion_cgm'] is not None:
return self.pf['pop_k_ion_cgm'](z)
if kw['return_rc']:
weight = self.rate_to_coefficient(z, species, **kw)
else:
weight = 1.0
Qdot = pop.PhotonLuminosityDensity(z, Emin=13.6, Emax=24.6)
return weight * Qdot * (1. + z)**3
def IonizationRateIGM(self, z, species=0, popid=0, band=0, **kwargs):
"""
Compute volume averaged hydrogen ionization rate.
Parameters
----------
z : float
redshift
species : int
HI, HeI, or HeII (species=0, 1, 2, respectively)
Returns
-------
Volume averaged ionization rate in units of ionizations per
second. If return_rc=True, will be in units of ionizations per
second per atom.
"""
pop = self.pops[popid]
# z between zform, zdead? must be careful for BHs
if (not pop.pf['pop_ion_src_igm']) or (z > pop.zform):
return 0.0
# Grab defaults, do some patches if need be
kw = self._fix_kwargs(**kwargs)
species_str = species_i_to_str[species]
if pop.pf['pop_k_ion_igm'] is not None:
return pop.pf['pop_k_ion_igm'](z)
if band is not None:
solve_rte = self.background.solve_rte[popid][band]
else:
solve_rte = False
if (not solve_rte) or \
(not np.any(self.background.bands_by_pop[popid] > pop.pf['pop_EminX'])):
Lx = pop.LuminosityDensity(z, Emin=pop.pf['pop_Emin_xray'],
Emax=pop.pf['pop_Emax'])
weight = self.rate_to_coefficient(z, species, **kw)
primary = weight * Lx \
* (1. + z)**3 / pop.pf['pop_Ex'] / erg_per_ev
fion = self.esec.DepositionFraction(kw['igm_e'], channel='h_1')[0]
return primary * (1. + fion) * (pop.pf['pop_Ex'] - E_th[0]) \
/ E_th[0]
# Full calculation - much like computing integrated flux
norm = J21_num * self.sigma0
# Integrate over function
if kw['fluxes'][popid] is None:
integrand = lambda E, zz: \
self.rb.AngleAveragedFluxSlice(z, E, zz, xavg=kw['xavg'],
zxavg=kw['zxavg']) * self.sigma(E, species=species) \
/ norm / ev_per_hz
ion, err = dblquad(integrand, z, kw['zf'], lambda a: self.E0,
lambda b: kw['Emax'], epsrel=self.rtol, epsabs=self.atol)
# Integrate over set of discrete points
else:
integrand = self.sigma_E[species_str][popid][band] \
* kw['fluxes'][popid][band] / norm / ev_per_hz
if self.sampled_integrator == 'romb':
ion = romb(integrand * self.E[popid][band],
dx=self.dlogE[popid][band])[0] * log10
else:
ion = simps(integrand * self.E[popid][band],
x=self.logE[popid][band]) * log10
# Re-normalize
ion *= 4. * np.pi * norm
# Currently a rate coefficient, returned value depends on return_rc
if kw['return_rc']:
pass
else:
ion *= self.coefficient_to_rate(z, species, **kw)
return ion
def SecondaryIonizationRateIGM(self, z, species=0, donor=0, popid=0,
band=0, **kwargs):
"""
Compute volume averaged secondary ionization rate.
Parameters
----------
z : float
redshift
species : int
Ionization rate of what atom?
Can be 0, 1, or 2 (HI, HeI, and HeII, respectively)
donor : int
Which atom gave the electron?
Can be 0, 1, or 2 (HI, HeI, and HeII, respectively)
===============
relevant kwargs
===============
fluxes : np.ndarray
Array of fluxes corresponding to photon energies in self.igm.E.
return_rc : bool
Return actual heating rate, or rate coefficient for heating?
Former has units of erg s**-1 cm**-3, latter has units of
erg s**-1 cm**-3 atom**-1.
Returns
-------
Volume averaged ionization rate due to secondary electrons,
in units of ionizations per second.
"""
pop = self.pops[popid]
if self.pf['secondary_ionization'] == 0:
return 0.0
if not pop.pf['pop_ion_src_igm']:
return 0.0
if band is not None:
solve_rte = self.background.solve_rte[popid][band]
else:
solve_rte = False
# Computed in IonizationRateIGM in this case
if not solve_rte:
return 0.0
if not np.any(self.background.bands_by_pop[popid] > pop.pf['pop_EminX']):
return 0.0
if ((donor or species) in [1,2]) and (not self.pf['include_He']):
return 0.0
# Grab defaults, do some patches if need be
kw = self._fix_kwargs(**kwargs)
#if self.pf['gamma_igm'] is not None:
# return self.pf['gamma_igm'](z)
species_str = species_i_to_str[species]
donor_str = species_i_to_str[donor]
if self.esec.method > 1 and solve_rte:
fion_const = 1.
if kw['igm_e'] == 0:
fion = self.fion[species_str][popid][band][:,0]
else:
i_x = np.argmin(np.abs(kw['igm_e'] - self.esec.x))
if self.esec.x[i_x] > kw['igm_e']:
i_x -= 1
j = i_x + 1
fion = self.fion[species_str][popid][band][:,i_x] \
+ (self.fion[species_str][popid][band][:,j] - self.fion[species_str][popid][:,i_x]) \
* (kw['igm_e'] - self.esec.x[i_x]) \
/ (self.esec.x[j] - self.esec.x[i_x])
elif self.esec.method > 1:
raise ValueError('Only know how to do advanced secondary ionization with solve_rte=True')
else:
fion = 1.0
fion_const = self.esec.DepositionFraction(kw['igm_e'],
channel=species_str)[0]
norm = J21_num * self.sigma0
if kw['fluxes'][popid] is None:
if self.pf['approx_He']: # assumes lower integration limit > 4 Ryd
integrand = lambda E, zz: \
self.rb.AngleAveragedFluxSlice(z, E, zz, xavg=kw['xavg'],
zxavg=kw['zxavg']) * (self.sigma(E) * (E - E_th[0]) \
+ self.cosm.y * self.sigma(E, 1) * (E - E_th[1])) \
/ E_th[0] / norm / ev_per_hz
else:
integrand = lambda E, zz: \
self.rb.AngleAveragedFluxSlice(z, E, zz, xavg=kw['xavg'],
zxavg=kw['zxavg']) * self.sigma(E) * (E - E_th[0]) \
/ E_th[0] / norm / ev_per_hz
else:
integrand = fion * self.sigma_E[donor_str][popid][band] \
* (self.E[popid][band] - E_th[donor])
if self.pf['approx_He']:
integrand += self.cosm.y * self.sigma_E['he_1'][popid][band] \
* (self.E[popid][band] - E_th[1])
integrand = integrand
integrand *= kw['fluxes'][popid][band] / E_th[species] / norm \
/ ev_per_hz
if type(integrand) == types.FunctionType:
ion, err = dblquad(integrand, z, kw['zf'], lambda a: self.E0,
lambda b: kw['Emax'], epsrel=self.rtol, epsabs=self.atol)
else:
if self.sampled_integrator == 'romb':
ion = romb(integrand * self.E[popid][band],
dx=self.dlogE[popid][band])[0] * log10
else:
ion = simps(integrand * self.E[popid][band],
x=self.logE[popid][band]) * log10
# Re-normalize
ion *= 4. * np.pi * norm * fion_const
# Currently a rate coefficient, returned value depends on return_rc
if kw['return_rc']:
pass
else:
ion *= self.coefficient_to_rate(z, species, **kw)
return ion
def DiffuseLymanAlphaFlux(self, z, **kwargs):
"""
Flux of Lyman-alpha photons induced by photo-electron collisions.
"""
raise NotImplemented('hey fix me')
if not self.pf['secondary_lya']:
return 0.0
#return 1e-25
# Grab defaults, do some patches if need be
kw = self._fix_kwargs(**kwargs)
# Compute fraction of photo-electron energy deposited as Lya excitation
if self.esec.method > 1 and (kw['fluxes'][popid] is not None):
if kw['igm_e'] == 0:
flya = self.flya[:,0]
else:
i_x = np.argmin(np.abs(kw['igm_e'] - self.esec.x))
if self.esec.x[i_x] > kw['igm_e']:
i_x -= 1
j = i_x + 1
flya = self.flya[:,i_x] \
+ (self.flya[:,j] - self.flya[:,i_x]) \
* (kw['igm_e'] - self.esec.x[i_x]) \
/ (self.esec.x[j] - self.esec.x[i_x])
else:
return 0.0
# Re-normalize to help integrator
norm = J21_num * self.sigma0
# Compute integrand
integrand = self.sigma_E[species_str] * (self.E - E_th[species])
integrand *= kw['fluxes'] * flya / norm / ev_per_hz
if kw['Emax'] is not None:
imax = np.argmin(np.abs(self.E - kw['Emax']))
if imax == 0:
return 0.0
if self.sampled_integrator == 'romb':
raise ValueError("Romberg's method cannot be used for integrating subintervals.")
heat = romb(integrand[0:imax] * self.E[0:imax], dx=self.dlogE[0:imax])[0] * log10
else:
heat = simps(integrand[0:imax] * self.E[0:imax], x=self.logE[0:imax]) * log10
else:
imin = np.argmin(np.abs(self.E - self.pop.pf['source_Emin']))
if self.sampled_integrator == 'romb':
heat = romb(integrand[imin:] * self.E[imin:],
dx=self.dlogE[imin:])[0] * log10
elif self.sampled_integrator == 'trapz':
heat = np.trapz(integrand[imin:] * self.E[imin:],
x=self.logE[imin:]) * log10
else:
heat = simps(integrand[imin:] * self.E[imin:],
x=self.logE[imin:]) * log10
# Re-normalize, get rid of per steradian units
heat *= 4. * np.pi * norm * erg_per_ev
# Currently a rate coefficient, returned value depends on return_rc
if kw['return_rc']:
pass
else:
heat *= self.coefficient_to_rate(z, species, **kw)
return heat
|
[] |
[] |
[
"ARES"
] |
[]
|
["ARES"]
|
python
| 1 | 0 | |
util.go
|
package main
import (
"bytes"
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"encoding/base32"
"fmt"
"io"
"net/http"
"net/url"
"os"
"os/signal"
"strings"
"syscall"
"github.com/golang/glog"
"github.com/gorilla/mux"
"gopkg.in/yaml.v2"
)
const (
EnvironmentDevelopment string = "dev"
EnvironmentProduction string = "production"
SPECTRE_DEFAULT_BRAND string = "Spectre"
)
type ReadCloser struct {
io.Reader
io.Closer
}
type WriteCloser struct {
io.Writer
io.Closer
}
func constructMAC(message, key []byte) []byte {
mac := hmac.New(sha256.New, key)
mac.Write(message)
return mac.Sum(nil)
}
func checkMAC(message, messageMAC, key []byte) bool {
return hmac.Equal(messageMAC, constructMAC(message, key))
}
var base32Encoder = base32.NewEncoding("abcdefghjkmnopqrstuvwxyz23456789")
func generateRandomBytes(nbytes int) ([]byte, error) {
uuid := make([]byte, nbytes)
n, err := rand.Read(uuid)
if n != len(uuid) || err != nil {
return []byte{}, err
}
return uuid, nil
}
func generateRandomBase32String(nbytes, outlen int) (string, error) {
uuid, err := generateRandomBytes(nbytes)
if err != nil {
return "", err
}
s := base32Encoder.EncodeToString(uuid)
if outlen == -1 {
outlen = len(s)
}
return s[0:outlen], nil
}
func YAMLUnmarshalFile(filename string, i interface{}) error {
path, err := os.Getwd()
if err != nil {
panic(err)
}
yamlFile, err := os.Open(path + "/" + filename)
if err != nil {
return err
}
fi, err := yamlFile.Stat()
if err != nil {
return err
}
yml := make([]byte, fi.Size())
io.ReadFull(yamlFile, yml)
yamlFile.Close()
err = yaml.Unmarshal(yml, i)
if err != nil {
return err
}
return nil
}
func SlurpFile(path string) (out []byte, err error) {
var file *os.File
if file, err = os.Open(path); err == nil {
buf := &bytes.Buffer{}
io.Copy(buf, file)
out = buf.Bytes()
file.Close()
}
return
}
func BaseURLForRequest(r *http.Request) *url.URL {
determinedScheme := "http"
if RequestIsHTTPS(r) {
determinedScheme = "https"
}
return &url.URL{
Scheme: determinedScheme,
User: r.URL.User,
Host: r.Host,
Path: "/",
}
}
func RequestIsHTTPS(r *http.Request) bool {
proto := strings.ToLower(r.Header.Get("X-Forwarded-Proto"))
if proto == "" {
proto = strings.ToLower(r.URL.Scheme)
}
return proto == "https"
}
func SourceIPForRequest(r *http.Request) string {
ip := r.Header.Get("CF-Connecting-IP")
if ip == "" {
ip := r.Header.Get("X-Forwarded-For")
if ip == "" {
ip = r.RemoteAddr[:strings.LastIndex(r.RemoteAddr, ":")]
}
}
return ip
}
func HTTPSMuxMatcher(r *http.Request, rm *mux.RouteMatch) bool {
return Env() == EnvironmentDevelopment || RequestIsHTTPS(r)
}
func NonHTTPSMuxMatcher(r *http.Request, rm *mux.RouteMatch) bool {
return !HTTPSMuxMatcher(r, rm)
}
type ReloadFunction func()
var reloadFunctions = []ReloadFunction{}
func RegisterReloadFunction(f ReloadFunction) {
reloadFunctions = append(reloadFunctions, f)
}
func ReloadAll() {
for _, f := range reloadFunctions {
f()
}
}
type ByteSize float64
const (
_ = iota // ignore first value by assigning to blank identifier
KB ByteSize = 1 << (10 * iota)
MB
GB
TB
PB
EB
ZB
YB
)
func (b ByteSize) String() string {
switch {
case b >= YB:
return fmt.Sprintf("%.2fYB", b/YB)
case b >= ZB:
return fmt.Sprintf("%.2fZB", b/ZB)
case b >= EB:
return fmt.Sprintf("%.2fEB", b/EB)
case b >= PB:
return fmt.Sprintf("%.2fPB", b/PB)
case b >= TB:
return fmt.Sprintf("%.2fTB", b/TB)
case b >= GB:
return fmt.Sprintf("%.2fGB", b/GB)
case b >= MB:
return fmt.Sprintf("%.2fMB", b/MB)
case b >= KB:
return fmt.Sprintf("%.2fKB", b/KB)
}
return fmt.Sprintf("%.2fB", b)
}
var environment string = EnvironmentDevelopment
func Env() string {
return environment
}
func init() {
environment = os.Getenv("SPECTRE_ENV")
if environment != EnvironmentProduction {
environment = EnvironmentDevelopment
}
brand := os.Getenv("SPECTRE_BRAND")
if brand == "" {
brand = SPECTRE_DEFAULT_BRAND
}
RegisterTemplateFunction("env", func() string { return environment })
RegisterTemplateFunction("brand", func() string {
return brand
})
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGHUP)
go func() {
for _ = range sigChan {
glog.Info("Received SIGHUP")
ReloadAll()
}
}()
}
|
[
"\"SPECTRE_ENV\"",
"\"SPECTRE_BRAND\""
] |
[] |
[
"SPECTRE_BRAND",
"SPECTRE_ENV"
] |
[]
|
["SPECTRE_BRAND", "SPECTRE_ENV"]
|
go
| 2 | 0 | |
course2021/part3_automation/example1/runner.py
|
# Step 1: establish path to traci
import os, sys
if 'SUMO_HOME' in os.environ:
tools = os.path.join(os.environ['SUMO_HOME'], 'tools')
sys.path.append(tools)
else:
sys.exit("please declare environment variable 'SUMO_HOME'")
# Step 2: add traci to be able to access its functionality
import traci
# Step 3: compose a sumo command you would like to run
sumo_command = ["sumo", "-n", "network.net.xml", "-r", "demands.rou.xml"]
# Step 4: open connection between sumo and traci
traci.start(sumo_command)
# Step 5: take simulation steps until there are no more vehicles in the network
while traci.simulation.getMinExpectedNumber() > 0:
traci.simulationStep() # move simulation forward 1 step
###
# Here you can decide what to do with simulation data at each step
###
# Step 6: close connection between sumo and traci
traci.close()
|
[] |
[] |
[
"SUMO_HOME"
] |
[]
|
["SUMO_HOME"]
|
python
| 1 | 0 | |
python/pyspark/pandas/window.py
|
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from abc import ABCMeta, abstractmethod
from functools import partial
from typing import (
Any,
Callable,
Generic,
List,
Optional,
cast,
)
from pyspark.sql import Window
from pyspark.sql import functions as F
from pyspark.pandas.missing.window import (
MissingPandasLikeRolling,
MissingPandasLikeRollingGroupby,
MissingPandasLikeExpanding,
MissingPandasLikeExpandingGroupby,
)
# For running doctests and reference resolution in PyCharm.
from pyspark import pandas as ps # noqa: F401
from pyspark.pandas._typing import FrameLike
from pyspark.pandas.groupby import GroupBy, DataFrameGroupBy
from pyspark.pandas.internal import NATURAL_ORDER_COLUMN_NAME, SPARK_INDEX_NAME_FORMAT
from pyspark.pandas.spark import functions as SF
from pyspark.pandas.utils import scol_for
from pyspark.sql.column import Column
from pyspark.sql.window import WindowSpec
class RollingAndExpanding(Generic[FrameLike], metaclass=ABCMeta):
def __init__(self, window: WindowSpec, min_periods: int):
self._window = window
# This unbounded Window is later used to handle 'min_periods' for now.
self._unbounded_window = Window.orderBy(NATURAL_ORDER_COLUMN_NAME).rowsBetween(
Window.unboundedPreceding, Window.currentRow
)
self._min_periods = min_periods
@abstractmethod
def _apply_as_series_or_frame(self, func: Callable[[Column], Column]) -> FrameLike:
"""
Wraps a function that handles Spark column in order
to support it in both pandas-on-Spark Series and DataFrame.
Note that the given `func` name should be same as the API's method name.
"""
pass
@abstractmethod
def count(self) -> FrameLike:
pass
def sum(self) -> FrameLike:
def sum(scol: Column) -> Column:
return F.when(
F.row_number().over(self._unbounded_window) >= self._min_periods,
F.sum(scol).over(self._window),
).otherwise(SF.lit(None))
return self._apply_as_series_or_frame(sum)
def min(self) -> FrameLike:
def min(scol: Column) -> Column:
return F.when(
F.row_number().over(self._unbounded_window) >= self._min_periods,
F.min(scol).over(self._window),
).otherwise(SF.lit(None))
return self._apply_as_series_or_frame(min)
def max(self) -> FrameLike:
def max(scol: Column) -> Column:
return F.when(
F.row_number().over(self._unbounded_window) >= self._min_periods,
F.max(scol).over(self._window),
).otherwise(SF.lit(None))
return self._apply_as_series_or_frame(max)
def mean(self) -> FrameLike:
def mean(scol: Column) -> Column:
return F.when(
F.row_number().over(self._unbounded_window) >= self._min_periods,
F.mean(scol).over(self._window),
).otherwise(SF.lit(None))
return self._apply_as_series_or_frame(mean)
def std(self) -> FrameLike:
def std(scol: Column) -> Column:
return F.when(
F.row_number().over(self._unbounded_window) >= self._min_periods,
F.stddev(scol).over(self._window),
).otherwise(SF.lit(None))
return self._apply_as_series_or_frame(std)
def var(self) -> FrameLike:
def var(scol: Column) -> Column:
return F.when(
F.row_number().over(self._unbounded_window) >= self._min_periods,
F.variance(scol).over(self._window),
).otherwise(SF.lit(None))
return self._apply_as_series_or_frame(var)
class RollingLike(RollingAndExpanding[FrameLike]):
def __init__(
self,
window: int,
min_periods: Optional[int] = None,
):
if window < 0:
raise ValueError("window must be >= 0")
if (min_periods is not None) and (min_periods < 0):
raise ValueError("min_periods must be >= 0")
if min_periods is None:
# TODO: 'min_periods' is not equivalent in pandas because it does not count NA as
# a value.
min_periods = window
window_spec = Window.orderBy(NATURAL_ORDER_COLUMN_NAME).rowsBetween(
Window.currentRow - (window - 1), Window.currentRow
)
super().__init__(window_spec, min_periods)
def count(self) -> FrameLike:
def count(scol: Column) -> Column:
return F.count(scol).over(self._window)
return self._apply_as_series_or_frame(count).astype("float64") # type: ignore[attr-defined]
class Rolling(RollingLike[FrameLike]):
def __init__(
self,
psdf_or_psser: FrameLike,
window: int,
min_periods: Optional[int] = None,
):
from pyspark.pandas.frame import DataFrame
from pyspark.pandas.series import Series
super().__init__(window, min_periods)
if not isinstance(psdf_or_psser, (DataFrame, Series)):
raise TypeError(
"psdf_or_psser must be a series or dataframe; however, got: %s"
% type(psdf_or_psser)
)
self._psdf_or_psser = psdf_or_psser
def __getattr__(self, item: str) -> Any:
if hasattr(MissingPandasLikeRolling, item):
property_or_func = getattr(MissingPandasLikeRolling, item)
if isinstance(property_or_func, property):
return property_or_func.fget(self)
else:
return partial(property_or_func, self)
raise AttributeError(item)
def _apply_as_series_or_frame(self, func: Callable[[Column], Column]) -> FrameLike:
return cast(
FrameLike,
self._psdf_or_psser._apply_series_op(
lambda psser: psser._with_new_scol(func(psser.spark.column)), # TODO: dtype?
should_resolve=True,
),
)
def count(self) -> FrameLike:
"""
The rolling count of any non-NaN observations inside the window.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.count : Count of the full Series.
DataFrame.count : Count of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 3, float("nan"), 10])
>>> s.rolling(1).count()
0 1.0
1 1.0
2 0.0
3 1.0
dtype: float64
>>> s.rolling(3).count()
0 1.0
1 2.0
2 2.0
3 2.0
dtype: float64
>>> s.to_frame().rolling(1).count()
0
0 1.0
1 1.0
2 0.0
3 1.0
>>> s.to_frame().rolling(3).count()
0
0 1.0
1 2.0
2 2.0
3 2.0
"""
return super().count()
def sum(self) -> FrameLike:
"""
Calculate rolling summation of given DataFrame or Series.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Same type as the input, with the same index, containing the
rolling summation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.sum : Reducing sum for Series.
DataFrame.sum : Reducing sum for DataFrame.
Examples
--------
>>> s = ps.Series([4, 3, 5, 2, 6])
>>> s
0 4
1 3
2 5
3 2
4 6
dtype: int64
>>> s.rolling(2).sum()
0 NaN
1 7.0
2 8.0
3 7.0
4 8.0
dtype: float64
>>> s.rolling(3).sum()
0 NaN
1 NaN
2 12.0
3 10.0
4 13.0
dtype: float64
For DataFrame, each rolling summation is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df
A B
0 4 16
1 3 9
2 5 25
3 2 4
4 6 36
>>> df.rolling(2).sum()
A B
0 NaN NaN
1 7.0 25.0
2 8.0 34.0
3 7.0 29.0
4 8.0 40.0
>>> df.rolling(3).sum()
A B
0 NaN NaN
1 NaN NaN
2 12.0 50.0
3 10.0 38.0
4 13.0 65.0
"""
return super().sum()
def min(self) -> FrameLike:
"""
Calculate the rolling minimum.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the rolling
calculation.
See Also
--------
Series.rolling : Calling object with a Series.
DataFrame.rolling : Calling object with a DataFrame.
Series.min : Similar method for Series.
DataFrame.min : Similar method for DataFrame.
Examples
--------
>>> s = ps.Series([4, 3, 5, 2, 6])
>>> s
0 4
1 3
2 5
3 2
4 6
dtype: int64
>>> s.rolling(2).min()
0 NaN
1 3.0
2 3.0
3 2.0
4 2.0
dtype: float64
>>> s.rolling(3).min()
0 NaN
1 NaN
2 3.0
3 2.0
4 2.0
dtype: float64
For DataFrame, each rolling minimum is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df
A B
0 4 16
1 3 9
2 5 25
3 2 4
4 6 36
>>> df.rolling(2).min()
A B
0 NaN NaN
1 3.0 9.0
2 3.0 9.0
3 2.0 4.0
4 2.0 4.0
>>> df.rolling(3).min()
A B
0 NaN NaN
1 NaN NaN
2 3.0 9.0
3 2.0 4.0
4 2.0 4.0
"""
return super().min()
def max(self) -> FrameLike:
"""
Calculate the rolling maximum.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Return type is determined by the caller.
See Also
--------
Series.rolling : Series rolling.
DataFrame.rolling : DataFrame rolling.
Series.max : Similar method for Series.
DataFrame.max : Similar method for DataFrame.
Examples
--------
>>> s = ps.Series([4, 3, 5, 2, 6])
>>> s
0 4
1 3
2 5
3 2
4 6
dtype: int64
>>> s.rolling(2).max()
0 NaN
1 4.0
2 5.0
3 5.0
4 6.0
dtype: float64
>>> s.rolling(3).max()
0 NaN
1 NaN
2 5.0
3 5.0
4 6.0
dtype: float64
For DataFrame, each rolling maximum is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df
A B
0 4 16
1 3 9
2 5 25
3 2 4
4 6 36
>>> df.rolling(2).max()
A B
0 NaN NaN
1 4.0 16.0
2 5.0 25.0
3 5.0 25.0
4 6.0 36.0
>>> df.rolling(3).max()
A B
0 NaN NaN
1 NaN NaN
2 5.0 25.0
3 5.0 25.0
4 6.0 36.0
"""
return super().max()
def mean(self) -> FrameLike:
"""
Calculate the rolling mean of the values.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the rolling
calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.mean : Equivalent method for Series.
DataFrame.mean : Equivalent method for DataFrame.
Examples
--------
>>> s = ps.Series([4, 3, 5, 2, 6])
>>> s
0 4
1 3
2 5
3 2
4 6
dtype: int64
>>> s.rolling(2).mean()
0 NaN
1 3.5
2 4.0
3 3.5
4 4.0
dtype: float64
>>> s.rolling(3).mean()
0 NaN
1 NaN
2 4.000000
3 3.333333
4 4.333333
dtype: float64
For DataFrame, each rolling mean is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df
A B
0 4 16
1 3 9
2 5 25
3 2 4
4 6 36
>>> df.rolling(2).mean()
A B
0 NaN NaN
1 3.5 12.5
2 4.0 17.0
3 3.5 14.5
4 4.0 20.0
>>> df.rolling(3).mean()
A B
0 NaN NaN
1 NaN NaN
2 4.000000 16.666667
3 3.333333 12.666667
4 4.333333 21.666667
"""
return super().mean()
def std(self) -> FrameLike:
"""
Calculate rolling standard deviation.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the rolling calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.std : Equivalent method for Series.
DataFrame.std : Equivalent method for DataFrame.
numpy.std : Equivalent method for Numpy array.
Examples
--------
>>> s = ps.Series([5, 5, 6, 7, 5, 5, 5])
>>> s.rolling(3).std()
0 NaN
1 NaN
2 0.577350
3 1.000000
4 1.000000
5 1.154701
6 0.000000
dtype: float64
For DataFrame, each rolling standard deviation is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.rolling(2).std()
A B
0 NaN NaN
1 0.000000 0.000000
2 0.707107 7.778175
3 0.707107 9.192388
4 1.414214 16.970563
5 0.000000 0.000000
6 0.000000 0.000000
"""
return super().std()
def var(self) -> FrameLike:
"""
Calculate unbiased rolling variance.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the rolling calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.var : Equivalent method for Series.
DataFrame.var : Equivalent method for DataFrame.
numpy.var : Equivalent method for Numpy array.
Examples
--------
>>> s = ps.Series([5, 5, 6, 7, 5, 5, 5])
>>> s.rolling(3).var()
0 NaN
1 NaN
2 0.333333
3 1.000000
4 1.000000
5 1.333333
6 0.000000
dtype: float64
For DataFrame, each unbiased rolling variance is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.rolling(2).var()
A B
0 NaN NaN
1 0.0 0.0
2 0.5 60.5
3 0.5 84.5
4 2.0 288.0
5 0.0 0.0
6 0.0 0.0
"""
return super().var()
class RollingGroupby(RollingLike[FrameLike]):
def __init__(
self,
groupby: GroupBy[FrameLike],
window: int,
min_periods: Optional[int] = None,
):
super().__init__(window, min_periods)
self._groupby = groupby
self._window = self._window.partitionBy(*[ser.spark.column for ser in groupby._groupkeys])
self._unbounded_window = self._unbounded_window.partitionBy(
*[ser.spark.column for ser in groupby._groupkeys]
)
def __getattr__(self, item: str) -> Any:
if hasattr(MissingPandasLikeRollingGroupby, item):
property_or_func = getattr(MissingPandasLikeRollingGroupby, item)
if isinstance(property_or_func, property):
return property_or_func.fget(self)
else:
return partial(property_or_func, self)
raise AttributeError(item)
def _apply_as_series_or_frame(self, func: Callable[[Column], Column]) -> FrameLike:
"""
Wraps a function that handles Spark column in order
to support it in both pandas-on-Spark Series and DataFrame.
Note that the given `func` name should be same as the API's method name.
"""
from pyspark.pandas import DataFrame
groupby = self._groupby
psdf = groupby._psdf
# Here we need to include grouped key as an index, and shift previous index.
# [index_column0, index_column1] -> [grouped key, index_column0, index_column1]
new_index_scols: List[Column] = []
new_index_spark_column_names = []
new_index_names = []
new_index_fields = []
for groupkey in groupby._groupkeys:
index_column_name = SPARK_INDEX_NAME_FORMAT(len(new_index_scols))
new_index_scols.append(groupkey.spark.column.alias(index_column_name))
new_index_spark_column_names.append(index_column_name)
new_index_names.append(groupkey._column_label)
new_index_fields.append(groupkey._internal.data_fields[0].copy(name=index_column_name))
for new_index_scol, index_name, index_field in zip(
psdf._internal.index_spark_columns,
psdf._internal.index_names,
psdf._internal.index_fields,
):
index_column_name = SPARK_INDEX_NAME_FORMAT(len(new_index_scols))
new_index_scols.append(new_index_scol.alias(index_column_name))
new_index_spark_column_names.append(index_column_name)
new_index_names.append(index_name)
new_index_fields.append(index_field.copy(name=index_column_name))
if groupby._agg_columns_selected:
agg_columns = groupby._agg_columns
else:
# pandas doesn't keep the groupkey as a column from 1.3 for DataFrameGroupBy
column_labels_to_exclude = groupby._column_labels_to_exclude.copy()
if isinstance(groupby, DataFrameGroupBy):
for groupkey in groupby._groupkeys: # type: ignore[attr-defined]
column_labels_to_exclude.add(groupkey._internal.column_labels[0])
agg_columns = [
psdf._psser_for(label)
for label in psdf._internal.column_labels
if label not in column_labels_to_exclude
]
applied = []
for agg_column in agg_columns:
applied.append(agg_column._with_new_scol(func(agg_column.spark.column))) # TODO: dtype?
# Seems like pandas filters out when grouped key is NA.
cond = groupby._groupkeys[0].spark.column.isNotNull()
for c in groupby._groupkeys[1:]:
cond = cond | c.spark.column.isNotNull()
sdf = psdf._internal.spark_frame.filter(cond).select(
new_index_scols + [c.spark.column for c in applied]
)
internal = psdf._internal.copy(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in new_index_spark_column_names],
index_names=new_index_names,
index_fields=new_index_fields,
column_labels=[c._column_label for c in applied],
data_spark_columns=[
scol_for(sdf, c._internal.data_spark_column_names[0]) for c in applied
],
data_fields=[c._internal.data_fields[0] for c in applied],
)
return groupby._cleanup_and_return(DataFrame(internal))
def count(self) -> FrameLike:
"""
The rolling count of any non-NaN observations inside the window.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the expanding
calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.count : Count of the full Series.
DataFrame.count : Count of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).rolling(3).count().sort_index()
2 0 1.0
1 2.0
3 2 1.0
3 2.0
4 3.0
4 5 1.0
6 2.0
7 3.0
8 3.0
5 9 1.0
10 2.0
dtype: float64
For DataFrame, each rolling count is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).rolling(2).count().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 1.0
1 2.0
3 2 1.0
3 2.0
4 2.0
4 5 1.0
6 2.0
7 2.0
8 2.0
5 9 1.0
10 2.0
"""
return super().count()
def sum(self) -> FrameLike:
"""
The rolling summation of any non-NaN observations inside the window.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the rolling
calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.sum : Sum of the full Series.
DataFrame.sum : Sum of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).rolling(3).sum().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 9.0
4 5 NaN
6 NaN
7 12.0
8 12.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each rolling summation is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).rolling(2).sum().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 8.0
3 2 NaN
3 18.0
4 18.0
4 5 NaN
6 32.0
7 32.0
8 32.0
5 9 NaN
10 50.0
"""
return super().sum()
def min(self) -> FrameLike:
"""
The rolling minimum of any non-NaN observations inside the window.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the rolling
calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.min : Min of the full Series.
DataFrame.min : Min of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).rolling(3).min().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 3.0
4 5 NaN
6 NaN
7 4.0
8 4.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each rolling minimum is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).rolling(2).min().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 4.0
3 2 NaN
3 9.0
4 9.0
4 5 NaN
6 16.0
7 16.0
8 16.0
5 9 NaN
10 25.0
"""
return super().min()
def max(self) -> FrameLike:
"""
The rolling maximum of any non-NaN observations inside the window.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the rolling
calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.max : Max of the full Series.
DataFrame.max : Max of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).rolling(3).max().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 3.0
4 5 NaN
6 NaN
7 4.0
8 4.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each rolling maximum is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).rolling(2).max().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 4.0
3 2 NaN
3 9.0
4 9.0
4 5 NaN
6 16.0
7 16.0
8 16.0
5 9 NaN
10 25.0
"""
return super().max()
def mean(self) -> FrameLike:
"""
The rolling mean of any non-NaN observations inside the window.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the rolling
calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.mean : Mean of the full Series.
DataFrame.mean : Mean of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).rolling(3).mean().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 3.0
4 5 NaN
6 NaN
7 4.0
8 4.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each rolling mean is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).rolling(2).mean().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 4.0
3 2 NaN
3 9.0
4 9.0
4 5 NaN
6 16.0
7 16.0
8 16.0
5 9 NaN
10 25.0
"""
return super().mean()
def std(self) -> FrameLike:
"""
Calculate rolling standard deviation.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the rolling calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.std : Equivalent method for Series.
DataFrame.std : Equivalent method for DataFrame.
numpy.std : Equivalent method for Numpy array.
"""
return super().std()
def var(self) -> FrameLike:
"""
Calculate unbiased rolling variance.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the rolling calculation.
See Also
--------
Series.rolling : Calling object with Series data.
DataFrame.rolling : Calling object with DataFrames.
Series.var : Equivalent method for Series.
DataFrame.var : Equivalent method for DataFrame.
numpy.var : Equivalent method for Numpy array.
"""
return super().var()
class ExpandingLike(RollingAndExpanding[FrameLike]):
def __init__(self, min_periods: int = 1):
if min_periods < 0:
raise ValueError("min_periods must be >= 0")
window = Window.orderBy(NATURAL_ORDER_COLUMN_NAME).rowsBetween(
Window.unboundedPreceding, Window.currentRow
)
super().__init__(window, min_periods)
def count(self) -> FrameLike:
def count(scol: Column) -> Column:
return F.when(
F.row_number().over(self._unbounded_window) >= self._min_periods,
F.count(scol).over(self._window),
).otherwise(F.lit(None))
return self._apply_as_series_or_frame(count).astype("float64") # type: ignore[attr-defined]
class Expanding(ExpandingLike[FrameLike]):
def __init__(self, psdf_or_psser: FrameLike, min_periods: int = 1):
from pyspark.pandas.frame import DataFrame
from pyspark.pandas.series import Series
super().__init__(min_periods)
if not isinstance(psdf_or_psser, (DataFrame, Series)):
raise TypeError(
"psdf_or_psser must be a series or dataframe; however, got: %s"
% type(psdf_or_psser)
)
self._psdf_or_psser = psdf_or_psser
def __getattr__(self, item: str) -> Any:
if hasattr(MissingPandasLikeExpanding, item):
property_or_func = getattr(MissingPandasLikeExpanding, item)
if isinstance(property_or_func, property):
return property_or_func.fget(self)
else:
return partial(property_or_func, self)
raise AttributeError(item)
# TODO: when add 'center' and 'axis' parameter, should add to here too.
def __repr__(self) -> str:
return "Expanding [min_periods={}]".format(self._min_periods)
_apply_as_series_or_frame = Rolling._apply_as_series_or_frame
def count(self) -> FrameLike:
"""
The expanding count of any non-NaN observations inside the window.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the expanding
calculation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.count : Count of the full Series.
DataFrame.count : Count of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 3, float("nan"), 10])
>>> s.expanding().count()
0 1.0
1 2.0
2 2.0
3 3.0
dtype: float64
>>> s.to_frame().expanding().count()
0
0 1.0
1 2.0
2 2.0
3 3.0
"""
return super().count()
def sum(self) -> FrameLike:
"""
Calculate expanding summation of given DataFrame or Series.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Same type as the input, with the same index, containing the
expanding summation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.sum : Reducing sum for Series.
DataFrame.sum : Reducing sum for DataFrame.
Examples
--------
>>> s = ps.Series([1, 2, 3, 4, 5])
>>> s
0 1
1 2
2 3
3 4
4 5
dtype: int64
>>> s.expanding(3).sum()
0 NaN
1 NaN
2 6.0
3 10.0
4 15.0
dtype: float64
For DataFrame, each expanding summation is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df
A B
0 1 1
1 2 4
2 3 9
3 4 16
4 5 25
>>> df.expanding(3).sum()
A B
0 NaN NaN
1 NaN NaN
2 6.0 14.0
3 10.0 30.0
4 15.0 55.0
"""
return super().sum()
def min(self) -> FrameLike:
"""
Calculate the expanding minimum.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the expanding
calculation.
See Also
--------
Series.expanding : Calling object with a Series.
DataFrame.expanding : Calling object with a DataFrame.
Series.min : Similar method for Series.
DataFrame.min : Similar method for DataFrame.
Examples
--------
Performing a expanding minimum with a window size of 3.
>>> s = ps.Series([4, 3, 5, 2, 6])
>>> s.expanding(3).min()
0 NaN
1 NaN
2 3.0
3 2.0
4 2.0
dtype: float64
"""
return super().min()
def max(self) -> FrameLike:
"""
Calculate the expanding maximum.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Return type is determined by the caller.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.max : Similar method for Series.
DataFrame.max : Similar method for DataFrame.
Examples
--------
Performing a expanding minimum with a window size of 3.
>>> s = ps.Series([4, 3, 5, 2, 6])
>>> s.expanding(3).max()
0 NaN
1 NaN
2 5.0
3 5.0
4 6.0
dtype: float64
"""
return super().max()
def mean(self) -> FrameLike:
"""
Calculate the expanding mean of the values.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the expanding
calculation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.mean : Equivalent method for Series.
DataFrame.mean : Equivalent method for DataFrame.
Examples
--------
The below examples will show expanding mean calculations with window sizes of
two and three, respectively.
>>> s = ps.Series([1, 2, 3, 4])
>>> s.expanding(2).mean()
0 NaN
1 1.5
2 2.0
3 2.5
dtype: float64
>>> s.expanding(3).mean()
0 NaN
1 NaN
2 2.0
3 2.5
dtype: float64
"""
return super().mean()
def std(self) -> FrameLike:
"""
Calculate expanding standard deviation.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the expanding calculation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.std : Equivalent method for Series.
DataFrame.std : Equivalent method for DataFrame.
numpy.std : Equivalent method for Numpy array.
Examples
--------
>>> s = ps.Series([5, 5, 6, 7, 5, 5, 5])
>>> s.expanding(3).std()
0 NaN
1 NaN
2 0.577350
3 0.957427
4 0.894427
5 0.836660
6 0.786796
dtype: float64
For DataFrame, each expanding standard deviation variance is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.expanding(2).std()
A B
0 NaN NaN
1 0.000000 0.000000
2 0.577350 6.350853
3 0.957427 11.412712
4 0.894427 10.630146
5 0.836660 9.928075
6 0.786796 9.327379
"""
return super().std()
def var(self) -> FrameLike:
"""
Calculate unbiased expanding variance.
.. note:: the current implementation of this API uses Spark's Window without
specifying partition specification. This leads to move all data into
single partition in single machine and could cause serious
performance degradation. Avoid this method against very large dataset.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the expanding calculation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.var : Equivalent method for Series.
DataFrame.var : Equivalent method for DataFrame.
numpy.var : Equivalent method for Numpy array.
Examples
--------
>>> s = ps.Series([5, 5, 6, 7, 5, 5, 5])
>>> s.expanding(3).var()
0 NaN
1 NaN
2 0.333333
3 0.916667
4 0.800000
5 0.700000
6 0.619048
dtype: float64
For DataFrame, each unbiased expanding variance is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.expanding(2).var()
A B
0 NaN NaN
1 0.000000 0.000000
2 0.333333 40.333333
3 0.916667 130.250000
4 0.800000 113.000000
5 0.700000 98.566667
6 0.619048 87.000000
"""
return super().var()
class ExpandingGroupby(ExpandingLike[FrameLike]):
def __init__(self, groupby: GroupBy[FrameLike], min_periods: int = 1):
super().__init__(min_periods)
self._groupby = groupby
self._window = self._window.partitionBy(*[ser.spark.column for ser in groupby._groupkeys])
self._unbounded_window = self._window.partitionBy(
*[ser.spark.column for ser in groupby._groupkeys]
)
def __getattr__(self, item: str) -> Any:
if hasattr(MissingPandasLikeExpandingGroupby, item):
property_or_func = getattr(MissingPandasLikeExpandingGroupby, item)
if isinstance(property_or_func, property):
return property_or_func.fget(self)
else:
return partial(property_or_func, self)
raise AttributeError(item)
_apply_as_series_or_frame = RollingGroupby._apply_as_series_or_frame
def count(self) -> FrameLike:
"""
The expanding count of any non-NaN observations inside the window.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the expanding
calculation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.count : Count of the full Series.
DataFrame.count : Count of the full DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).expanding(3).count().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 3.0
4 5 NaN
6 NaN
7 3.0
8 4.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each expanding count is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).expanding(2).count().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 2.0
3 2 NaN
3 2.0
4 3.0
4 5 NaN
6 2.0
7 3.0
8 4.0
5 9 NaN
10 2.0
"""
return super().count()
def sum(self) -> FrameLike:
"""
Calculate expanding summation of given DataFrame or Series.
Returns
-------
Series or DataFrame
Same type as the input, with the same index, containing the
expanding summation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.sum : Reducing sum for Series.
DataFrame.sum : Reducing sum for DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).expanding(3).sum().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 9.0
4 5 NaN
6 NaN
7 12.0
8 16.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each expanding summation is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).expanding(2).sum().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 8.0
3 2 NaN
3 18.0
4 27.0
4 5 NaN
6 32.0
7 48.0
8 64.0
5 9 NaN
10 50.0
"""
return super().sum()
def min(self) -> FrameLike:
"""
Calculate the expanding minimum.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the expanding
calculation.
See Also
--------
Series.expanding : Calling object with a Series.
DataFrame.expanding : Calling object with a DataFrame.
Series.min : Similar method for Series.
DataFrame.min : Similar method for DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).expanding(3).min().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 3.0
4 5 NaN
6 NaN
7 4.0
8 4.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each expanding minimum is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).expanding(2).min().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 4.0
3 2 NaN
3 9.0
4 9.0
4 5 NaN
6 16.0
7 16.0
8 16.0
5 9 NaN
10 25.0
"""
return super().min()
def max(self) -> FrameLike:
"""
Calculate the expanding maximum.
Returns
-------
Series or DataFrame
Return type is determined by the caller.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.max : Similar method for Series.
DataFrame.max : Similar method for DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).expanding(3).max().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 3.0
4 5 NaN
6 NaN
7 4.0
8 4.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each expanding maximum is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).expanding(2).max().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 4.0
3 2 NaN
3 9.0
4 9.0
4 5 NaN
6 16.0
7 16.0
8 16.0
5 9 NaN
10 25.0
"""
return super().max()
def mean(self) -> FrameLike:
"""
Calculate the expanding mean of the values.
Returns
-------
Series or DataFrame
Returned object type is determined by the caller of the expanding
calculation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.mean : Equivalent method for Series.
DataFrame.mean : Equivalent method for DataFrame.
Examples
--------
>>> s = ps.Series([2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5])
>>> s.groupby(s).expanding(3).mean().sort_index()
2 0 NaN
1 NaN
3 2 NaN
3 NaN
4 3.0
4 5 NaN
6 NaN
7 4.0
8 4.0
5 9 NaN
10 NaN
dtype: float64
For DataFrame, each expanding mean is computed column-wise.
>>> df = ps.DataFrame({"A": s.to_numpy(), "B": s.to_numpy() ** 2})
>>> df.groupby(df.A).expanding(2).mean().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
2 0 NaN
1 4.0
3 2 NaN
3 9.0
4 9.0
4 5 NaN
6 16.0
7 16.0
8 16.0
5 9 NaN
10 25.0
"""
return super().mean()
def std(self) -> FrameLike:
"""
Calculate expanding standard deviation.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the expanding calculation.
See Also
--------
Series.expanding: Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.std : Equivalent method for Series.
DataFrame.std : Equivalent method for DataFrame.
numpy.std : Equivalent method for Numpy array.
"""
return super().std()
def var(self) -> FrameLike:
"""
Calculate unbiased expanding variance.
Returns
-------
Series or DataFrame
Returns the same object type as the caller of the expanding calculation.
See Also
--------
Series.expanding : Calling object with Series data.
DataFrame.expanding : Calling object with DataFrames.
Series.var : Equivalent method for Series.
DataFrame.var : Equivalent method for DataFrame.
numpy.var : Equivalent method for Numpy array.
"""
return super().var()
def _test() -> None:
import os
import doctest
import sys
from pyspark.sql import SparkSession
import pyspark.pandas.window
os.chdir(os.environ["SPARK_HOME"])
globs = pyspark.pandas.window.__dict__.copy()
globs["ps"] = pyspark.pandas
spark = (
SparkSession.builder.master("local[4]").appName("pyspark.pandas.window tests").getOrCreate()
)
(failure_count, test_count) = doctest.testmod(
pyspark.pandas.window,
globs=globs,
optionflags=doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE,
)
spark.stop()
if failure_count:
sys.exit(-1)
if __name__ == "__main__":
_test()
|
[] |
[] |
[
"SPARK_HOME"
] |
[]
|
["SPARK_HOME"]
|
python
| 1 | 0 | |
pkg/environmentvar/environmentvar_test.go
|
package environmentvar
import (
"os"
"testing"
"github.com/stretchr/testify/assert"
)
func TestSetEnv(t *testing.T) {
os.Setenv("NODE_ENV", "production")
defer os.Unsetenv("NODE_ENV")
actual := os.Getenv("NODE_ENV")
assert.Equal(t, actual, "production")
}
|
[
"\"NODE_ENV\""
] |
[] |
[
"NODE_ENV"
] |
[]
|
["NODE_ENV"]
|
go
| 1 | 0 | |
vendor/github.com/armory/dinghy/pkg/settings/load.go
|
/*
* Copyright 2019 Armory, Inc.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Package settings is a single place to put all of the application settings.
package settings
import (
"context"
"encoding/json"
"errors"
"io/ioutil"
"os"
"strconv"
"strings"
"github.com/armory/go-yaml-tools/pkg/secrets"
"github.com/armory/go-yaml-tools/pkg/tls/server"
"github.com/mitchellh/mapstructure"
"github.com/armory/dinghy/pkg/util"
"github.com/armory/go-yaml-tools/pkg/spring"
"github.com/imdario/mergo"
log "github.com/sirupsen/logrus"
)
const (
// DefaultDinghyPort is the default port that Dinghy will listen on.
DefaultDinghyPort = 8081
)
func NewDefaultSettings() Settings {
dinghyPort, err := strconv.ParseUint(util.GetenvOrDefault("DINGHY_PORT", string(DefaultDinghyPort)), 10, 32)
if err != nil {
dinghyPort = DefaultDinghyPort
}
return Settings{
DinghyFilename: "dinghyfile",
TemplateRepo: "dinghy-templates",
AutoLockPipelines: "true",
GitHubCredsPath: util.GetenvOrDefault("GITHUB_TOKEN_PATH", os.Getenv("HOME")+"/.armory/cache/github-creds.txt"),
GithubEndpoint: "https://api.github.com",
StashCredsPath: util.GetenvOrDefault("STASH_TOKEN_PATH", os.Getenv("HOME")+"/.armory/cache/stash-creds.txt"),
StashEndpoint: "http://localhost:7990/rest/api/1.0",
Logging: Logging{
File: "",
Level: "INFO",
},
spinnakerSupplied: spinnakerSupplied{
Orca: spinnakerService{
Enabled: "true",
BaseURL: util.GetenvOrDefault("ORCA_BASE_URL", "http://orca:8083"),
},
Front50: spinnakerService{
Enabled: "true",
BaseURL: util.GetenvOrDefault("FRONT50_BASE_URL", "http://front50:8080"),
},
Echo: spinnakerService{
BaseURL: util.GetenvOrDefault("ECHO_BASE_URL", "http://echo:8089"),
},
Fiat: fiat{
spinnakerService: spinnakerService{
Enabled: "false",
BaseURL: util.GetenvOrDefault("FIAT_BASE_URL", "http://fiat:7003"),
},
AuthUser: "",
},
Redis: Redis{
BaseURL: util.GetenvOrDefault("REDIS_HOST", "redis:6379"),
Password: util.GetenvOrDefaultRedact("REDIS_PASSWORD", ""),
},
},
ParserFormat: "json",
RepoConfig: []RepoConfig{},
Server: server.ServerConfig{
Port: uint32(dinghyPort),
},
}
}
// LoadSettings loads the Spring config from the default Spinnaker paths
// and merges default settings with the loaded settings
func LoadSettings() (*Settings, error) {
springConfig, err := loadProfiles()
if err != nil {
return nil, err
}
settings, err := configureSettings(NewDefaultSettings(), springConfig)
if err != nil {
return nil, err
}
if err = settings.Http.Init(); err != nil {
return nil, err
}
return settings, nil
}
func configureSettings(defaultSettings, overrides Settings) (*Settings, error) {
if err := mergo.Merge(&defaultSettings, overrides, mergo.WithOverride); err != nil {
return nil, err
}
// If Github token not passed directly
// Required for backwards compatibility
if defaultSettings.GitHubToken == "" {
// load github api token
if _, err := os.Stat(defaultSettings.GitHubCredsPath); err == nil {
creds, err := ioutil.ReadFile(defaultSettings.GitHubCredsPath)
if err != nil {
return nil, err
}
c := strings.Split(strings.TrimSpace(string(creds)), ":")
if len(c) < 2 {
return nil, errors.New("github creds file should have format 'username:token'")
}
defaultSettings.GitHubToken = c[1]
log.Info("Successfully loaded github api creds")
}
}
// If Stash token not passed directly
// Required for backwards compatibility
if defaultSettings.StashToken == "" || defaultSettings.StashUsername == "" {
// load stash api creds
if _, err := os.Stat(defaultSettings.StashCredsPath); err == nil {
creds, err := ioutil.ReadFile(defaultSettings.StashCredsPath)
if err != nil {
return nil, err
}
c := strings.Split(strings.TrimSpace(string(creds)), ":")
if len(c) < 2 {
return nil, errors.New("stash creds file should have format 'username:token'")
}
defaultSettings.StashUsername = c[0]
defaultSettings.StashToken = c[1]
log.Info("Successfully loaded stash api creds")
}
}
// Required for backwards compatibility
if defaultSettings.Deck.BaseURL == "" && defaultSettings.SpinnakerUIURL != "" {
log.Warn("Spinnaker UI URL should be set with ${services.deck.baseUrl}")
defaultSettings.Deck.BaseURL = defaultSettings.SpinnakerUIURL
}
// Take the FiatUser setting if fiat is enabled (coming from hal settings)
if defaultSettings.Fiat.Enabled == "true" && defaultSettings.FiatUser != "" {
defaultSettings.Fiat.AuthUser = defaultSettings.FiatUser
}
if defaultSettings.ParserFormat == "" {
defaultSettings.ParserFormat = "json"
}
c, _ := json.Marshal(defaultSettings.Redacted())
log.Infof("The following settings have been loaded: %v", string(c))
return &defaultSettings, nil
}
func decodeProfilesToSettings(profiles map[string]interface{}, s *Settings) error {
decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
WeaklyTypedInput: true,
Result: s,
})
if err != nil {
return err
}
return decoder.Decode(profiles)
}
func loadProfiles() (Settings, error) {
// var s Settings
var config Settings
propNames := []string{"spinnaker", "dinghy"}
c, err := spring.LoadDefault(propNames)
if err != nil {
return config, err
}
if err := decodeProfilesToSettings(c, &config); err != nil {
return config, err
}
if (Secrets{}) != config.Secrets {
if (secrets.VaultConfig{}) != config.Secrets.Vault {
if err = secrets.RegisterVaultConfig(config.Secrets.Vault); err != nil {
return config, err
}
}
}
if err = decryptSecrets(context.TODO(), &config); err != nil {
log.Fatalf("failed to decrypt secrets: %s", err)
}
return config, nil
}
func decryptSecrets(ctx context.Context, config *Settings) error {
decrypter, err := secrets.NewDecrypter(ctx, config.GitHubToken)
if err != nil {
return err
}
secret, err := decrypter.Decrypt()
if err != nil {
return err
}
config.GitHubToken = secret
decrypter, err = secrets.NewDecrypter(ctx, config.StashToken)
if err != nil {
return err
}
secret, err = decrypter.Decrypt()
if err != nil {
return err
}
config.StashToken = secret
return nil
}
|
[
"\"HOME\"",
"\"HOME\""
] |
[] |
[
"HOME"
] |
[]
|
["HOME"]
|
go
| 1 | 0 | |
pkg/terraform/install_test.go
|
package terraform
import (
"bytes"
"io/ioutil"
"os"
"strings"
"testing"
"github.com/deislabs/porter/pkg/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gopkg.in/yaml.v2"
)
type InstallTest struct {
expectedCommand string
installStep InstallStep
}
// sad hack: not sure how to make a common test main for all my subpackages
func TestMain(m *testing.M) {
test.TestMainWithMockedCommandHandlers(m)
}
func TestMixin_UnmarshalInstallStep(t *testing.T) {
b, err := ioutil.ReadFile("testdata/install-input.yaml")
require.NoError(t, err)
var action InstallAction
err = yaml.Unmarshal(b, &action)
require.NoError(t, err)
require.Len(t, action.Steps, 1)
step := action.Steps[0]
assert.Equal(t, "Install MySQL", step.Description)
assert.Equal(t, "TRACE", step.LogLevel)
}
func TestMixin_Install(t *testing.T) {
installTests := []InstallTest{
{
expectedCommand: strings.Join([]string{
"terraform init",
"terraform apply -auto-approve -var cool=true -var foo=bar",
}, "\n"),
installStep: InstallStep{
InstallArguments: InstallArguments{
AutoApprove: true,
LogLevel: "TRACE",
Vars: map[string]string{
"cool": "true",
"foo": "bar",
},
},
},
},
}
defer os.Unsetenv(test.ExpectedCommandEnv)
for _, installTest := range installTests {
t.Run(installTest.expectedCommand, func(t *testing.T) {
os.Setenv(test.ExpectedCommandEnv, installTest.expectedCommand)
action := InstallAction{Steps: []InstallStep{installTest.installStep}}
b, err := yaml.Marshal(action)
require.NoError(t, err)
h := NewTestMixin(t)
h.In = bytes.NewReader(b)
// Set up working dir as current dir
h.WorkingDir, err = os.Getwd()
require.NoError(t, err)
err = h.Install()
require.NoError(t, err)
assert.Equal(t, "TRACE", os.Getenv("TF_LOG"))
wd, err := os.Getwd()
require.NoError(t, err)
assert.Equal(t, wd, h.WorkingDir)
})
}
}
|
[
"\"TF_LOG\""
] |
[] |
[
"TF_LOG"
] |
[]
|
["TF_LOG"]
|
go
| 1 | 0 | |
a-plus-rst-tools/conf.py
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Sample documentation build configuration file, created by
# sphinx-quickstart on Tue May 3 14:15:50 2016.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
# -- Aplus configuration --------------------------------------------------
course_open_date = '2016-01-01'
course_close_date = '2017-01-01'
questionnaire_default_submissions = 5
program_default_submissions = 10
ae_default_submissions = 0
use_wide_column = True
static_host = os.environ.get('STATIC_CONTENT_HOST', None)
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
sys.path.append(os.path.abspath('a-plus-rst-tools'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.todo',
'sphinx.ext.mathjax',
'sphinx.ext.ifconfig',
'aplus_setup',
]
# Add any paths that contain templates here, relative to this directory.
#templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'Sample'
copyright = '2016, NN'
author = 'NN'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '0.1'
# The full version, including alpha/beta/rc tags.
release = '0.1'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = 'en'
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
#pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = True
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'aplus'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
html_theme_options = {
'use_wide_column': use_wide_column,
}
# Add any paths that contain custom themes here, relative to this directory.
html_theme_path = ['a-plus-rst-tools/theme']
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr'
#html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
#html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'Sampledoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'Sample.tex', 'Sample Documentation',
'NN', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'sample', 'Sample Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'Sample', 'Sample Documentation',
author, 'Sample', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
|
[] |
[] |
[
"STATIC_CONTENT_HOST"
] |
[]
|
["STATIC_CONTENT_HOST"]
|
python
| 1 | 0 | |
config/production.py
|
import os
API_URI = os.environ["WRISTBAND_API_URI"]
SECRET_KEY = os.environ["FLASK_SECRET_KEY"]
|
[] |
[] |
[
"WRISTBAND_API_URI",
"FLASK_SECRET_KEY"
] |
[]
|
["WRISTBAND_API_URI", "FLASK_SECRET_KEY"]
|
python
| 2 | 0 | |
resolver/resolver.go
|
package resolver
import (
"context"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"net/http"
"os"
"regexp"
"sort"
"strings"
"time"
"github.com/google/go-github/v28/github"
goSem "github.com/tj/go-semver"
"golang.org/x/oauth2"
"github.com/Masterminds/semver"
)
const DEFAULT_PROXY_URL = "https://proxy.golang.org"
const hashRegex = "^[0-9a-f]{7,40}$"
var gh = &GitHub{}
type Resolver struct {
Pkg string
Value string
Hash bool
ConstraintCheck *semver.Constraints
ghClient *github.Client
}
type GitHub struct {
// Client is the GitHub client.
Client *github.Client
}
type VersionInfo struct {
Version string // version string
Time time.Time // commit time
}
func init() {
ctx := context.Background()
ghClient := oauth2.StaticTokenSource(
&oauth2.Token{
AccessToken: os.Getenv("GITHUB_TOKEN"),
},
)
gh.Client = github.NewClient(oauth2.NewClient(ctx, ghClient))
}
// Resolve the version for the given package by
// checking with the proxy for either the specified version
// or getting the latest version on the proxy
func (v *Resolver) ResolveVersion() (string, error) {
if len(v.Value) == 0 {
version, err := v.ResolveLatestVersion()
if err != nil {
if v.isGithubPKG() {
return v.GithubFallbackResolveVersion()
}
return "", err
}
if len(version.Version) == 0 {
return v.GithubFallbackResolveVersion()
}
return version.Version, err
}
if v.Hash {
return v.Value, nil
}
versionString, err := v.ResolveClosestVersion()
if err != nil {
return "", err
}
if len(versionString) == 0 && v.isGithubPKG() {
return v.GithubFallbackResolveVersion()
}
return versionString, nil
}
func (v *Resolver) isGithubPKG() bool {
parts := strings.Split(v.Pkg, "/")
return parts[0] == "github.com"
}
func (v *Resolver) GithubFallbackResolveVersion() (string, error) {
parts := strings.Split(v.Pkg, "/")
version := "master"
if len(v.Value) == 0 {
version = v.Value
}
resolvedV, err := gh.resolve(parts[1], parts[2], version)
if err != nil {
return "", err
}
return resolvedV, nil
}
// resolve the latest version from the proxy
func (v *Resolver) ResolveLatestVersion() (VersionInfo, error) {
var versionInfo VersionInfo
resp, err := http.Get(getVersionLatestProxyURL(v.Pkg))
if err != nil {
return versionInfo, err
}
defer resp.Body.Close()
respBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return versionInfo, err
}
if err := json.Unmarshal(respBytes, &versionInfo); err != nil {
return versionInfo, err
}
return versionInfo, nil
}
// Parse the given string to be either a semver version string
// or a commit hash
func (v *Resolver) ParseVersion(version string) error {
v.Value = version
// just send back if no version is provided
if len(version) == 0 {
return nil
}
// return the string back if it's a valid hash string
if !isSemver(version) && !isValidSemverConstraint(version) {
matched, err := regexp.MatchString(hashRegex, version)
if matched {
v.Hash = true
return nil
}
// if not a hash or a semver, just return an error
if err != nil {
return err
}
}
if isSemver(version) {
check, err := semver.NewConstraint("= " + version)
if err != nil {
return err
}
v.ConstraintCheck = check
}
if isValidSemverConstraint(version) {
check, err := semver.NewConstraint(version)
if err != nil {
return err
}
v.ConstraintCheck = check
}
return nil
}
// Resolve the closes version to the given semver from the proxy
func (v *Resolver) ResolveClosestVersion() (string, error) {
var versionTags []string
resp, err := http.Get(getVersionListProxyURL(v.Pkg))
if err != nil {
return "", err
}
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
versionTags = strings.Split(string(data), "\n")
matchedVersion := ""
var sortedVersionTags []*semver.Version
for _, versionTag := range versionTags {
if len(versionTag) == 0 {
continue
}
ver, err := semver.NewVersion(versionTag)
if err != nil {
return "", err
}
sortedVersionTags = append(sortedVersionTags, ver)
}
sort.Sort(semver.Collection(sortedVersionTags))
for _, versionTag := range sortedVersionTags {
if !v.ConstraintCheck.Check(
versionTag,
) {
continue
}
matchedVersion = versionTag.String()
break
}
if len(matchedVersion) == 0 {
return "", nil
}
return matchedVersion, nil
}
// check if the given string is valid semver string and if yest
// create a constraint checker out of it
func isSemver(version string) bool {
_, err := semver.NewVersion(version)
return err == nil
}
func isValidSemverConstraint(version string) bool {
versionRegex := `v?([0-9|x|X|\*]+)(\.[0-9|x|X|\*]+)?(\.[0-9|x|X|\*]+)?` +
`(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
`(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
constraintOperations := `=||!=|>|<|>=|=>|<=|=<|~|~>|\^`
validConstraintRegex := regexp.MustCompile(fmt.Sprintf(
`^(\s*(%s)\s*(%s)\s*\,?)+$`,
constraintOperations,
versionRegex))
return validConstraintRegex.MatchString(version)
}
// normalize the proxy url to
// - not have traling slashes
func normalizeUrl(url string) string {
if strings.HasSuffix(url, "/") {
ind := strings.LastIndex(url, "/")
if ind == -1 {
return url
}
return strings.Join([]string{url[:ind], "", url[ind+1:]}, "")
}
return url
}
// get the proxy url for the latest version
func getVersionLatestProxyURL(pkg string) string {
urlPrefix := normalizeUrl(DEFAULT_PROXY_URL)
return urlPrefix + "/" + pkg + "/@latest"
}
// get the proxy url for the entire version list
func getVersionListProxyURL(pkg string) string {
urlPrefix := normalizeUrl(DEFAULT_PROXY_URL)
return urlPrefix + "/" + pkg + "/@v/list"
}
func (g *GitHub) versions(owner, repo string) (versions []string, err error) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
defer cancel()
page := 1
for {
options := &github.ListOptions{
Page: page,
PerPage: 100,
}
tags, _, err := g.Client.Repositories.ListTags(ctx, owner, repo, options)
if err != nil {
return nil, fmt.Errorf("listing tags: %w", err)
}
if len(tags) == 0 {
break
}
for _, t := range tags {
versions = append(versions, t.GetName())
}
page++
}
if len(versions) == 0 {
return nil, errors.New("no versions defined")
}
return
}
// Resolve implementation.
func (g *GitHub) resolve(owner, repo, version string) (string, error) {
// fetch tags
tags, err := g.versions(owner, repo)
if err != nil {
return "", err
}
// convert to semver, ignoring malformed
var versions []goSem.Version
for _, t := range tags {
if v, err := goSem.Parse(t); err == nil {
versions = append(versions, v)
}
}
// no versions, it has tags but they're not semver
if len(versions) == 0 {
return "", errors.New("no versions matched")
}
// master special-case
if version == "master" {
return versions[0].String(), nil
}
// match requested semver range
vr, err := goSem.ParseRange(version)
if err != nil {
return "", fmt.Errorf("parsing version range: %w", err)
}
for _, v := range versions {
if vr.Match(v) {
return v.String(), nil
}
}
return "", errors.New("no versions matched")
}
|
[
"\"GITHUB_TOKEN\""
] |
[] |
[
"GITHUB_TOKEN"
] |
[]
|
["GITHUB_TOKEN"]
|
go
| 1 | 0 | |
Matrimony/manage.py
|
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
"""Run administrative tasks."""
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Matrimony.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
controllers/kustomization_controller.go
|
/*
Copyright 2020 The Flux authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package controllers
import (
"context"
"errors"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
securejoin "github.com/cyphar/filepath-securejoin"
"github.com/fluxcd/pkg/apis/meta"
"github.com/fluxcd/pkg/runtime/events"
"github.com/fluxcd/pkg/runtime/metrics"
"github.com/fluxcd/pkg/runtime/predicates"
"github.com/fluxcd/pkg/untar"
sourcev1 "github.com/fluxcd/source-controller/api/v1beta1"
"github.com/go-logr/logr"
"github.com/hashicorp/go-retryablehttp"
apierrors "k8s.io/apimachinery/pkg/api/errors"
apimeta "k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/types"
kuberecorder "k8s.io/client-go/tools/record"
"k8s.io/client-go/tools/reference"
"sigs.k8s.io/cli-utils/pkg/kstatus/polling"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/builder"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/controller"
"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
"sigs.k8s.io/controller-runtime/pkg/handler"
"sigs.k8s.io/controller-runtime/pkg/predicate"
"sigs.k8s.io/controller-runtime/pkg/source"
"sigs.k8s.io/kustomize/api/filesys"
kustomizev1 "github.com/fluxcd/kustomize-controller/api/v1beta1"
)
// +kubebuilder:rbac:groups=kustomize.toolkit.fluxcd.io,resources=kustomizations,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=kustomize.toolkit.fluxcd.io,resources=kustomizations/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=kustomize.toolkit.fluxcd.io,resources=kustomizations/finalizers,verbs=get;create;update;patch;delete
// +kubebuilder:rbac:groups=source.toolkit.fluxcd.io,resources=buckets;gitrepositories,verbs=get;list;watch
// +kubebuilder:rbac:groups=source.toolkit.fluxcd.io,resources=buckets/status;gitrepositories/status,verbs=get
// +kubebuilder:rbac:groups="",resources=secrets;serviceaccounts,verbs=get;list;watch
// +kubebuilder:rbac:groups="",resources=events,verbs=create;patch
// KustomizationReconciler reconciles a Kustomization object
type KustomizationReconciler struct {
client.Client
httpClient *retryablehttp.Client
requeueDependency time.Duration
Scheme *runtime.Scheme
EventRecorder kuberecorder.EventRecorder
ExternalEventRecorder *events.Recorder
MetricsRecorder *metrics.Recorder
StatusPoller *polling.StatusPoller
}
type KustomizationReconcilerOptions struct {
MaxConcurrentReconciles int
HTTPRetry int
DependencyRequeueInterval time.Duration
}
func (r *KustomizationReconciler) SetupWithManager(mgr ctrl.Manager, opts KustomizationReconcilerOptions) error {
// Index the Kustomizations by the GitRepository references they (may) point at.
if err := mgr.GetCache().IndexField(context.TODO(), &kustomizev1.Kustomization{}, kustomizev1.GitRepositoryIndexKey,
r.indexByGitRepository); err != nil {
return fmt.Errorf("failed setting index fields: %w", err)
}
// Index the Kustomizations by the Bucket references they (may) point at.
if err := mgr.GetCache().IndexField(context.TODO(), &kustomizev1.Kustomization{}, kustomizev1.BucketIndexKey,
r.indexByBucket); err != nil {
return fmt.Errorf("failed setting index fields: %w", err)
}
r.requeueDependency = opts.DependencyRequeueInterval
// Configure the retryable http client used for fetching artifacts.
// By default it retries 10 times within a 3.5 minutes window.
httpClient := retryablehttp.NewClient()
httpClient.RetryWaitMin = 5 * time.Second
httpClient.RetryWaitMax = 30 * time.Second
httpClient.RetryMax = opts.HTTPRetry
httpClient.Logger = nil
r.httpClient = httpClient
return ctrl.NewControllerManagedBy(mgr).
For(&kustomizev1.Kustomization{}, builder.WithPredicates(
predicate.Or(predicate.GenerationChangedPredicate{}, predicates.ReconcileRequestedPredicate{}),
)).
Watches(
&source.Kind{Type: &sourcev1.GitRepository{}},
handler.EnqueueRequestsFromMapFunc(r.requestsForGitRepositoryRevisionChange),
builder.WithPredicates(SourceRevisionChangePredicate{}),
).
Watches(
&source.Kind{Type: &sourcev1.Bucket{}},
handler.EnqueueRequestsFromMapFunc(r.requestsForBucketRevisionChange),
builder.WithPredicates(SourceRevisionChangePredicate{}),
).
WithOptions(controller.Options{MaxConcurrentReconciles: opts.MaxConcurrentReconciles}).
Complete(r)
}
func (r *KustomizationReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
log := logr.FromContext(ctx)
reconcileStart := time.Now()
var kustomization kustomizev1.Kustomization
if err := r.Get(ctx, req.NamespacedName, &kustomization); err != nil {
return ctrl.Result{}, client.IgnoreNotFound(err)
}
// Record suspended status metric
defer r.recordSuspension(ctx, kustomization)
// Add our finalizer if it does not exist
if !controllerutil.ContainsFinalizer(&kustomization, kustomizev1.KustomizationFinalizer) {
controllerutil.AddFinalizer(&kustomization, kustomizev1.KustomizationFinalizer)
if err := r.Update(ctx, &kustomization); err != nil {
log.Error(err, "unable to register finalizer")
return ctrl.Result{}, err
}
}
// Examine if the object is under deletion
if !kustomization.ObjectMeta.DeletionTimestamp.IsZero() {
return r.reconcileDelete(ctx, kustomization)
}
// Return early if the Kustomization is suspended.
if kustomization.Spec.Suspend {
log.Info("Reconciliation is suspended for this object")
return ctrl.Result{}, nil
}
// resolve source reference
source, err := r.getSource(ctx, kustomization)
if err != nil {
if apierrors.IsNotFound(err) {
msg := fmt.Sprintf("Source '%s' not found", kustomization.Spec.SourceRef.String())
kustomization = kustomizev1.KustomizationNotReady(kustomization, "", kustomizev1.ArtifactFailedReason, msg)
if err := r.patchStatus(ctx, req, kustomization.Status); err != nil {
log.Error(err, "unable to update status for source not found")
return ctrl.Result{Requeue: true}, err
}
r.recordReadiness(ctx, kustomization)
log.Info(msg)
// do not requeue immediately, when the source is created the watcher should trigger a reconciliation
return ctrl.Result{RequeueAfter: kustomization.GetRetryInterval()}, nil
} else {
// retry on transient errors
return ctrl.Result{Requeue: true}, err
}
}
if source.GetArtifact() == nil {
msg := "Source is not ready, artifact not found"
kustomization = kustomizev1.KustomizationNotReady(kustomization, "", kustomizev1.ArtifactFailedReason, msg)
if err := r.patchStatus(ctx, req, kustomization.Status); err != nil {
log.Error(err, "unable to update status for artifact not found")
return ctrl.Result{Requeue: true}, err
}
r.recordReadiness(ctx, kustomization)
log.Info(msg)
// do not requeue immediately, when the artifact is created the watcher should trigger a reconciliation
return ctrl.Result{RequeueAfter: kustomization.GetRetryInterval()}, nil
}
// check dependencies
if len(kustomization.Spec.DependsOn) > 0 {
if err := r.checkDependencies(kustomization); err != nil {
kustomization = kustomizev1.KustomizationNotReady(
kustomization, source.GetArtifact().Revision, meta.DependencyNotReadyReason, err.Error())
if err := r.patchStatus(ctx, req, kustomization.Status); err != nil {
log.Error(err, "unable to update status for dependency not ready")
return ctrl.Result{Requeue: true}, err
}
// we can't rely on exponential backoff because it will prolong the execution too much,
// instead we requeue on a fix interval.
msg := fmt.Sprintf("Dependencies do not meet ready condition, retrying in %s", r.requeueDependency.String())
log.Info(msg)
r.event(ctx, kustomization, source.GetArtifact().Revision, events.EventSeverityInfo, msg, nil)
r.recordReadiness(ctx, kustomization)
return ctrl.Result{RequeueAfter: r.requeueDependency}, nil
}
log.Info("All dependencies area ready, proceeding with reconciliation")
}
// record reconciliation duration
if r.MetricsRecorder != nil {
objRef, err := reference.GetReference(r.Scheme, &kustomization)
if err != nil {
return ctrl.Result{}, err
}
defer r.MetricsRecorder.RecordDuration(*objRef, reconcileStart)
}
// set the reconciliation status to progressing
kustomization = kustomizev1.KustomizationProgressing(kustomization)
if err := r.patchStatus(ctx, req, kustomization.Status); err != nil {
log.Error(err, "unable to update status to progressing")
return ctrl.Result{Requeue: true}, err
}
r.recordReadiness(ctx, kustomization)
// reconcile kustomization by applying the latest revision
reconciledKustomization, reconcileErr := r.reconcile(ctx, *kustomization.DeepCopy(), source)
if err := r.patchStatus(ctx, req, reconciledKustomization.Status); err != nil {
log.Error(err, "unable to update status after reconciliation")
return ctrl.Result{Requeue: true}, err
}
r.recordReadiness(ctx, reconciledKustomization)
// broadcast the reconciliation failure and requeue at the specified retry interval
if reconcileErr != nil {
log.Error(reconcileErr, fmt.Sprintf("Reconciliation failed after %s, next try in %s",
time.Now().Sub(reconcileStart).String(),
kustomization.GetRetryInterval().String()),
"revision",
source.GetArtifact().Revision)
r.event(ctx, reconciledKustomization, source.GetArtifact().Revision, events.EventSeverityError,
reconcileErr.Error(), nil)
return ctrl.Result{RequeueAfter: kustomization.GetRetryInterval()}, nil
}
// broadcast the reconciliation result and requeue at the specified interval
log.Info(fmt.Sprintf("Reconciliation finished in %s, next run in %s",
time.Now().Sub(reconcileStart).String(),
kustomization.Spec.Interval.Duration.String()),
"revision",
source.GetArtifact().Revision,
)
r.event(ctx, reconciledKustomization, source.GetArtifact().Revision, events.EventSeverityInfo,
"Update completed", map[string]string{"commit_status": "update"})
return ctrl.Result{RequeueAfter: kustomization.Spec.Interval.Duration}, nil
}
func (r *KustomizationReconciler) reconcile(
ctx context.Context,
kustomization kustomizev1.Kustomization,
source sourcev1.Source) (kustomizev1.Kustomization, error) {
// record the value of the reconciliation request, if any
if v, ok := meta.ReconcileAnnotationValue(kustomization.GetAnnotations()); ok {
kustomization.Status.SetLastHandledReconcileRequest(v)
}
// create tmp dir
tmpDir, err := ioutil.TempDir("", kustomization.Name)
if err != nil {
err = fmt.Errorf("tmp dir error: %w", err)
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
sourcev1.StorageOperationFailedReason,
err.Error(),
), err
}
defer os.RemoveAll(tmpDir)
// download artifact and extract files
err = r.download(source.GetArtifact().URL, tmpDir)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
kustomizev1.ArtifactFailedReason,
err.Error(),
), err
}
// check build path exists
dirPath, err := securejoin.SecureJoin(tmpDir, kustomization.Spec.Path)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
kustomizev1.ArtifactFailedReason,
err.Error(),
), err
}
if _, err := os.Stat(dirPath); err != nil {
err = fmt.Errorf("kustomization path not found: %w", err)
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
kustomizev1.ArtifactFailedReason,
err.Error(),
), err
}
// create any necessary kube-clients for impersonation
impersonation := NewKustomizeImpersonation(kustomization, r.Client, r.StatusPoller, dirPath)
kubeClient, statusPoller, err := impersonation.GetClient(ctx)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
meta.ReconciliationFailedReason,
err.Error(),
), fmt.Errorf("failed to build kube client: %w", err)
}
// generate kustomization.yaml and calculate the manifests checksum
checksum, err := r.generate(ctx, kubeClient, kustomization, dirPath)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
kustomizev1.BuildFailedReason,
err.Error(),
), err
}
// build the kustomization and generate the GC snapshot
snapshot, err := r.build(ctx, kustomization, checksum, dirPath)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
kustomizev1.BuildFailedReason,
err.Error(),
), err
}
// dry-run apply
err = r.validate(ctx, kustomization, impersonation, dirPath)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
kustomizev1.ValidationFailedReason,
err.Error(),
), err
}
// apply
changeSet, err := r.applyWithRetry(ctx, kustomization, impersonation, source.GetArtifact().Revision, dirPath, 5*time.Second)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
meta.ReconciliationFailedReason,
err.Error(),
), err
}
// prune
err = r.prune(ctx, kubeClient, kustomization, checksum)
if err != nil {
return kustomizev1.KustomizationNotReady(
kustomization,
source.GetArtifact().Revision,
kustomizev1.PruneFailedReason,
err.Error(),
), err
}
// health assessment
err = r.checkHealth(ctx, statusPoller, kustomization, source.GetArtifact().Revision, changeSet != "")
if err != nil {
return kustomizev1.KustomizationNotReadySnapshot(
kustomization,
snapshot,
source.GetArtifact().Revision,
kustomizev1.HealthCheckFailedReason,
err.Error(),
), err
}
return kustomizev1.KustomizationReady(
kustomization,
snapshot,
source.GetArtifact().Revision,
meta.ReconciliationSucceededReason,
"Applied revision: "+source.GetArtifact().Revision,
), nil
}
func (r *KustomizationReconciler) checkDependencies(kustomization kustomizev1.Kustomization) error {
for _, d := range kustomization.Spec.DependsOn {
if d.Namespace == "" {
d.Namespace = kustomization.GetNamespace()
}
dName := types.NamespacedName(d)
var k kustomizev1.Kustomization
err := r.Get(context.Background(), dName, &k)
if err != nil {
return fmt.Errorf("unable to get '%s' dependency: %w", dName, err)
}
if len(k.Status.Conditions) == 0 || k.Generation != k.Status.ObservedGeneration {
return fmt.Errorf("dependency '%s' is not ready", dName)
}
if !apimeta.IsStatusConditionTrue(k.Status.Conditions, meta.ReadyCondition) {
return fmt.Errorf("dependency '%s' is not ready", dName)
}
}
return nil
}
func (r *KustomizationReconciler) download(artifactURL string, tmpDir string) error {
if hostname := os.Getenv("SOURCE_CONTROLLER_LOCALHOST"); hostname != "" {
u, err := url.Parse(artifactURL)
if err != nil {
return err
}
u.Host = hostname
artifactURL = u.String()
}
req, err := retryablehttp.NewRequest(http.MethodGet, artifactURL, nil)
if err != nil {
return fmt.Errorf("failed to create a new request: %w", err)
}
resp, err := r.httpClient.Do(req)
if err != nil {
return fmt.Errorf("failed to download artifact, error: %w", err)
}
defer resp.Body.Close()
// check response
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("failed to download artifact from %s, status: %s", artifactURL, resp.Status)
}
// extract
if _, err = untar.Untar(resp.Body, tmpDir); err != nil {
return fmt.Errorf("failed to untar artifact, error: %w", err)
}
return nil
}
func (r *KustomizationReconciler) getSource(ctx context.Context, kustomization kustomizev1.Kustomization) (sourcev1.Source, error) {
var source sourcev1.Source
sourceNamespace := kustomization.GetNamespace()
if kustomization.Spec.SourceRef.Namespace != "" {
sourceNamespace = kustomization.Spec.SourceRef.Namespace
}
namespacedName := types.NamespacedName{
Namespace: sourceNamespace,
Name: kustomization.Spec.SourceRef.Name,
}
switch kustomization.Spec.SourceRef.Kind {
case sourcev1.GitRepositoryKind:
var repository sourcev1.GitRepository
err := r.Client.Get(ctx, namespacedName, &repository)
if err != nil {
if apierrors.IsNotFound(err) {
return source, err
}
return source, fmt.Errorf("unable to get source '%s': %w", namespacedName, err)
}
source = &repository
case sourcev1.BucketKind:
var bucket sourcev1.Bucket
err := r.Client.Get(ctx, namespacedName, &bucket)
if err != nil {
if apierrors.IsNotFound(err) {
return source, err
}
return source, fmt.Errorf("unable to get source '%s': %w", namespacedName, err)
}
source = &bucket
default:
return source, fmt.Errorf("source `%s` kind '%s' not supported",
kustomization.Spec.SourceRef.Name, kustomization.Spec.SourceRef.Kind)
}
return source, nil
}
func (r *KustomizationReconciler) generate(ctx context.Context, kubeClient client.Client, kustomization kustomizev1.Kustomization, dirPath string) (string, error) {
gen := NewGenerator(kustomization, kubeClient)
return gen.WriteFile(ctx, dirPath)
}
func (r *KustomizationReconciler) build(ctx context.Context, kustomization kustomizev1.Kustomization, checksum, dirPath string) (*kustomizev1.Snapshot, error) {
timeout := kustomization.GetTimeout()
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
dec, cleanup, err := NewTempDecryptor(r.Client, kustomization)
if err != nil {
return nil, err
}
defer cleanup()
// import OpenPGP keys if any
if err := dec.ImportKeys(ctx); err != nil {
return nil, err
}
fs := filesys.MakeFsOnDisk()
m, err := buildKustomization(fs, dirPath)
if err != nil {
return nil, fmt.Errorf("kustomize build failed: %w", err)
}
for _, res := range m.Resources() {
// check if resources are encrypted and decrypt them before generating the final YAML
if kustomization.Spec.Decryption != nil {
outRes, err := dec.Decrypt(res)
if err != nil {
return nil, fmt.Errorf("decryption failed for '%s': %w", res.GetName(), err)
}
if outRes != nil {
_, err = m.Replace(res)
if err != nil {
return nil, err
}
}
}
// run variable substitutions
if kustomization.Spec.PostBuild != nil {
outRes, err := substituteVariables(ctx, r.Client, kustomization, res)
if err != nil {
return nil, fmt.Errorf("var substitution failed for '%s': %w", res.GetName(), err)
}
if outRes != nil {
_, err = m.Replace(res)
if err != nil {
return nil, err
}
}
}
}
resources, err := m.AsYaml()
if err != nil {
return nil, fmt.Errorf("kustomize build failed: %w", err)
}
manifestsFile := filepath.Join(dirPath, fmt.Sprintf("%s.yaml", kustomization.GetUID()))
if err := fs.WriteFile(manifestsFile, resources); err != nil {
return nil, err
}
return kustomizev1.NewSnapshot(resources, checksum)
}
func (r *KustomizationReconciler) validate(ctx context.Context, kustomization kustomizev1.Kustomization, imp *KustomizeImpersonation, dirPath string) error {
if kustomization.Spec.Validation == "" || kustomization.Spec.Validation == "none" {
return nil
}
log := logr.FromContext(ctx)
timeout := kustomization.GetTimeout() + (time.Second * 1)
applyCtx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
validation := kustomization.Spec.Validation
if validation == "server" && kustomization.Spec.Force {
// Use client-side validation with force
validation = "client"
log.Info(fmt.Sprintf("Server-side validation is configured, falling-back to client-side validation since 'force' is enabled"))
}
cmd := fmt.Sprintf("cd %s && kubectl apply -f %s.yaml --timeout=%s --dry-run=%s --cache-dir=/tmp --force=%t",
dirPath, kustomization.GetUID(), kustomization.GetTimeout().String(), validation, kustomization.Spec.Force)
if kustomization.Spec.KubeConfig != nil {
kubeConfig, err := imp.WriteKubeConfig(ctx)
if err != nil {
return err
}
cmd = fmt.Sprintf("%s --kubeconfig=%s", cmd, kubeConfig)
} else {
// impersonate SA
if kustomization.Spec.ServiceAccountName != "" {
saToken, err := imp.GetServiceAccountToken(ctx)
if err != nil {
return fmt.Errorf("service account impersonation failed: %w", err)
}
cmd = fmt.Sprintf("%s --token %s", cmd, saToken)
}
}
command := exec.CommandContext(applyCtx, "/bin/sh", "-c", cmd)
output, err := command.CombinedOutput()
if err != nil {
if errors.Is(err, context.DeadlineExceeded) {
return fmt.Errorf("validation timeout: %w", err)
}
return fmt.Errorf("validation failed: %s", parseApplyError(output))
}
return nil
}
func (r *KustomizationReconciler) apply(ctx context.Context, kustomization kustomizev1.Kustomization, imp *KustomizeImpersonation, dirPath string) (string, error) {
log := logr.FromContext(ctx)
start := time.Now()
timeout := kustomization.GetTimeout() + (time.Second * 1)
applyCtx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
fieldManager := "kustomize-controller"
cmd := fmt.Sprintf("cd %s && kubectl apply --field-manager=%s -f %s.yaml --timeout=%s --cache-dir=/tmp --force=%t",
dirPath, fieldManager, kustomization.GetUID(), kustomization.Spec.Interval.Duration.String(), kustomization.Spec.Force)
if kustomization.Spec.KubeConfig != nil {
kubeConfig, err := imp.WriteKubeConfig(ctx)
if err != nil {
return "", err
}
cmd = fmt.Sprintf("%s --kubeconfig=%s", cmd, kubeConfig)
} else {
// impersonate SA
if kustomization.Spec.ServiceAccountName != "" {
saToken, err := imp.GetServiceAccountToken(ctx)
if err != nil {
return "", fmt.Errorf("service account impersonation failed: %w", err)
}
cmd = fmt.Sprintf("%s --token %s", cmd, saToken)
}
}
command := exec.CommandContext(applyCtx, "/bin/sh", "-c", cmd)
output, err := command.CombinedOutput()
if err != nil {
if errors.Is(err, context.DeadlineExceeded) {
return "", fmt.Errorf("apply timeout: %w", err)
}
if string(output) == "" {
return "", fmt.Errorf("apply failed: %w, kubectl process was killed, probably due to OOM", err)
}
applyErr := parseApplyError(output)
if applyErr == "" {
applyErr = "no error output found, this may happen because of a timeout"
}
return "", fmt.Errorf("apply failed: %s", applyErr)
}
resources := parseApplyOutput(output)
log.Info(
fmt.Sprintf("Kustomization applied in %s",
time.Now().Sub(start).String()),
"output", resources,
)
changeSet := ""
for obj, action := range resources {
if action != "" && action != "unchanged" {
changeSet += obj + " " + action + "\n"
}
}
return changeSet, nil
}
func (r *KustomizationReconciler) applyWithRetry(ctx context.Context, kustomization kustomizev1.Kustomization, imp *KustomizeImpersonation, revision, dirPath string, delay time.Duration) (string, error) {
log := logr.FromContext(ctx)
changeSet, err := r.apply(ctx, kustomization, imp, dirPath)
if err != nil {
// retry apply due to CRD/CR race
if strings.Contains(err.Error(), "could not find the requested resource") ||
strings.Contains(err.Error(), "no matches for kind") {
log.Info("retrying apply", "error", err.Error())
time.Sleep(delay)
if changeSet, err := r.apply(ctx, kustomization, imp, dirPath); err != nil {
return "", err
} else {
if changeSet != "" {
r.event(ctx, kustomization, revision, events.EventSeverityInfo, changeSet, nil)
}
}
} else {
return "", err
}
} else {
if changeSet != "" && kustomization.Status.LastAppliedRevision != revision {
r.event(ctx, kustomization, revision, events.EventSeverityInfo, changeSet, nil)
}
}
return changeSet, nil
}
func (r *KustomizationReconciler) prune(ctx context.Context, kubeClient client.Client, kustomization kustomizev1.Kustomization, newChecksum string) error {
if !kustomization.Spec.Prune || kustomization.Status.Snapshot == nil {
return nil
}
if kustomization.DeletionTimestamp.IsZero() && kustomization.Status.Snapshot.Checksum == newChecksum {
return nil
}
log := logr.FromContext(ctx)
gc := NewGarbageCollector(kubeClient, *kustomization.Status.Snapshot, newChecksum, logr.FromContext(ctx))
if output, ok := gc.Prune(kustomization.GetTimeout(),
kustomization.GetName(),
kustomization.GetNamespace(),
); !ok {
return fmt.Errorf("garbage collection failed: %s", output)
} else {
if output != "" {
log.Info(fmt.Sprintf("garbage collection completed: %s", output))
r.event(ctx, kustomization, newChecksum, events.EventSeverityInfo, output, nil)
}
}
return nil
}
func (r *KustomizationReconciler) checkHealth(ctx context.Context, statusPoller *polling.StatusPoller, kustomization kustomizev1.Kustomization, revision string, changed bool) error {
if len(kustomization.Spec.HealthChecks) == 0 {
return nil
}
hc := NewHealthCheck(kustomization, statusPoller)
if err := hc.Assess(1 * time.Second); err != nil {
return err
}
healthiness := apimeta.FindStatusCondition(kustomization.Status.Conditions, kustomizev1.HealthyCondition)
healthy := healthiness != nil && healthiness.Status == metav1.ConditionTrue
if !healthy || (kustomization.Status.LastAppliedRevision != revision && changed) {
r.event(ctx, kustomization, revision, events.EventSeverityInfo, "Health check passed", nil)
}
return nil
}
func (r *KustomizationReconciler) reconcileDelete(ctx context.Context, kustomization kustomizev1.Kustomization) (ctrl.Result, error) {
log := logr.FromContext(ctx)
if kustomization.Spec.Prune && !kustomization.Spec.Suspend {
// create any necessary kube-clients
imp := NewKustomizeImpersonation(kustomization, r.Client, r.StatusPoller, "")
client, _, err := imp.GetClient(ctx)
if err != nil {
err = fmt.Errorf("failed to build kube client for Kustomization: %w", err)
log.Error(err, "Unable to prune for finalizer")
return ctrl.Result{}, err
}
if err := r.prune(ctx, client, kustomization, ""); err != nil {
r.event(ctx, kustomization, kustomization.Status.LastAppliedRevision, events.EventSeverityError, "pruning for deleted resource failed", nil)
// Return the error so we retry the failed garbage collection
return ctrl.Result{}, err
}
}
// Record deleted status
r.recordReadiness(ctx, kustomization)
// Remove our finalizer from the list and update it
controllerutil.RemoveFinalizer(&kustomization, kustomizev1.KustomizationFinalizer)
if err := r.Update(ctx, &kustomization); err != nil {
return ctrl.Result{}, err
}
// Stop reconciliation as the object is being deleted
return ctrl.Result{}, nil
}
func (r *KustomizationReconciler) event(ctx context.Context, kustomization kustomizev1.Kustomization, revision, severity, msg string, metadata map[string]string) {
log := logr.FromContext(ctx)
r.EventRecorder.Event(&kustomization, "Normal", severity, msg)
objRef, err := reference.GetReference(r.Scheme, &kustomization)
if err != nil {
log.Error(err, "unable to send event")
return
}
if r.ExternalEventRecorder != nil {
if metadata == nil {
metadata = map[string]string{}
}
if revision != "" {
metadata["revision"] = revision
}
reason := severity
if c := apimeta.FindStatusCondition(kustomization.Status.Conditions, meta.ReadyCondition); c != nil {
reason = c.Reason
}
if err := r.ExternalEventRecorder.Eventf(*objRef, metadata, severity, reason, msg); err != nil {
log.Error(err, "unable to send event")
return
}
}
}
func (r *KustomizationReconciler) recordReadiness(ctx context.Context, kustomization kustomizev1.Kustomization) {
if r.MetricsRecorder == nil {
return
}
log := logr.FromContext(ctx)
objRef, err := reference.GetReference(r.Scheme, &kustomization)
if err != nil {
log.Error(err, "unable to record readiness metric")
return
}
if rc := apimeta.FindStatusCondition(kustomization.Status.Conditions, meta.ReadyCondition); rc != nil {
r.MetricsRecorder.RecordCondition(*objRef, *rc, !kustomization.DeletionTimestamp.IsZero())
} else {
r.MetricsRecorder.RecordCondition(*objRef, metav1.Condition{
Type: meta.ReadyCondition,
Status: metav1.ConditionUnknown,
}, !kustomization.DeletionTimestamp.IsZero())
}
}
func (r *KustomizationReconciler) recordSuspension(ctx context.Context, kustomization kustomizev1.Kustomization) {
if r.MetricsRecorder == nil {
return
}
log := logr.FromContext(ctx)
objRef, err := reference.GetReference(r.Scheme, &kustomization)
if err != nil {
log.Error(err, "unable to record suspended metric")
return
}
if !kustomization.DeletionTimestamp.IsZero() {
r.MetricsRecorder.RecordSuspend(*objRef, false)
} else {
r.MetricsRecorder.RecordSuspend(*objRef, kustomization.Spec.Suspend)
}
}
func (r *KustomizationReconciler) patchStatus(ctx context.Context, req ctrl.Request, newStatus kustomizev1.KustomizationStatus) error {
var kustomization kustomizev1.Kustomization
if err := r.Get(ctx, req.NamespacedName, &kustomization); err != nil {
return err
}
patch := client.MergeFrom(kustomization.DeepCopy())
kustomization.Status = newStatus
return r.Status().Patch(ctx, &kustomization, patch)
}
|
[
"\"SOURCE_CONTROLLER_LOCALHOST\""
] |
[] |
[
"SOURCE_CONTROLLER_LOCALHOST"
] |
[]
|
["SOURCE_CONTROLLER_LOCALHOST"]
|
go
| 1 | 0 | |
backend/src/main/java/br/com/estacionamento/main/ApplicationConfiguration.java
|
package br.com.estacionamento.main;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "br.com.estacionamento.model", entityManagerFactoryRef = "factoryBean")
@ComponentScan(basePackages = "br.com.estacionamento.controller")
public class ApplicationConfiguration {
public static String getDatabaseUrl() {
String url = System.getenv("DATABASE_URL");
if (url == null) {
url = "jdbc:mysql://localhost:3306/estacionamento?user=root&password=123456";
}
return url;
}
@Bean
public LocalContainerEntityManagerFactoryBean factoryBean() {
LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
factoryBean.setDataSource(dataSource());
factoryBean.setPackagesToScan("br.com.estacionamento.model");
return factoryBean;
}
@Bean
public DataSource dataSource() {
DriverManagerDataSource driver = new DriverManagerDataSource();
driver.setDriverClassName("com.mysql.jdbc.Driver");
driver.setUrl(getDatabaseUrl());
return driver;
}
}
|
[
"\"DATABASE_URL\""
] |
[] |
[
"DATABASE_URL"
] |
[]
|
["DATABASE_URL"]
|
java
| 1 | 0 | |
enterprise/internal/insights/insights.go
|
package insights
import (
"context"
"database/sql"
"log"
"os"
"strconv"
"time"
"github.com/cockroachdb/errors"
"github.com/sourcegraph/sourcegraph/cmd/frontend/enterprise"
"github.com/sourcegraph/sourcegraph/enterprise/internal/insights/migration"
"github.com/sourcegraph/sourcegraph/enterprise/internal/insights/resolvers"
"github.com/sourcegraph/sourcegraph/internal/conf"
"github.com/sourcegraph/sourcegraph/internal/conf/conftypes"
"github.com/sourcegraph/sourcegraph/internal/conf/deploy"
"github.com/sourcegraph/sourcegraph/internal/database"
connections "github.com/sourcegraph/sourcegraph/internal/database/connections/live"
"github.com/sourcegraph/sourcegraph/internal/observation"
"github.com/sourcegraph/sourcegraph/internal/oobmigration"
)
// IsEnabled tells if code insights are enabled or not.
func IsEnabled() bool {
if v, _ := strconv.ParseBool(os.Getenv("DISABLE_CODE_INSIGHTS")); v {
// Code insights can always be disabled. This can be a helpful escape hatch if e.g. there
// are issues with (or connecting to) the codeinsights-db deployment and it is preventing
// the Sourcegraph frontend or repo-updater from starting.
//
// It is also useful in dev environments if you do not wish to spend resources running Code
// Insights.
return false
}
if deploy.IsDeployTypeSingleDockerContainer(deploy.Type()) {
// Code insights is not supported in single-container Docker demo deployments.
return false
}
return true
}
// Init initializes the given enterpriseServices to include the required resolvers for insights.
func Init(ctx context.Context, postgres database.DB, _ conftypes.UnifiedWatchable, outOfBandMigrationRunner *oobmigration.Runner, enterpriseServices *enterprise.Services, observationContext *observation.Context) error {
if !IsEnabled() {
if deploy.IsDeployTypeSingleDockerContainer(deploy.Type()) {
enterpriseServices.InsightsResolver = resolvers.NewDisabledResolver("backend-run code insights are not available on single-container deployments")
} else {
enterpriseServices.InsightsResolver = resolvers.NewDisabledResolver("code insights has been disabled")
}
return nil
}
timescale, err := InitializeCodeInsightsDB("frontend")
if err != nil {
return err
}
enterpriseServices.InsightsResolver = resolvers.New(timescale, postgres)
insightsMigrator := migration.NewMigrator(timescale, postgres)
// This id (14) was defined arbitrarily in this migration file: 1528395945_settings_migration_out_of_band.up.sql.
if err := outOfBandMigrationRunner.Register(14, insightsMigrator, oobmigration.MigratorOptions{Interval: 10 * time.Second}); err != nil {
log.Fatalf("failed to register settings migration job: %v", err)
}
return nil
}
// InitializeCodeInsightsDB connects to and initializes the Code Insights Timescale DB, running
// database migrations before returning. It is safe to call from multiple services/containers (in
// which case, one's migration will win and the other caller will receive an error and should exit
// and restart until the other finishes.)
func InitializeCodeInsightsDB(app string) (*sql.DB, error) {
dsn := conf.GetServiceConnectionValueAndRestartOnChange(func(serviceConnections conftypes.ServiceConnections) string {
return serviceConnections.CodeInsightsTimescaleDSN
})
db, err := connections.NewCodeInsightsDB(dsn, app, true, &observation.TestContext)
if err != nil {
return nil, errors.Errorf("Failed to connect to codeinsights database: %s", err)
}
return db, nil
}
|
[
"\"DISABLE_CODE_INSIGHTS\""
] |
[] |
[
"DISABLE_CODE_INSIGHTS"
] |
[]
|
["DISABLE_CODE_INSIGHTS"]
|
go
| 1 | 0 | |
news2rss.py
|
#!/usr/bin/env python3
#
# news2rss.py by lenormf
# A lightweight HTTP server that turns NewsAPI data into RSS feeds
#
import os
import sys
import logging
import inspect
import argparse
from enum import Enum, auto
import bottle
from bottle import get, abort
from newsapi import NewsApiClient
from newsapi.newsapi_exception import NewsAPIException
from feedgen.feed import FeedGenerator
class NewsAPIPlugin(object):
name = "news_api"
api = 2
def __init__(self, keyword="newsapi", api_key=None):
self.keyword = keyword
self.newsapi = NewsApiClient(api_key=api_key)
try:
self.newsapi._sources_cache = self.newsapi.get_sources()["sources"]
logging.debug("sources cache: %r", self.newsapi._sources_cache)
except NewsAPIException as e:
logging.error("unable to fetch list of sources: %s", e)
raise bottle.PluginError("unable to initialise NewsAPIPlugin")
def setup(self, app):
for other in app.plugins:
if not isinstance(other, NewsAPIPlugin):
continue
if other.keyword == self.keyword:
raise bottle.PluginError("Found another '%s' plugin with conflicting settings (non-unique keyword)." % self.name)
def apply(self, callback, context):
conf = context.config.get(NewsAPIPlugin.name) or {}
keyword = conf.get("keyword", self.keyword)
newsapi = conf.get("newsapi", self.newsapi)
if self.keyword not in inspect.signature(callback).parameters:
return callback
def wrapper(*args, **kwargs):
kwargs[keyword] = newsapi
return callback(*args, **kwargs)
return wrapper
def _feed_rss(source_meta, articles):
feed = FeedGenerator()
if "name" not in source_meta:
logging.error("no 'name' entry in the source meta")
abort(401, "an error occurred while generating the feed")
feed.title(source_meta["name"])
if "url" not in source_meta:
logging.error("no 'url' entry in the source meta")
abort(401, "an error occurred while generating the feed")
feed.link(href=source_meta["url"], rel="self")
if "description" not in source_meta:
logging.error("no 'description' entry in the source meta")
abort(401, "an error occurred while generating the feed")
feed.description(source_meta["description"])
if "id" in source_meta:
feed.id(source_meta["id"])
if "category" in source_meta:
feed.category(term=source_meta["category"])
if "language" in source_meta:
feed.language(source_meta["language"])
for article in articles:
entry = feed.add_entry(order="append")
logging.debug("article: %r", article)
if "title" not in article:
logging.error("no 'title' entry in the article")
abort(401, "an error occurred while adding an entry")
entry.title(article["title"])
if "content" not in article:
logging.error("no 'content' entry in the article")
abort(401, "an error occurred while adding an entry")
entry.content(article["content"])
if "description" not in article:
logging.error("no 'description' entry in the article")
abort(401, "an error occurred while adding an entry")
entry.description(article["description"])
if "author" in article:
entry.author(name=article["author"], email="[email protected]")
if "url" in article:
entry.link(href=article["url"], rel="alternate")
if "publishedAt" in article:
entry.pubDate(article["publishedAt"])
try:
return feed.rss_str()
except ValueError as e:
logging.error("invalid data: %s", e)
abort(401, "an error occurred while generating the feed")
@get("/<feed_type>/<source_id>")
def get_feed_sources(feed_type, source_id, newsapi):
source_meta = next((source for source in newsapi._sources_cache if source["id"] == source_id),
None)
if not source_meta:
abort(401, "invalid source identifier")
try:
# Maximum amount of articles returned in a single page: 100
articles = newsapi.get_everything(sources=source_id, page_size=100)
logging.debug("total amount of articles: %d", articles["totalResults"])
except (ValueError, TypeError) as e:
logging.error("invalid request: %s", e)
abort(401, "an error occurred while fetching the articles")
except NewsAPIException as e:
logging.error("couldn't query the API: %s", e)
abort(401, "an error occurred while fetching the articles")
logging.debug("requested feed type: %s", feed_type)
if feed_type == "rss":
return _feed_rss(source_meta, articles["articles"])
else:
abort(401, "invalid feed type")
class CliOptions(argparse.Namespace):
def __init__(self, args):
parser = argparse.ArgumentParser(description="News2RSS - An HTTP server that returns feeds of news articles")
parser.add_argument("-d", "--debug", default=False, action="store_true", help="Display debug messages")
parser.add_argument("-v", "--verbose", default=False, action="store_true", help="Display more messages")
parser.add_argument("-H", "--host", default="localhost", help="Hostname to bind to")
parser.add_argument("-P", "--port", type=int, default=8080, help="Port to listen on")
parser.add_argument("-X", "--api-key", help="News API authentication key")
parser.parse_args(args, self)
def main(av):
cli_options = CliOptions(av[1:])
logging_level = logging.WARN
if cli_options.debug:
logging_level = logging.DEBUG
elif cli_options.verbose:
logging_level = logging.INFO
logging.basicConfig(level=logging_level,
format="[%(asctime)s][%(levelname)s]: %(message)s")
api_key = cli_options.api_key or os.getenv("NEWS2RSS_API_KEY")
if not api_key:
logging.critical("No API key set")
return 1
bottle.install(NewsAPIPlugin(api_key=api_key))
bottle.run(host=cli_options.host, port=cli_options.port,
debug=cli_options.debug, reloader=cli_options.debug)
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv))
|
[] |
[] |
[
"NEWS2RSS_API_KEY"
] |
[]
|
["NEWS2RSS_API_KEY"]
|
python
| 1 | 0 | |
vendor/github.com/containers/buildah/util/util.go
|
package util
import (
"fmt"
"io"
"net/url"
"os"
"path"
"strings"
"syscall"
"github.com/containers/buildah/pkg/cgroups"
"github.com/containers/image/v5/docker/reference"
"github.com/containers/image/v5/pkg/sysregistriesv2"
"github.com/containers/image/v5/signature"
is "github.com/containers/image/v5/storage"
"github.com/containers/image/v5/transports"
"github.com/containers/image/v5/types"
"github.com/containers/storage"
"github.com/docker/distribution/registry/api/errcode"
specs "github.com/opencontainers/runtime-spec/specs-go"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
)
const (
minimumTruncatedIDLength = 3
// DefaultTransport is a prefix that we apply to an image name if we
// can't find one in the local Store, in order to generate a source
// reference for the image that we can then copy to the local Store.
DefaultTransport = "docker://"
)
var (
// RegistryDefaultPathPrefix contains a per-registry listing of default prefixes
// to prepend to image names that only contain a single path component.
RegistryDefaultPathPrefix = map[string]string{
"index.docker.io": "library",
"docker.io": "library",
}
)
// ResolveName checks if name is a valid image name, and if that name doesn't
// include a domain portion, returns a list of the names which it might
// correspond to in the set of configured registries, the transport used to
// pull the image, and a boolean which is true iff
// 1) the list of search registries was used, and 2) it was empty.
//
// The returned image names never include a transport: prefix, and if transport != "",
// (transport, image) should be a valid input to alltransports.ParseImageName.
// transport == "" indicates that image that already exists in a local storage,
// and the name is valid for store.Image() / storage.Transport.ParseStoreReference().
//
// NOTE: The "list of search registries is empty" check does not count blocked registries,
// and neither the implied "localhost" nor a possible firstRegistry are counted
func ResolveName(name string, firstRegistry string, sc *types.SystemContext, store storage.Store) ([]string, string, bool, error) {
if name == "" {
return nil, "", false, nil
}
// Maybe it's a truncated image ID. Don't prepend a registry name, then.
if len(name) >= minimumTruncatedIDLength {
if img, err := store.Image(name); err == nil && img != nil && strings.HasPrefix(img.ID, name) {
// It's a truncated version of the ID of an image that's present in local storage;
// we need only expand the ID.
return []string{img.ID}, "", false, nil
}
}
// If the image includes a transport's name as a prefix, use it as-is.
if strings.HasPrefix(name, DefaultTransport) {
return []string{strings.TrimPrefix(name, DefaultTransport)}, DefaultTransport, false, nil
}
split := strings.SplitN(name, ":", 2)
if len(split) == 2 {
if trans := transports.Get(split[0]); trans != nil {
return []string{split[1]}, trans.Name(), false, nil
}
}
// If the image name already included a domain component, we're done.
named, err := reference.ParseNormalizedNamed(name)
if err != nil {
return nil, "", false, errors.Wrapf(err, "error parsing image name %q", name)
}
if named.String() == name {
// Parsing produced the same result, so there was a domain name in there to begin with.
return []string{name}, DefaultTransport, false, nil
}
if reference.Domain(named) != "" && RegistryDefaultPathPrefix[reference.Domain(named)] != "" {
// If this domain can cause us to insert something in the middle, check if that happened.
repoPath := reference.Path(named)
domain := reference.Domain(named)
tag := ""
if tagged, ok := named.(reference.Tagged); ok {
tag = ":" + tagged.Tag()
}
digest := ""
if digested, ok := named.(reference.Digested); ok {
digest = "@" + digested.Digest().String()
}
defaultPrefix := RegistryDefaultPathPrefix[reference.Domain(named)] + "/"
if strings.HasPrefix(repoPath, defaultPrefix) && path.Join(domain, repoPath[len(defaultPrefix):])+tag+digest == name {
// Yup, parsing just inserted a bit in the middle, so there was a domain name there to begin with.
return []string{name}, DefaultTransport, false, nil
}
}
// Figure out the list of registries.
var registries []string
searchRegistries, err := sysregistriesv2.UnqualifiedSearchRegistries(sc)
if err != nil {
logrus.Debugf("unable to read configured registries to complete %q: %v", name, err)
searchRegistries = nil
}
for _, registry := range searchRegistries {
reg, err := sysregistriesv2.FindRegistry(sc, registry)
if err != nil {
logrus.Debugf("unable to read registry configuration for %#v: %v", registry, err)
continue
}
if reg == nil || !reg.Blocked {
registries = append(registries, registry)
}
}
searchRegistriesAreEmpty := len(registries) == 0
// Create all of the combinations. Some registries need an additional component added, so
// use our lookaside map to keep track of them. If there are no configured registries, we'll
// return a name using "localhost" as the registry name.
candidates := []string{}
initRegistries := []string{"localhost"}
if firstRegistry != "" && firstRegistry != "localhost" {
initRegistries = append([]string{firstRegistry}, initRegistries...)
}
for _, registry := range append(initRegistries, registries...) {
if registry == "" {
continue
}
middle := ""
if prefix, ok := RegistryDefaultPathPrefix[registry]; ok && !strings.ContainsRune(name, '/') {
middle = prefix
}
candidate := path.Join(registry, middle, name)
candidates = append(candidates, candidate)
}
return candidates, DefaultTransport, searchRegistriesAreEmpty, nil
}
// ExpandNames takes unqualified names, parses them as image names, and returns
// the fully expanded result, including a tag. Names which don't include a registry
// name will be marked for the most-preferred registry (i.e., the first one in our
// configuration).
func ExpandNames(names []string, firstRegistry string, systemContext *types.SystemContext, store storage.Store) ([]string, error) {
expanded := make([]string, 0, len(names))
for _, n := range names {
var name reference.Named
nameList, _, _, err := ResolveName(n, firstRegistry, systemContext, store)
if err != nil {
return nil, errors.Wrapf(err, "error parsing name %q", n)
}
if len(nameList) == 0 {
named, err := reference.ParseNormalizedNamed(n)
if err != nil {
return nil, errors.Wrapf(err, "error parsing name %q", n)
}
name = named
} else {
named, err := reference.ParseNormalizedNamed(nameList[0])
if err != nil {
return nil, errors.Wrapf(err, "error parsing name %q", nameList[0])
}
name = named
}
name = reference.TagNameOnly(name)
expanded = append(expanded, name.String())
}
return expanded, nil
}
// FindImage locates the locally-stored image which corresponds to a given name.
func FindImage(store storage.Store, firstRegistry string, systemContext *types.SystemContext, image string) (types.ImageReference, *storage.Image, error) {
var ref types.ImageReference
var img *storage.Image
var err error
names, _, _, err := ResolveName(image, firstRegistry, systemContext, store)
if err != nil {
return nil, nil, errors.Wrapf(err, "error parsing name %q", image)
}
for _, name := range names {
ref, err = is.Transport.ParseStoreReference(store, name)
if err != nil {
logrus.Debugf("error parsing reference to image %q: %v", name, err)
continue
}
img, err = is.Transport.GetStoreImage(store, ref)
if err != nil {
img2, err2 := store.Image(name)
if err2 != nil {
logrus.Debugf("error locating image %q: %v", name, err2)
continue
}
img = img2
}
break
}
if ref == nil || img == nil {
return nil, nil, errors.Wrapf(err, "error locating image with name %q (%v)", image, names)
}
return ref, img, nil
}
// AddImageNames adds the specified names to the specified image.
func AddImageNames(store storage.Store, firstRegistry string, systemContext *types.SystemContext, image *storage.Image, addNames []string) error {
names, err := ExpandNames(addNames, firstRegistry, systemContext, store)
if err != nil {
return err
}
err = store.SetNames(image.ID, append(image.Names, names...))
if err != nil {
return errors.Wrapf(err, "error adding names (%v) to image %q", names, image.ID)
}
return nil
}
// GetFailureCause checks the type of the error "err" and returns a new
// error message that reflects the reason of the failure.
// In case err type is not a familiar one the error "defaultError" is returned.
func GetFailureCause(err, defaultError error) error {
switch nErr := errors.Cause(err).(type) {
case errcode.Errors:
return err
case errcode.Error, *url.Error:
return nErr
default:
return defaultError
}
}
// WriteError writes `lastError` into `w` if not nil and return the next error `err`
func WriteError(w io.Writer, err error, lastError error) error {
if lastError != nil {
fmt.Fprintln(w, lastError)
}
return err
}
// Runtime is the default command to use to run the container.
func Runtime() string {
runtime := os.Getenv("BUILDAH_RUNTIME")
if runtime != "" {
return runtime
}
// Need to switch default until runc supports cgroups v2
if unified, _ := cgroups.IsCgroup2UnifiedMode(); unified {
return "crun"
}
return DefaultRuntime
}
// StringInSlice returns a boolean indicating if the exact value s is present
// in the slice slice.
func StringInSlice(s string, slice []string) bool {
for _, v := range slice {
if v == s {
return true
}
}
return false
}
// GetContainerIDs uses ID mappings to compute the container-level IDs that will
// correspond to a UID/GID pair on the host.
func GetContainerIDs(uidmap, gidmap []specs.LinuxIDMapping, uid, gid uint32) (uint32, uint32, error) {
uidMapped := true
for _, m := range uidmap {
uidMapped = false
if uid >= m.HostID && uid < m.HostID+m.Size {
uid = (uid - m.HostID) + m.ContainerID
uidMapped = true
break
}
}
if !uidMapped {
return 0, 0, errors.Errorf("container uses ID mappings (%#v), but doesn't map UID %d", uidmap, uid)
}
gidMapped := true
for _, m := range gidmap {
gidMapped = false
if gid >= m.HostID && gid < m.HostID+m.Size {
gid = (gid - m.HostID) + m.ContainerID
gidMapped = true
break
}
}
if !gidMapped {
return 0, 0, errors.Errorf("container uses ID mappings (%#v), but doesn't map GID %d", gidmap, gid)
}
return uid, gid, nil
}
// GetHostIDs uses ID mappings to compute the host-level IDs that will
// correspond to a UID/GID pair in the container.
func GetHostIDs(uidmap, gidmap []specs.LinuxIDMapping, uid, gid uint32) (uint32, uint32, error) {
uidMapped := true
for _, m := range uidmap {
uidMapped = false
if uid >= m.ContainerID && uid < m.ContainerID+m.Size {
uid = (uid - m.ContainerID) + m.HostID
uidMapped = true
break
}
}
if !uidMapped {
return 0, 0, errors.Errorf("container uses ID mappings (%#v), but doesn't map UID %d", uidmap, uid)
}
gidMapped := true
for _, m := range gidmap {
gidMapped = false
if gid >= m.ContainerID && gid < m.ContainerID+m.Size {
gid = (gid - m.ContainerID) + m.HostID
gidMapped = true
break
}
}
if !gidMapped {
return 0, 0, errors.Errorf("container uses ID mappings (%#v), but doesn't map GID %d", gidmap, gid)
}
return uid, gid, nil
}
// GetHostRootIDs uses ID mappings in spec to compute the host-level IDs that will
// correspond to UID/GID 0/0 in the container.
func GetHostRootIDs(spec *specs.Spec) (uint32, uint32, error) {
if spec.Linux == nil {
return 0, 0, nil
}
return GetHostIDs(spec.Linux.UIDMappings, spec.Linux.GIDMappings, 0, 0)
}
// GetPolicyContext sets up, initializes and returns a new context for the specified policy
func GetPolicyContext(ctx *types.SystemContext) (*signature.PolicyContext, error) {
policy, err := signature.DefaultPolicy(ctx)
if err != nil {
return nil, err
}
policyContext, err := signature.NewPolicyContext(policy)
if err != nil {
return nil, err
}
return policyContext, nil
}
// logIfNotErrno logs the error message unless err is either nil or one of the
// listed syscall.Errno values. It returns true if it logged an error.
func logIfNotErrno(err error, what string, ignores ...syscall.Errno) (logged bool) {
if err == nil {
return false
}
if errno, isErrno := err.(syscall.Errno); isErrno {
for _, ignore := range ignores {
if errno == ignore {
return false
}
}
}
logrus.Error(what)
return true
}
// LogIfNotRetryable logs "what" if err is set and is not an EINTR or EAGAIN
// syscall.Errno. Returns "true" if we can continue.
func LogIfNotRetryable(err error, what string) (retry bool) {
return !logIfNotErrno(err, what, syscall.EINTR, syscall.EAGAIN)
}
// LogIfUnexpectedWhileDraining logs "what" if err is set and is not an EINTR
// or EAGAIN or EIO syscall.Errno.
func LogIfUnexpectedWhileDraining(err error, what string) {
logIfNotErrno(err, what, syscall.EINTR, syscall.EAGAIN, syscall.EIO)
}
// TruncateString trims the given string to the provided maximum amount of
// characters and shortens it with `...`.
func TruncateString(str string, to int) string {
newStr := str
if len(str) > to {
const tr = "..."
if to > len(tr) {
to -= len(tr)
}
newStr = str[0:to] + tr
}
return newStr
}
|
[
"\"BUILDAH_RUNTIME\""
] |
[] |
[
"BUILDAH_RUNTIME"
] |
[]
|
["BUILDAH_RUNTIME"]
|
go
| 1 | 0 | |
src/go/MONIT/annotationManager.go
|
package main
// File : annotationManager.go
// Author : Rahul Indra <indrarahul2013 AT gmail dot com>
// Created : Tue, 1 Sep 2020 14:08:00 GMT
// Description: CERN MONIT infrastructure Annotation Manager CLI Tool
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"io/ioutil"
"log"
"net/http"
"net/http/httputil"
"net/url"
"os"
"strconv"
"strings"
"text/tabwriter"
"time"
)
// -------VARIABLES-------
// MAX timeStamp // Saturday, May 24, 3000 3:43:26 PM
var maxtstmp int64 = 32516091806
var microSec int64 = 1000000
var milliSec int64 = 1000
// token name
var token string
// text for annotating
var annotation string
// annotation ID for deleting single annotation
var annotationID int
// tags list seperated by comma
var tags string
// Action to be performed. [list, create, delete, deleteall, update] Default: list
var action string
// time range
var trange string
// boolean for generating default config
var generateConfig *bool
// Config filepath
var configFilePath string
// config variable
var configJSON config
// -------VARIABLES-------
// -------STRUCTS---------
// Grafana Dashboard Annotation API Data struct
type annotationData struct {
ID int `json:"id"` // Annotation Id
DashboardID int `json:"dashboardId"` // Dashboard ID
Created int64 `json:"created"` // Timestamp when the annotation created
Updated int64 `json:"updated"` // Timestamp when the annotation last updated
Time int64 `json:"time"` // Start Time of the annotation
TimeEnd int64 `json:"timeEnd"` // End Time of the annotation
Text string `json:"text"` // Text field of the annotation
Tags []string `json:"tags"` // List of tags attached with the annotation
}
type config struct {
GrafanaBaseURL string `json:"grafanaBaseURL"` // Grafana Annotation Base URL
FindDashboardAPI string `json:"findDashboardAPI"` // API endpoint for all dashboards with given tags
ListAnnotationsAPI string `json:"listAnnotationsAPI"` // API endpoint for fetching all annotations
CreateAnnotationAPI string `json:"createAnnotationAPI"` // API endpoint for creating an annotation
UpdateAnnotationAPI string `json:"updateAnnotationAPI"` // API endpoint for updating an annotation
DeleteAnnotationAPI string `json:"deleteAnnotationAPI"` // API endpoint for deleting an annotation
Columns []string `json:"columns"` // column names for annotations info
HTTPTimeout int `json:"httpTimeout"` // http timeout to connect to AM
Verbose int `json:"verbose"` // verbosity level
Token string `json:"token"` // CERN SSO token to use
}
// -------STRUCTS---------
// function for get request grafana annotations endpoint for fetching annotations.
func getAnnotations(data *[]annotationData, tags []string) {
var headers [][]string
bearer := fmt.Sprintf("Bearer %s", configJSON.Token)
h := []string{"Authorization", bearer}
headers = append(headers, h)
h = []string{"Accept", "application/json"}
headers = append(headers, h)
// Ex: /api/annotations?from=1598366184000&to=1598366184000&tags=cmsweb&tags=cmsmon-int
v := url.Values{}
if trange != "" {
tms := parseTimes(false) // False because Listing annotations with past time offset
if len(tms) == 2 {
v.Add("from", strings.Trim(strconv.FormatInt(tms[0], 10), " "))
v.Add("to", strings.Trim(strconv.FormatInt(tms[1], 10), " "))
} else if len(tms) == 1 {
v.Add("from", strings.Trim(strconv.FormatInt(tms[0], 10), " "))
v.Add("to", strings.Trim(strconv.FormatInt(time.Now().UTC().Unix()*int64(milliSec), 10), " "))
}
}
for _, tag := range tags {
v.Add("tags", strings.Trim(tag, " "))
}
apiURL := fmt.Sprintf("%s%s?%s", configJSON.GrafanaBaseURL, configJSON.ListAnnotationsAPI, v.Encode())
if configJSON.Verbose > 0 {
log.Println(apiURL)
}
req, err := http.NewRequest("GET", apiURL, nil)
if err != nil {
log.Fatalf("Unable to make request to %s, error: %s", apiURL, err)
}
for _, v := range headers {
if len(v) == 2 {
req.Header.Add(v[0], v[1])
}
}
timeout := time.Duration(configJSON.HTTPTimeout) * time.Second
client := &http.Client{Timeout: timeout}
if configJSON.Verbose > 1 {
log.Println("URL", apiURL)
dump, err := httputil.DumpRequestOut(req, true)
if err == nil {
log.Println("Request: ", string(dump))
}
}
resp, err := client.Do(req)
if err != nil {
log.Fatalf("Response Error, error: %v\n", err)
}
defer resp.Body.Close()
byteValue, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("Unable to read JSON Data from Grafana Annotation GET API, error: %v\n", err)
}
err = json.Unmarshal(byteValue, &data)
if err != nil {
if configJSON.Verbose > 0 {
log.Println(string(byteValue))
}
log.Fatalf("Unable to parse JSON Data from Grafana Annotation GET API, error: %v\n", err)
}
if configJSON.Verbose > 1 {
dump, err := httputil.DumpResponse(resp, true)
if err == nil {
log.Println("Response: ", string(dump))
}
}
}
// function for delete request on grafana annotations endpoint for deleting an annotation.
func deleteAnnotationHelper(annotationID int) {
apiurl := fmt.Sprintf("%s%s%d", configJSON.GrafanaBaseURL, configJSON.DeleteAnnotationAPI, annotationID)
req, err := http.NewRequest("DELETE", apiurl, nil)
if err != nil {
log.Fatalf("Request Error, error: %v\n", err)
}
req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", configJSON.Token))
timeout := time.Duration(configJSON.HTTPTimeout) * time.Second
client := &http.Client{Timeout: timeout}
if configJSON.Verbose > 1 {
log.Println("DELETE", apiurl)
} else if configJSON.Verbose > 2 {
dump, err := httputil.DumpRequestOut(req, true)
if err == nil {
log.Println("Request: ", string(dump))
}
}
resp, err := client.Do(req)
if err != nil {
log.Fatalf("Response Error, error: %v\n", err)
}
if resp.StatusCode != http.StatusOK {
log.Fatalf("Http Response Code Error, status code: %d", resp.StatusCode)
}
defer resp.Body.Close()
if configJSON.Verbose > 2 {
dump, err := httputil.DumpResponse(resp, true)
if err == nil {
log.Println("Response: ", string(dump))
}
}
}
//
// The following block of code was taken from
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/alert.go#L204
// Helper function for converting time difference in a meaningful manner
func diff(a, b time.Time) (array []int) {
if a.Location() != b.Location() {
b = b.In(a.Location())
}
if a.After(b) {
a, b = b, a
}
y1, M1, d1 := a.Date()
y2, M2, d2 := b.Date()
h1, m1, s1 := a.Clock()
h2, m2, s2 := b.Clock()
var year = int(y2 - y1)
var month = int(M2 - M1)
var day = int(d2 - d1)
var hour = int(h2 - h1)
var min = int(m2 - m1)
var sec = int(s2 - s1)
// Normalize negative values
if sec < 0 {
sec += 60
min--
}
if min < 0 {
min += 60
hour--
}
if hour < 0 {
hour += 24
day--
}
if day < 0 {
// days in month:
t := time.Date(y1, M1, 32, 0, 0, 0, 0, time.UTC)
day += 32 - t.Day()
month--
}
if month < 0 {
month += 12
year--
}
array = append(array, year)
array = append(array, month)
array = append(array, day)
array = append(array, hour)
array = append(array, min)
array = append(array, sec)
return
}
//
// The following block of code was taken from
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/alert.go#L259
// Helper function for time difference between two time.Time objects
func timeDiffHelper(timeList []int) (dif string) {
for ind := range timeList {
if timeList[ind] > 0 {
switch ind {
case 0:
dif += strconv.Itoa(timeList[ind]) + "Y "
break
case 1:
dif += strconv.Itoa(timeList[ind]) + "M "
break
case 2:
dif += strconv.Itoa(timeList[ind]) + "D "
break
case 3:
dif += strconv.Itoa(timeList[ind]) + "h "
break
case 4:
dif += strconv.Itoa(timeList[ind]) + "m "
break
case 5:
dif += strconv.Itoa(timeList[ind]) + "s "
break
default:
break
}
}
}
return
}
//
// The following block of code was taken from
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/alert.go#L291
// Function for time difference between two time.Time objects
func timeDiff(t1 time.Time, t2 time.Time, duration int) string {
if t1.After(t2) {
timeList := diff(t1, t2)
return timeDiffHelper(timeList) + "AGO"
}
timeList := diff(t2, t1)
if duration == 1 {
return timeDiffHelper(timeList)
}
return "IN " + timeDiffHelper(timeList)
}
//
// The following block of code was taken from (with few changes done)
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/alert.go#L426
// Function for printing annotations in Plain text format
func tabulate(data []annotationData) {
w := new(tabwriter.Writer)
w.Init(os.Stdout, 8, 8, 0, '\t', 0)
defer w.Flush()
fmt.Fprintf(w, "\n ")
for _, each := range configJSON.Columns {
fmt.Fprintf(w, "%s\t", each)
}
fmt.Fprintf(w, "\n")
for _, each := range data {
fmt.Fprintf(w, " %d\t%d\t%s\t%s\t%s",
each.ID,
each.DashboardID,
strings.Split(each.Text, "\n<a")[0],
each.Tags,
timeDiff(time.Now(), time.Unix(0, each.Time*int64(microSec)), 0), // times should be in microseconds of Unix since epoch
)
if each.TimeEnd == maxtstmp {
fmt.Fprintf(w, "\t%s", "Undefined")
fmt.Fprintf(w, "\t%s\n", "Undefined")
} else {
fmt.Fprintf(w, "\t%s", timeDiff(time.Now(), time.Unix(0, each.TimeEnd*int64(microSec)), 0)) // times should be in microseconds of Unix since epoch
fmt.Fprintf(w, "\t%s\n", timeDiff(time.Unix(0, each.Time*int64(microSec)), time.Unix(0, each.TimeEnd*int64(microSec)), 1)) // times should be in microseconds of Unix since epoch
}
}
}
// helper function for listing annotations
func listAnnotation() []annotationData {
var aData []annotationData
tagList := parseTags(tags)
getAnnotations(&aData, tagList)
if len(aData) == 0 {
log.Printf("NO ANNOTATION FOUND\n")
return nil
}
tabulate(aData)
return aData
}
//
// The following block of code was taken from (with few changes done)
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/monit.go#L603
// helper function to find dashboard info
func findDashboard() []map[string]interface{} {
tagsList := parseTags(tags)
var headers [][]string
bearer := fmt.Sprintf("Bearer %s", configJSON.Token)
h := []string{"Authorization", bearer}
headers = append(headers, h)
h = []string{"Accept", "application/json"}
headers = append(headers, h)
// example: /api/search?query=Production%20Overview&starred=true&tag=prod
v := url.Values{}
for _, tag := range tagsList {
v.Add("tag", strings.Trim(tag, " "))
}
rurl := fmt.Sprintf("%s%s?%s", configJSON.GrafanaBaseURL, configJSON.FindDashboardAPI, v.Encode())
if configJSON.Verbose > 0 {
log.Println(rurl)
}
req, err := http.NewRequest("GET", rurl, nil)
if err != nil {
log.Fatalf("Unable to make request to %s, error: %s", rurl, err)
}
for _, v := range headers {
if len(v) == 2 {
req.Header.Add(v[0], v[1])
}
}
if configJSON.Verbose > 1 {
dump, err := httputil.DumpRequestOut(req, true)
if err == nil {
log.Println("request: ", string(dump))
}
}
timeout := time.Duration(configJSON.HTTPTimeout) * time.Second
client := &http.Client{Timeout: timeout}
resp, err := client.Do(req)
if err != nil {
log.Fatalf("Unable to get response from %s, error: %s", rurl, err)
}
if configJSON.Verbose > 1 {
dump, err := httputil.DumpResponse(resp, true)
if err == nil {
log.Println("response: ", string(dump))
}
}
defer resp.Body.Close()
var data []map[string]interface{}
// Deserialize the response into a map.
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
log.Fatalf("Error parsing the response body: %s", err)
}
return data
}
//
// The following block of code was taken from (with few changes done)
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/monit.go#L657
// helper function to add annotation
func addAnnotation(data []byte) {
var headers [][]string
bearer := fmt.Sprintf("Bearer %s", configJSON.Token)
h := []string{"Authorization", bearer}
headers = append(headers, h)
h = []string{"Content-Type", "application/json"}
headers = append(headers, h)
rurl := fmt.Sprintf("%s%s", configJSON.GrafanaBaseURL, configJSON.CreateAnnotationAPI)
if configJSON.Verbose > 0 {
log.Println(rurl)
}
req, err := http.NewRequest("POST", rurl, bytes.NewBuffer(data))
if err != nil {
log.Fatalf("Unable to make request to %s, error: %s", rurl, err)
}
for _, v := range headers {
if len(v) == 2 {
req.Header.Add(v[0], v[1])
}
}
if configJSON.Verbose > 1 {
dump, err := httputil.DumpRequestOut(req, true)
if err == nil {
log.Println("request: ", string(dump))
}
}
timeout := time.Duration(configJSON.HTTPTimeout) * time.Second
client := &http.Client{Timeout: timeout}
resp, err := client.Do(req)
if err != nil {
log.Fatalf("Unable to get response from %s, error: %s", rurl, err)
}
if configJSON.Verbose > 1 {
dump, err := httputil.DumpResponse(resp, true)
if err == nil {
log.Println("response:", string(dump))
}
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("Unable to read JSON Data from Grafana Annotation POST API, error: %v\n", err)
}
if configJSON.Verbose > 1 {
log.Println("response Status:", resp.Status)
log.Println("response Headers:", resp.Header)
log.Println("response Body:", string(body))
}
}
//
// The following block of code was taken from (with few changes done)
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/monit.go#L813
func createAnnotation() {
if annotation != "" {
if tags != "" {
dashboards := findDashboard()
timeRanges := parseTimes(true) // True because we are creating annotation and time ranges should be in future
if trange == "" {
log.Fatalf("Unable to create Annotation. Please provide Time Range!\n")
}
if configJSON.Verbose > 0 {
log.Println("timeRanges", timeRanges)
}
for _, r := range dashboards {
rec := make(map[string]interface{})
rec["dashboardId"] = r["id"]
rec["time"] = timeRanges[0]
rec["timeEnd"] = timeRanges[1]
rec["tags"] = parseTags(tags)
rec["text"] = annotation
data, err := json.Marshal(rec)
if err != nil {
log.Fatalf("Unable to marshal the data %+v, error %v\n", rec, err)
}
if configJSON.Verbose > 0 {
log.Printf("Add annotation: %+v", rec)
}
addAnnotation(data)
}
log.Printf("Annotation Created Successfully\n")
} else {
log.Fatalf("Can't Create annotation. Please provide tags!\n")
}
} else {
log.Fatalf("Can't Create annotation without any text!\n")
}
}
// helper function for updating an annotation which makes PUT request
func updateAnnotationHelper(annotationID int, data []byte) {
var headers [][]string
bearer := fmt.Sprintf("Bearer %s", configJSON.Token)
h := []string{"Authorization", bearer}
headers = append(headers, h)
h = []string{"Content-Type", "application/json"}
headers = append(headers, h)
h = []string{"Accept", "application/json"}
headers = append(headers, h)
apiurl := fmt.Sprintf("%s%s%d", configJSON.GrafanaBaseURL, configJSON.DeleteAnnotationAPI, annotationID)
if configJSON.Verbose > 0 {
log.Println(apiurl)
}
req, err := http.NewRequest("PUT", apiurl, bytes.NewBuffer(data))
if err != nil {
log.Fatalf("Unable to make request to %s, error: %s", apiurl, err)
}
for _, v := range headers {
if len(v) == 2 {
req.Header.Add(v[0], v[1])
}
}
if configJSON.Verbose > 1 {
dump, err := httputil.DumpRequestOut(req, true)
if err == nil {
log.Println("request: ", string(dump))
}
}
timeout := time.Duration(configJSON.HTTPTimeout) * time.Second
client := &http.Client{Timeout: timeout}
resp, err := client.Do(req)
if err != nil {
log.Fatalf("Unable to get response from %s, error: %s", apiurl, err)
}
if configJSON.Verbose > 1 {
dump, err := httputil.DumpResponse(resp, true)
if err == nil {
log.Println("response:", string(dump))
}
}
if resp.StatusCode != 200 {
log.Fatalf("HTTP Respose error, code: %d", resp.StatusCode)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatalf("Unable to read JSON Data from Grafana Annotation PUT API, error: %v\n", err)
}
if configJSON.Verbose > 1 {
log.Println("response Status:", resp.Status)
log.Println("response Headers:", resp.Header)
log.Println("response Body:", string(body))
}
}
// function which contains the logic of updating an annotation
func updateAnnotation() {
updatedData := make(map[string]interface{})
if trange != "" {
tms := parseTimes(true)
if len(tms) == 2 {
updatedData["time"] = tms[0]
updatedData["timeEnd"] = tms[1]
}
}
if annotation != "" {
updatedData["text"] = annotation
}
if tags != "" {
updatedData["tags"] = parseTags(tags)
}
data, err := json.Marshal(updatedData)
if err != nil {
log.Fatalf("Unable to parse Data for Updation, update failed !, error: %v", err)
}
updateAnnotationHelper(annotationID, data)
log.Printf("Annotation with id:%d has been updated successfully!\n", annotationID)
if configJSON.Verbose > 1 {
log.Printf("Annotation Update Data :%v\n", string(data))
}
}
// function which contains the logic of deleting an annotation
func deleteOneAnnotation() {
deleteAnnotationHelper(annotationID)
log.Printf("Annotation with id: %d has been deleted successfully !\n", annotationID)
}
// function which contains the logic of deleting multiple annotations
func deleteAllAnnotations() {
noOfDeletedAnnotation := 0
aData := listAnnotation()
if aData != nil {
log.Printf("DELETING ALL OF THE ALERTS SHOWN ABOVE!!\n")
for _, each := range aData {
deleteAnnotationHelper(each.ID)
if configJSON.Verbose > 2 {
log.Printf("Annotation Deleted for:\n%+v\n", each)
}
noOfDeletedAnnotation++
}
log.Printf("Successfully Deleted %d annotations!!\n", noOfDeletedAnnotation)
} else {
log.Fatalf("Unable to delete with null data!\n")
}
}
// Function running all logics
func run() {
switch action {
case "list":
listAnnotation()
case "create":
createAnnotation()
case "update":
updateAnnotation()
case "delete":
deleteOneAnnotation()
case "deleteall":
deleteAllAnnotations()
default:
listAnnotation()
}
}
// helper function for parsing Configs
func openConfigFile(configFilePath string) {
jsonFile, e := os.Open(configFilePath)
if e != nil {
if configJSON.Verbose > 0 {
log.Printf("Config File not found at %s, error: %s\n", configFilePath, e)
} else {
log.Printf("Config File Missing at %s. Using Defaults\n", configFilePath)
}
return
}
defer jsonFile.Close()
decoder := json.NewDecoder(jsonFile)
err := decoder.Decode(&configJSON)
if err != nil {
log.Printf("Config JSON File can't be loaded, error: %s", err)
return
} else if configJSON.Verbose > 0 {
log.Printf("Load config from %s\n", configFilePath)
}
}
// function for parsing Configs
func parseConfig(verbose int) {
configFilePath = os.Getenv("CONFIG_PATH") // CONFIG_PATH Environment Variable storing config filepath.
defaultConfigFilePath := os.Getenv("HOME") + "/.annotationManagerConfig.json"
// Defaults in case no config file is provided
configJSON.GrafanaBaseURL = "https://monit-grafana.cern.ch"
configJSON.ListAnnotationsAPI = "/api/annotations/"
configJSON.CreateAnnotationAPI = "/api/annotations/"
configJSON.UpdateAnnotationAPI = "/api/annotations/"
configJSON.DeleteAnnotationAPI = "/api/annotations/"
configJSON.FindDashboardAPI = "/api/search"
configJSON.Columns = []string{"ID", "DASID", "TEXT", "TAGS", "STARTS", "ENDS", "DURATION"}
configJSON.Verbose = verbose
configJSON.HTTPTimeout = 5 // 5 seconds timeout for http
if *generateConfig {
config, err := json.MarshalIndent(configJSON, "", " ")
if err != nil {
log.Fatalf("Default Config Value can't be parsed from configJSON struct, error: %s", err)
}
filePath := defaultConfigFilePath
if len(flag.Args()) > 0 {
filePath = flag.Args()[0]
}
err = ioutil.WriteFile(filePath, config, 0644)
if err != nil {
log.Fatalf("Failed to generate Config File, error: %s", err)
}
log.Printf("A new configuration file %s was generated.\n", filePath)
return
}
if configFilePath != "" {
openConfigFile(configFilePath)
} else if defaultConfigFilePath != "" {
log.Printf("$CONFIG_PATH is not set. Using config file at %s\n", defaultConfigFilePath)
openConfigFile(defaultConfigFilePath)
}
// we we were given verbose from command line we should overwrite its value in config
if verbose > 0 {
configJSON.Verbose = verbose
}
if configJSON.Verbose > 0 {
log.SetFlags(log.LstdFlags | log.Lshortfile)
} else {
log.SetFlags(log.LstdFlags)
}
// if we were given the token we will use it
if token != "" {
configJSON.Token = token
}
if configJSON.Verbose > 1 {
log.Printf("Configuration:\n%+v\n", configJSON)
}
}
//
// The following block of code was taken from
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/monit.go#L550
// helper function to parse comma separated tags string
func parseTags(itags string) []string {
var tags []string
for _, tag := range strings.Split(itags, ",") {
tags = append(tags, strings.Trim(tag, " "))
}
return tags
}
//
// The following block of code was taken from (with few changes done)
// https://github.com/dmwm/CMSMonitoring/blob/master/src/go/MONIT/monit.go#L559
// helper function to parse given time-range separated by '-'
func parseTimes(ifCreatingAnnotation bool) []int64 {
var times []int64
// additional line added in the adopted code for date support.
if strings.Contains(trange, "--") {
tms := strings.Split(trange, "--")
startTime, err := time.Parse(time.RFC3339, tms[0])
if err != nil {
log.Fatalf("Unable to parse time, error: %s", err)
}
endTime, err := time.Parse(time.RFC3339, tms[1])
if err != nil {
log.Fatalf("Unable to parse time, error: %s", err)
}
times = append(times, startTime.Unix()*int64(milliSec))
times = append(times, endTime.Unix()*int64(milliSec)) // times should be in milliseconds of Unix since epoch
return times
}
for _, v := range strings.Split(trange, "-") {
v = strings.Trim(v, " ")
var t int64
if v == "now" {
t = time.Now().UTC().Unix()
} else if len(v) == 10 { // unix since epoch
value, err := strconv.Atoi(v)
if err != nil {
log.Fatalf("Unable to parse given time value: %v\n", v)
}
t = int64(value)
} else {
var value string
var offset int64
if strings.HasSuffix(v, "s") || strings.HasSuffix(v, "sec") || strings.HasSuffix(v, "secs") {
value = strings.Split(v, "s")[0]
offset = 1
} else if strings.HasSuffix(v, "m") || strings.HasSuffix(v, "min") || strings.HasSuffix(v, "mins") {
value = strings.Split(v, "m")[0]
offset = 60
} else if strings.HasSuffix(v, "h") || strings.HasSuffix(v, "hr") || strings.HasSuffix(v, "hrs") {
value = strings.Split(v, "h")[0]
offset = 60 * 60
} else if strings.HasSuffix(v, "d") || strings.HasSuffix(v, "day") || strings.HasSuffix(v, "days") {
value = strings.Split(v, "d")[0]
offset = 60 * 60 * 24
} else {
log.Fatalf("Unable to parse given time value: %v\n", v)
}
if v, e := strconv.Atoi(value); e == nil {
if ifCreatingAnnotation { // When we create annotation we think in future time frame while when we list annotation the offset would be in past.
t = time.Now().UTC().Add(time.Duration((int64(v) * offset)) * time.Second).Unix() // FUTURE OFFSET
} else {
t = time.Now().UTC().Add(time.Duration((int64(v) * offset)) * -1 * time.Second).Unix() // PAST OFFSET
}
}
}
if t == 0 {
log.Fatalf("Unable to parse given time value: %v\n", v)
}
times = append(times, t*milliSec) // times should be in milliseconds of Unix since epoch
}
return times
}
func main() {
flag.StringVar(&annotation, "annotation", "", "Annotation text")
flag.StringVar(&token, "token", "", "Authentication token to use (Optional-can be stored in config file)")
flag.StringVar(&tags, "tags", "", "List of tags seperated by comma")
flag.StringVar(&action, "action", "", "Action to be performed. [list, create, delete, deleteall, update] Default: list")
flag.StringVar(&trange, "trange", "", "Time Range for filtering annotations.")
flag.IntVar(&annotationID, "annotationID", 0, "Annotation ID required in making delete api call for deleting an annotation")
generateConfig = flag.Bool("generateConfig", false, "Flag for generating default config")
var verbose int
flag.IntVar(&verbose, "verbose", 0, "verbosity level, can be overwritten in config (Optional-can be stored in config file)")
flag.Usage = func() {
configPath := os.Getenv("HOME") + "/.annotationManagerConfig.json"
fmt.Println("Usage: annotationManager [options]")
flag.PrintDefaults()
fmt.Println("\nEnvironments:")
fmt.Printf("\tCONFIG_PATH:\t Config to use, default (%s)\n", configPath)
fmt.Println("\nExamples:")
fmt.Println("\tALTHOUGH ACTION SHOULD BE (-action=list) FOR GETTING ALL ANNOTATIONS BUT ACTION FLAG CAN BE DROPPED AS LIST IS DEFAULT ACTION!")
fmt.Println("\n\tGet all annotations with specified tags:")
fmt.Println("\t annotationManager -action=list -tags=das,cmsmon-int")
fmt.Println("\n\tUse (d/day/days) for days, (h/hr/hrs) for hours, (m/min/mins) for minutes and (s/sec/secs) for seconds.")
fmt.Println("\n\tGet all annotations with specified tags on time period range (from last 7days to now)")
fmt.Println("\t annotationManager -action=list -tags=das,cmsmon-int -trange=7d-now")
fmt.Println("\n\tGet all annotations with specified tags on time period range (from last 14days to last 7days)")
fmt.Println("\t annotationManager -action=list -tags=das,cmsmon-int -trange=14d-7d")
fmt.Println("\n\tGet all annotations with specified tags on time period range (using dates seperated by '--')")
fmt.Println("\t annotationManager -action=list -tags=das,cmsmon-int -trange=2020-09-01T19:49:50.206Z--2020-09-01T19:49:50.206Z")
fmt.Println("\n\tDelete all annotations once you find appropriate annotations to delete from the above commands.")
fmt.Println("\t annotationManager -action=deleteall -tags=das,cmsmon-int -trange=7d-now")
fmt.Println("\t annotationManager -action=deleteall -tags=das,cmsmon-int -trange=14d-7d")
fmt.Println("\t annotationManager -action=deleteall -tags=das,cmsmon-int -trange=2020-09-01T19:49:50.206Z--2020-09-01T19:49:50.206Z")
fmt.Println("\n\tDelete an annotation with specific annotation id (/api/annotations/:id)")
fmt.Println("\t annotationManager -action=delete -annotationID=761323")
fmt.Println("\n\tCreate an annotation on dashboards with specific tags with time ranging from now to 2m")
fmt.Println("\t annotationManager -action=create -annotation=\"some message\" -tags=das,cmsweb -trange=now-2m")
fmt.Println("\n\tUpdate an annotation with specific annotation id with new annotation and tags. (/api/annotations/:id)")
fmt.Println("\t(TAGS AND ANNOTATION ARE REQUIRED FLAGS OR OLD DATA WILL BE REPLACED WITH NULL VALUES. If you don't want to change annotation or tag, please send the old values.)")
fmt.Println("\t annotationManager -action=update -annotationID=761323 -annotation=\"some new message\" -tags=newTag1,newTag2")
fmt.Println("\n\tUpdate an annotation with specific annotation id with new start and end Time. (/api/annotations/:id)")
fmt.Println("\t(TAGS AND ANNOTATION ARE REQUIRED FLAGS OR OLD DATA WILL BE REPLACED WITH NULL VALUES. If you don't want to change annotation or tag, please send the old values.)")
fmt.Println("\t annotationManager -action=update -annotationID=761323 -annotation=\"old message\" -tags=oldTag1,oldTag2 -trange=now-5m")
}
flag.Parse()
parseConfig(verbose)
if !*generateConfig {
run()
}
}
|
[
"\"CONFIG_PATH\"",
"\"HOME\"",
"\"HOME\""
] |
[] |
[
"HOME",
"CONFIG_PATH"
] |
[]
|
["HOME", "CONFIG_PATH"]
|
go
| 2 | 0 | |
httpecho.go
|
package main
import (
"bufio"
"crypto/tls"
"flag"
"fmt"
"io"
"log"
"net"
"os"
"strings"
"time"
"github.com/ariary/HTTPCustomHouse/pkg/utils"
)
const usage = `Usage of httpecho: echo server accepting malformed HTTP request
-s, --serve serve continuously (default: wait for 1 request)
-t, --timeout timeout to close connection in millisecond. Needed for closing http request. (default: 500)
-d, --dump dump incoming request to a file (default: only print to stdout)
-p, --port listening on specific port (default: 8888)
-v, --verbose display request with special characters
--tls use TLS encryption for communication
-h, --help dump incoming request to a file (default: only print to stdout)
`
var verbose bool
func main() {
//-s
var serve bool
flag.BoolVar(&serve, "serve", false, "Serve continuously (default: wait for 1 request)")
flag.BoolVar(&serve, "s", false, "Serve continuously (default: wait for 1 request)")
// -t
var timeout int
flag.IntVar(&timeout, "timeout", 200, "Timeout to close connection. Needed for closing http request. (default: 200)")
flag.IntVar(&timeout, "t", 200, "Timeout to close connection. Needed for closing http request. (default: 200)")
//-d
var dump string
flag.StringVar(&dump, "dump", "", "Dump incoming request to a file (default: only print to stdout)")
flag.StringVar(&dump, "d", "", "Dump incoming request to a file (default: only print to stdout)")
//-p
var port string
flag.StringVar(&port, "port", "8888", "Listening on specific port (default: 8888)")
flag.StringVar(&port, "p", "8888", "Listening on specific port (default: 8888)")
//--tls
var encrypted bool
flag.BoolVar(&encrypted, "tls", false, "Use TLS encryption for communication")
//-v,--verbose
flag.BoolVar(&verbose, "verbose", false, "Display request with special characters")
flag.BoolVar(&verbose, "v", false, "Display request with special characters")
flag.Usage = func() { fmt.Print(usage) }
flag.Parse()
log.SetFlags(log.Lshortfile)
port = ":" + port
var ln net.Listener
var err error
if encrypted {
home := os.Getenv("HOME")
cer, err := tls.LoadX509KeyPair(home+"/.httpecho/server.crt", home+"/.httpecho/server.key")
if err != nil {
log.Println(err)
return
}
config := &tls.Config{Certificates: []tls.Certificate{cer}}
ln, err = tls.Listen("tcp", port, config)
} else {
ln, err = net.Listen("tcp", port)
}
if err != nil {
log.Println(err)
return
}
defer ln.Close()
if serve {
for {
conn, err := ln.Accept()
conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second)) //close http request
if err != nil {
log.Println(err)
}
//fmt.Println("-----------------")
go handleConnection(conn, dump, timeout)
}
} else { //only 1 time
conn, err := ln.Accept()
//conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Millisecond)) //close http request
if err != nil {
log.Println(err)
}
handleConnection(conn, dump, timeout)
}
}
func handleConnection(conn net.Conn, dump string, timeout int) {
defer conn.Close()
//HTTP1.1 OK!
n, err := conn.Write([]byte("HTTP/1.1 200 OK\n\n"))
if err != nil {
log.Println(n, err)
return
}
writeFile := false
var request string
if dump != "" {
writeFile = true
f, err := os.Create(dump)
if err != nil {
log.Fatal(err)
}
defer f.Close()
}
r := bufio.NewReader(conn)
go func() { //handle packet without '\n' ending character
time.Sleep(time.Duration(timeout) * time.Millisecond)
residue, err := r.Peek(r.Buffered())
if err != nil && err != io.EOF {
log.Println(err)
}
n, err := conn.Write(residue)
if err != nil && err != io.EOF {
log.Println(n, err)
return
}
conn.Close()
}()
for {
msg, err := r.ReadString('\n')
//print log
if verbose {
msgDebug := strings.ReplaceAll(string(msg), "\r", utils.Green("\\r"))
msgDebug = strings.ReplaceAll(string(msgDebug), "\n", utils.Green("\\n\n"))
fmt.Print(msgDebug)
} else {
fmt.Print(msg)
}
//write to file
if writeFile {
request += msg
}
//handle read error
if err != nil && err != io.EOF {
if !strings.Contains(err.Error(), "timeout") && !strings.Contains(err.Error(), "closed network connection") { //avoid timeout error
log.Println(err)
}
if writeFile { //Write request received in file
f, err := os.Create(dump)
if err != nil {
log.Fatal(err)
}
defer f.Close()
_, err2 := f.WriteString(request)
if err2 != nil {
log.Fatal(err2)
} else {
fmt.Println("dump request in:", dump)
}
}
return
}
n, err := conn.Write([]byte(msg))
if err != nil {
log.Println(n, err)
return
}
}
}
|
[
"\"HOME\""
] |
[] |
[
"HOME"
] |
[]
|
["HOME"]
|
go
| 1 | 0 | |
test/Configure/config-h.py
|
#!/usr/bin/env python
#
# __COPYRIGHT__
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
Verify creation of a config.h file from a Configure context.
"""
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
import os
import re
import TestSCons
test = TestSCons.TestSCons(match = TestSCons.match_exact)
lib = test.Configure_lib
LIB = "LIB" + lib.upper()
test.write('SConstruct', """\
env = Environment()
import os
env.AppendENVPath('PATH', os.environ['PATH'])
conf = Configure(env, config_h = 'config.h')
r1 = conf.CheckFunc('printf')
r2 = conf.CheckFunc('noFunctionCall')
r3 = conf.CheckFunc('memmove')
r4 = conf.CheckType('int')
r5 = conf.CheckType('noType')
r6 = conf.CheckCHeader('stdio.h', '<>')
r7 = conf.CheckCHeader('hopefullynoc-header.h')
r8 = conf.CheckCXXHeader('vector', '<>')
r9 = conf.CheckCXXHeader('hopefullynocxx-header.h')
env = conf.Finish()
conf = Configure(env, config_h = 'config.h')
r10 = conf.CheckLib('%(lib)s', 'sin')
r11 = conf.CheckLib('hopefullynolib', 'sin')
r12 = conf.CheckLibWithHeader('%(lib)s', 'math.h', 'c')
r13 = conf.CheckLibWithHeader('%(lib)s', 'hopefullynoheader2.h', 'c')
r14 = conf.CheckLibWithHeader('hopefullynolib2', 'math.h', 'c')
env = conf.Finish()
""" % locals())
expected_read_str = """\
Checking for C function printf()... yes
Checking for C function noFunctionCall()... no
Checking for C function memmove()... yes
Checking for C type int... yes
Checking for C type noType... no
Checking for C header file stdio.h... yes
Checking for C header file hopefullynoc-header.h... no
Checking for C++ header file vector... yes
Checking for C++ header file hopefullynocxx-header.h... no
Checking for sin() in C library %(lib)s... yes
Checking for sin() in C library hopefullynolib... no
Checking for C library %(lib)s... yes
Checking for C library %(lib)s... no
Checking for C library hopefullynolib2... no
""" % locals()
expected_build_str = """\
scons: Configure: creating config.h
"""
expected_stdout = test.wrap_stdout(build_str=expected_build_str,
read_str=expected_read_str)
expected_config_h = ("""\
#ifndef CONFIG_H_SEEN
#define CONFIG_H_SEEN
/* Define to 1 if the system has the function `printf'. */
#define HAVE_PRINTF 1
/* Define to 1 if the system has the function `noFunctionCall'. */
/* #undef HAVE_NOFUNCTIONCALL */
/* Define to 1 if the system has the function `memmove'. */
#define HAVE_MEMMOVE 1
/* Define to 1 if the system has the type `int'. */
#define HAVE_INT 1
/* Define to 1 if the system has the type `noType'. */
/* #undef HAVE_NOTYPE */
/* Define to 1 if you have the <stdio.h> header file. */
#define HAVE_STDIO_H 1
/* Define to 1 if you have the <hopefullynoc-header.h> header file. */
/* #undef HAVE_HOPEFULLYNOC_HEADER_H */
/* Define to 1 if you have the <vector> header file. */
#define HAVE_VECTOR 1
/* Define to 1 if you have the <hopefullynocxx-header.h> header file. */
/* #undef HAVE_HOPEFULLYNOCXX_HEADER_H */
/* Define to 1 if you have the `%(lib)s' library. */
#define HAVE_%(LIB)s 1
/* Define to 1 if you have the `hopefullynolib' library. */
/* #undef HAVE_LIBHOPEFULLYNOLIB */
/* Define to 1 if you have the `%(lib)s' library. */
#define HAVE_%(LIB)s 1
/* Define to 1 if you have the `%(lib)s' library. */
/* #undef HAVE_%(LIB)s */
/* Define to 1 if you have the `hopefullynolib2' library. */
/* #undef HAVE_LIBHOPEFULLYNOLIB2 */
#endif /* CONFIG_H_SEEN */
""" % locals())
test.run(stdout=expected_stdout)
config_h = test.read(test.workpath('config.h'), mode='r')
if expected_config_h != config_h:
print("Unexpected config.h")
print("Expected: ")
print("---------------------------------------------------------")
print(repr(expected_config_h))
print("---------------------------------------------------------")
print("Found: ")
print("---------------------------------------------------------")
print(repr(config_h))
print("---------------------------------------------------------")
print("Stdio: ")
print("---------------------------------------------------------")
print(test.stdout())
print("---------------------------------------------------------")
test.fail_test()
expected_read_str = re.sub(r'\b((yes)|(no))\b',
r'(cached) \1',
expected_read_str)
expected_build_str = "scons: `.' is up to date.\n"
expected_stdout = test.wrap_stdout(build_str=expected_build_str,
read_str=expected_read_str)
#expected_stdout = expected_stdout.replace("\n", os.linesep)
test.run(stdout=expected_stdout)
config_h = test.read(test.workpath('config.h'),mode='r')
if expected_config_h != config_h:
print("Unexpected config.h")
print("Expected: ")
print("---------------------------------------------------------")
print(repr(expected_config_h))
print("---------------------------------------------------------")
print("Found: ")
print("---------------------------------------------------------")
print(repr(config_h))
print("---------------------------------------------------------")
print("Stdio: ")
print("---------------------------------------------------------")
print(test.stdout())
print("---------------------------------------------------------")
test.fail_test()
test.pass_test()
# Local Variables:
# tab-width:4
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=4 shiftwidth=4:
|
[] |
[] |
[
"PATH"
] |
[]
|
["PATH"]
|
python
| 1 | 0 | |
ci.py
|
#!/usr/bin/env python
# (C) Copyright 2017 Hewlett Packard Enterprise Development LP
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import argparse
import datetime
import gzip
import json
import logging
import os
import re
import shutil
import signal
import six
import subprocess
import sys
import time
import yaml
parser = argparse.ArgumentParser(description='CI command')
parser.add_argument('-p', '--pipeline', dest='pipeline', default=None, required=True,
help='Select the pipeline [metrics|logs]')
parser.add_argument('-nv', '--non-voting', dest='non_voting', action='store_true',
help='Set the check as non-voting')
parser.add_argument('-pl', '--print-logs', dest='printlogs', action='store_true',
help='Print containers logs')
parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',
help='Increment verbosity')
parser.add_argument('--CI_BRANCH', dest='ci_branch', default=None, required=False,
help='')
parser.add_argument('--CI_EVENT_TYPE', dest='ci_event_type', default=None, required=False,
help='')
parser.add_argument('--CI_COMMIT_RANGE', dest='ci_commit_range', default=None, required=False,
help='')
args = parser.parse_args()
pipeline = args.pipeline
non_voting = args.non_voting
printlogs = args.printlogs
verbose = args.verbose
ci_branch = args.ci_branch if args.ci_branch else os.environ.get('CI_BRANCH', None)
ci_event_type = args.ci_event_type if args.ci_event_type else os.environ.get('CI_EVENT_TYPE', None)
ci_commit_range = args.ci_commit_range if args.ci_commit_range else os.environ.get('CI_COMMIT_RANGE', None)
logging.basicConfig(format = '%(asctime)s %(levelname)5.5s %(message)s')
LOG=logging.getLogger(__name__)
verbose = args.verbose
LOG.setLevel(logging.DEBUG) if verbose else LOG.setLevel(logging.INFO)
LOG.debug(args)
#TAG_REGEX = re.compile(r'^!(\w+)(?:\s+([\w-]+))?$')
TAG_REGEX = re.compile(r'^!(build|push|readme)(?:\s([\w-]+))$')
METRIC_PIPELINE_MARKER = 'metrics'
LOG_PIPELINE_MARKER = 'logs'
TEMPEST_TIMEOUT = 20 # minutes
BUILD_TIMEOUT = 20 # minutes
INITJOBS_ATTEMPS = 5
METRIC_PIPELINE_MODULE_TO_COMPOSE_SERVICES = {
'monasca-agent-forwarder': 'agent-forwarder',
'zookeeper': 'zookeeper',
'influxdb': 'influxdb',
'kafka': 'kafka',
'kafka-init': 'kafka-init',
'monasca-thresh': 'thresh',
'monasca-persister-python': 'monasca-persister',
'mysql-init': 'mysql-init',
'monasca-api-python': 'monasca',
'influxdb-init': 'influxdb-init',
'monasca-agent-collector': 'agent-collector',
'grafana': 'grafana',
'monasca-notification': 'monasca-notification',
'grafana-init': 'grafana-init',
'monasca-statsd': 'monasca-statsd'
}
LOGS_PIPELINE_MODULE_TO_COMPOSE_SERVICES = {
'monasca-log-metrics': 'log-metrics',
'monasca-log-persister': 'log-persister',
'monasca-log-transformer': 'log-transformer',
'elasticsearch': 'elasticsearch',
'elasticsearch-curator': 'elasticsearch-curator',
'elasticsearch-init': 'elasticsearch-init',
'kafka-init': 'kafka-log-init',
'kibana': 'kibana',
'monasca-log-api': 'log-api',
'monasca-log-agent': 'log-agent',
'logspout': 'logspout',
}
METRIC_PIPELINE_INIT_JOBS = ('influxdb-init', 'kafka-init', 'mysql-init', 'grafana-init')
LOG_PIPELINE_INIT_JOBS = ('elasticsearch-init', 'kafka-log-init')
INIT_JOBS = {
METRIC_PIPELINE_MARKER: METRIC_PIPELINE_INIT_JOBS,
LOG_PIPELINE_MARKER: LOG_PIPELINE_INIT_JOBS
}
METRIC_PIPELINE_SERVICES = METRIC_PIPELINE_MODULE_TO_COMPOSE_SERVICES.values()
"""Explicit list of services for docker compose
to launch for metrics pipeline"""
LOG_PIPELINE_SERVICES = LOGS_PIPELINE_MODULE_TO_COMPOSE_SERVICES.values()
"""Explicit list of services for docker compose
to launch for logs pipeline"""
PIPELINE_TO_YAML_COMPOSE = {
METRIC_PIPELINE_MARKER: 'docker-compose-metric.yml',
LOG_PIPELINE_MARKER: 'docker-compose-log.yml'
}
CI_COMPOSE_FILE = 'ci-compose.yml'
LOG_DIR = 'monasca-logs/' + \
datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
BUILD_LOG_DIR = LOG_DIR + '/build/'
RUN_LOG_DIR = LOG_DIR + '/run/'
LOG_DIRS = [LOG_DIR, BUILD_LOG_DIR, RUN_LOG_DIR]
class SubprocessException(Exception):
pass
class FileReadException(Exception):
pass
class FileWriteException(Exception):
pass
class InitJobFailedException(Exception):
pass
class TempestTestFailedException(Exception):
pass
class SmokeTestFailedException(Exception):
pass
class BuildFailedException(Exception):
pass
def print_logs():
for log_dir in LOG_DIRS:
for file_name in os.listdir(log_dir):
file_path = log_dir + file_name
if os.path.isfile(file_path):
with open(file_path, 'r') as f:
log_contents = f.read()
LOG.info("#" * 100)
LOG.info("###### Container Logs from {0}".format(file_name))
LOG.info("#" * 100)
LOG.info(log_contents)
def set_log_dir():
try:
LOG.debug('Working directory: {0}'.format(os.getcwd()))
if not os.path.exists(LOG_DIR):
LOG.debug('Creating LOG_DIR: {0}'.format(LOG_DIR))
os.makedirs(LOG_DIR)
if not os.path.exists(BUILD_LOG_DIR):
LOG.debug('Creating BUILD_LOG_DIR: {0}'.format(BUILD_LOG_DIR))
os.makedirs(BUILD_LOG_DIR)
if not os.path.exists(RUN_LOG_DIR):
LOG.debug('Creating RUN_LOG_DIR: {0}'.format(RUN_LOG_DIR))
os.makedirs(RUN_LOG_DIR)
except Exception as e:
LOG.error('Unexpected error {0}'.format(e))
def get_changed_files():
if not ci_commit_range:
return []
LOG.debug('Execute: git diff --name-only {0}'.format(ci_commit_range))
p = subprocess.Popen([
'git', 'diff', '--name-only', ci_commit_range
], stdout=subprocess.PIPE)
stdout, _ = p.communicate()
if six.PY3:
stdout = stdout.decode('utf-8')
if p.returncode != 0:
raise SubprocessException('git returned non-zero exit code')
return [line.strip() for line in stdout.splitlines()]
def get_message_tags():
if not ci_commit_range:
return []
LOG.debug('Execute: git log --pretty=%B -1 {0}'.format(ci_commit_range))
p = subprocess.Popen([
'git', 'log', '--pretty=%B', '-1', ci_commit_range
], stdout=subprocess.PIPE)
stdout, _ = p.communicate()
if six.PY3:
stdout = stdout.decode('utf-8')
if p.returncode != 0:
raise SubprocessException('git returned non-zero exit code')
tags = []
for line in stdout.splitlines():
line = line.strip()
m = TAG_REGEX.match(line)
if m:
tags.append(m.groups())
return tags
def get_dirty_modules(dirty_files):
dirty = set()
for f in dirty_files:
if os.path.sep in f:
mod, _ = f.split(os.path.sep, 1)
if not os.path.exists(os.path.join(mod, 'Dockerfile')):
continue
if not os.path.exists(os.path.join(mod, 'build.yml')):
continue
dirty.add(mod)
# if len(dirty) > 5:
# LOG.error('Max number of changed modules exceded.',
# 'Please break up the patch set until a maximum of 5 modules are changed.')
# sys.exit(1)
return list(dirty)
def get_dirty_for_module(files, module=None):
ret = []
for f in files:
if os.path.sep in f:
mod, rel_path = f.split(os.path.sep, 1)
if mod == module:
ret.append(rel_path)
else:
# top-level file, no module
if module is None:
ret.append(f)
return ret
def run_build(modules):
log_dir = BUILD_LOG_DIR
build_args = ['dbuild', '-sd', '--build-log-dir', log_dir, 'build', 'all', '+', ':ci-cd'] + modules
LOG.debug('Executing build command: {0}\n'.format(' '.join(build_args)))
p = subprocess.Popen(build_args, stdout=subprocess.PIPE, universal_newlines=True)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
start_time = datetime.datetime.now()
while True:
output = p.stdout.readline()
print(" " + output.strip())
return_code = p.poll()
if return_code is not None:
LOG.debug('Return code: {0}'.format(return_code))
if return_code != 0:
LOG.error('BUILD FAILED !!!')
raise BuildFailedException('Build failed')
if return_code == 0:
LOG.info('Build succeeded')
# Process has finished, read rest of the output
for output in p.stdout.readlines():
LOG.debug(output.strip())
break
end_time = start_time + datetime.timedelta(minutes=BUILD_TIMEOUT)
if datetime.datetime.now() >= end_time:
LOG.error('BUILD TIMEOUT AFTER {0} MIN !!!'.format(BUILD_TIMEOUT))
p.kill()
raise BuildFailedException('Build timeout')
def run_push(modules, pipeline):
if ci_branch != 'master':
LOG.warn('Push images to Docker Hub is only allowed from master branch')
return
if pipeline == 'logs':
LOG.info('Images are already pushed by metrics-pipeline, skipping!')
return
username = os.environ.get('DOCKER_HUB_USERNAME', None)
password = os.environ.get('DOCKER_HUB_PASSWORD', None)
if not password:
LOG.info('Not DOCKER_HUB_PASSWORD, skipping!')
LOG.info('Not pushing: {0}'.format(modules))
return
if username and password:
LOG.info('Logging into docker registry...')
login = subprocess.Popen([
'docker', 'login',
'-u', username,
'--password-stdin'
], stdin=subprocess.PIPE)
login.communicate(password)
if login.returncode != 0:
LOG.error('Docker registry login failed, cannot push!')
sys.exit(1)
log_dir = BUILD_LOG_DIR
push_args = ['dbuild', '-sd', '--build-log-dir', log_dir, 'build', 'push', 'all'] + modules
LOG.debug('Executing push command: {0}\n'.format(' '.join(push_args)))
p = subprocess.Popen(push_args)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
if p.wait() != 0:
LOG.error('PUSH FAILED !!!')
sys.exit(p.returncode)
def run_readme(modules):
if ci_branch != 'master':
LOG.warn('Update readme to Docker Hub is only allowed from master branch')
return
log_dir = BUILD_LOG_DIR
readme_args = ['dbuild', '-sd', '--build-log-dir', log_dir, 'readme'] + modules
LOG.debug('Executing readme command: {0}\n'.format(' '.join(readme_args)))
p = subprocess.Popen(readme_args)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
if p.wait() != 0:
LOG.error('README FAILED !!!')
sys.exit(p.returncode)
def update_docker_compose(modules, pipeline):
compose_dict = load_yml(PIPELINE_TO_YAML_COMPOSE['metrics'])
services_to_changes = METRIC_PIPELINE_MODULE_TO_COMPOSE_SERVICES.copy()
if pipeline == 'logs':
LOG.info('\'logs\' pipeline is enabled, including in CI run')
log_compose = load_yml(PIPELINE_TO_YAML_COMPOSE['logs'])
compose_dict['services'].update(log_compose['services'])
services_to_changes.update(
LOGS_PIPELINE_MODULE_TO_COMPOSE_SERVICES.copy()
)
if modules:
compose_services = compose_dict['services']
for module in modules:
# Not all modules are included in docker compose
if module not in services_to_changes:
continue
service_name = services_to_changes[module]
services_to_update = service_name.split(',')
for service in services_to_update:
image = compose_services[service]['image']
image = image.split(':')[0]
image += ":ci-cd"
compose_services[service]['image'] = image
# Update compose version
compose_dict['version'] = '2'
LOG.debug("Displaying {0}\n\n{1}".format(CI_COMPOSE_FILE, yaml.dump(compose_dict, default_flow_style=False)))
try:
with open(CI_COMPOSE_FILE, 'w') as docker_compose:
yaml.dump(compose_dict, docker_compose, default_flow_style=False)
except:
raise FileWriteException(
'Error writing CI dictionary to {0}'.format(CI_COMPOSE_FILE)
)
def load_yml(yml_path):
try:
with open(yml_path) as compose_file:
compose_dict = yaml.safe_load(compose_file)
return compose_dict
except:
raise FileReadException('Failed to read {0}'.format(yml_path))
def handle_pull_request(files, modules, tags, pipeline):
modules_to_build = modules[:]
for tag, arg in tags:
if tag in ('build', 'push'):
if arg is None:
# arg-less doesn't make sense for PRs since any changes to a
# module already result in a rebuild
continue
modules_to_build.append(arg)
# note(kornicameister) check if module belong to the pipeline
# if not, there's no point of building that as it will be build
# for the given pipeline
pipeline_modules = pick_modules_for_pipeline(modules_to_build, pipeline)
if pipeline_modules:
run_build(pipeline_modules)
else:
LOG.info('No modules to build.')
update_docker_compose(pipeline_modules, pipeline)
run_docker_keystone()
run_docker_compose(pipeline)
wait_for_init_jobs(pipeline)
LOG.info('Waiting for containers to be ready 1 min...')
time.sleep(60)
output_docker_ps()
cool_test_mapper = {
'smoke': {
METRIC_PIPELINE_MARKER: run_smoke_tests_metrics,
LOG_PIPELINE_MARKER: lambda : LOG.info('No smoke tests for logs')
},
'tempest': {
METRIC_PIPELINE_MARKER: run_tempest_tests_metrics,
LOG_PIPELINE_MARKER: lambda : LOG.info('No tempest tests for logs')
}
}
cool_test_mapper['smoke'][pipeline]()
cool_test_mapper['tempest'][pipeline]()
def pick_modules_for_pipeline(modules, pipeline):
if not modules:
return []
modules_for_pipeline = {
LOG_PIPELINE_MARKER: LOGS_PIPELINE_MODULE_TO_COMPOSE_SERVICES.keys(),
METRIC_PIPELINE_MARKER: METRIC_PIPELINE_MODULE_TO_COMPOSE_SERVICES.keys()
}
pipeline_modules = modules_for_pipeline[pipeline]
# some of the modules are not used in pipelines, but should be
# taken into consideration during the build
other_modules = [
'storm'
]
LOG.info('Modules to build: {0}'.format(modules))
LOG.info('Modules to pull: {0}'.format(pipeline_modules))
# iterate over copy of all modules that are planned for the build
# if one of them does not belong to active pipeline
# remove from current run
for m in modules[::]:
if m not in pipeline_modules:
if m in other_modules:
LOG.info('Module {0} is not part of either pipeline, but it will be build anyway'.format(m))
continue
LOG.info('Module {0} does not belong to {1}, skipping'.format(m, pipeline))
modules.remove(m)
return modules
def get_current_init_status(docker_id):
init_status = ['docker', 'inspect', '-f', '{{ .State.ExitCode }}:{{ .State.Status }}', docker_id]
p = subprocess.Popen(init_status, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
output, err = p.communicate()
if six.PY3:
output = output.decode('utf-8')
if p.wait() != 0:
LOG.info('getting current status failed')
return False
status_output = output.rstrip()
exit_code, status = status_output.split(":", 1)
LOG.debug('Status from init-container {0}, exit_code {1}, status {2}'.format(docker_id, exit_code, status))
return exit_code == "0" and status == "exited"
def output_docker_logs():
LOG.info("Saving container logs at {0}".format(LOG_DIR))
docker_names = ['docker', 'ps', '-a', '--format', '"{{.Names}}"']
LOG.debug('Executing: {0}'.format(' '.join(docker_names)))
p = subprocess.Popen(docker_names, stdout=subprocess.PIPE)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
output, err = p.communicate()
if six.PY3:
output = output.decode('utf-8')
names = output.replace('"', '').split('\n')
for name in names:
if not name:
continue
docker_logs = ['docker', 'logs', '-t', name]
log_name = RUN_LOG_DIR + 'docker_log_' + name + '.log'
LOG.debug('Executing: {0}'.format(' '.join(docker_logs)))
with open(log_name, 'w') as out:
p = subprocess.Popen(docker_logs, stdout=out,
stderr=subprocess.STDOUT)
signal.signal(signal.SIGINT, kill)
if p.wait() != 0:
LOG.error('Error running docker log for {0}'.format(name))
def addtab(s):
white = " " * 2
return white + white.join(s.splitlines(1))
def output_docker_ps():
docker_ps = ['docker', 'ps', '-a']
LOG.debug('Executing: {0}'.format(' '.join(docker_ps)))
p = subprocess.Popen(docker_ps, stdout=subprocess.PIPE)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
output, err = p.communicate()
if six.PY3:
output = output.decode('utf-8')
LOG.info("Displaying all docker containers\n" + addtab(output))
def output_compose_details(pipeline):
if pipeline == 'metrics':
services = METRIC_PIPELINE_SERVICES
else:
services = LOG_PIPELINE_SERVICES
if six.PY3:
services = list(services)
LOG.info('All services that are about to start: {0}'.format(', '.join(services)))
def get_docker_id(init_job):
docker_id = ['docker-compose',
'-f', CI_COMPOSE_FILE,
'ps',
'-q', init_job]
p = subprocess.Popen(docker_id, stdout=subprocess.PIPE)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
output, err = p.communicate()
if six.PY3:
output = output.decode('utf-8')
if p.wait() != 0:
LOG.error('error getting docker id')
return ""
return output.rstrip()
def wait_for_init_jobs(pipeline):
LOG.info('Waiting 20 sec for init jobs to finish...')
init_status_dict = {job: False for job in INIT_JOBS[pipeline]}
docker_id_dict = {job: "" for job in INIT_JOBS[pipeline]}
amount_succeeded = 0
for attempt in range(INITJOBS_ATTEMPS):
time.sleep(20)
amount_succeeded = 0
for init_job, status in init_status_dict.items():
if docker_id_dict[init_job] == "":
docker_id_dict[init_job] = get_docker_id(init_job)
if status:
amount_succeeded += 1
else:
updated_status = get_current_init_status(docker_id_dict[init_job])
init_status_dict[init_job] = updated_status
if updated_status:
amount_succeeded += 1
if amount_succeeded == len(docker_id_dict):
LOG.info("All init-jobs finished successfully !!!")
break
else:
LOG.info("Not all init jobs have finished yet, waiting another 20 sec. " +
"Try " + str(attempt + 1) + " of {0}...".format(INITJOBS_ATTEMPS))
if amount_succeeded != len(docker_id_dict):
LOG.error("INIT-JOBS FAILED !!!")
raise InitJobFailedException("Not all init-containers finished with exit code 0")
def handle_push(files, modules, tags, pipeline):
modules_to_push = []
modules_to_readme = []
force_push = False
force_readme = False
for tag, arg in tags:
if tag in ('build', 'push'):
if arg is None:
force_push = True
else:
modules_to_push.append(arg)
elif tag == 'readme':
if arg is None:
force_readme = True
else:
modules_to_readme.append(arg)
for module in modules:
dirty = get_dirty_for_module(files, module)
if force_push or 'build.yml' in dirty:
modules_to_push.append(module)
if force_readme or 'README.md' in dirty:
modules_to_readme.append(module)
if modules_to_push:
run_push(modules_to_push, pipeline)
else:
LOG.info('No modules to push.')
if modules_to_readme:
run_readme(modules_to_readme)
else:
LOG.info('No READMEs to update.')
def run_docker_keystone():
LOG.info('Running docker compose for Keystone')
username = os.environ.get('DOCKER_HUB_USERNAME', None)
password = os.environ.get('DOCKER_HUB_PASSWORD', None)
if username and password:
LOG.info('Logging into docker registry...')
login = subprocess.Popen([
'docker', 'login',
'-u', username,
'--password-stdin'
], stdin=subprocess.PIPE)
login.communicate(password)
if login.returncode != 0:
LOG.error('Docker registry login failed!')
sys.exit(1)
docker_compose_dev_command = ['docker-compose',
'-f', 'docker-compose-dev.yml',
'up', '-d']
LOG.debug('Executing: {0}'.format(' '.join(docker_compose_dev_command)))
with open(RUN_LOG_DIR + 'docker_compose_dev.log', 'w') as out:
p = subprocess.Popen(docker_compose_dev_command, stdout=out)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
if p.wait() != 0:
LOG.error('DOCKER COMPOSE FAILED !!!')
sys.exit(p.returncode)
# print out running images for debugging purposes
LOG.info('docker compose dev succeeded')
output_docker_ps()
def run_docker_compose(pipeline):
LOG.info('Running docker compose')
output_compose_details(pipeline)
username = os.environ.get('DOCKER_HUB_USERNAME', None)
password = os.environ.get('DOCKER_HUB_PASSWORD', None)
if username and password:
LOG.info('Logging into docker registry...')
login = subprocess.Popen([
'docker', 'login',
'-u', username,
'--password-stdin'
], stdin=subprocess.PIPE)
login.communicate(password)
if login.returncode != 0:
LOG.error('Docker registry login failed!')
sys.exit(1)
if pipeline == 'metrics':
services = METRIC_PIPELINE_SERVICES
else:
services = LOG_PIPELINE_SERVICES
if six.PY3:
services = list(services)
docker_compose_command = ['docker-compose',
'-f', CI_COMPOSE_FILE,
'up', '-d'] + services
LOG.debug('Executing: {0}'.format(' '.join(docker_compose_command)))
with open(RUN_LOG_DIR + 'docker_compose.log', 'w') as out:
p = subprocess.Popen(docker_compose_command, stdout=out)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
if p.wait() != 0:
LOG.error('DOCKER COMPOSE FAILED !!!')
sys.exit(p.returncode)
# print out running images for debugging purposes
LOG.info('docker compose succeeded')
output_docker_ps()
def run_smoke_tests_metrics():
LOG.info('Running Smoke-tests')
#TODO: branch as variable... use TRAVIS_PULL_REQUEST_BRANCH ?
smoke_tests_run = ['docker', 'run',
'-e', 'OS_AUTH_URL=http://keystone:35357/v3',
'-e', 'MONASCA_URL=http://monasca:8070',
'-e', 'METRIC_NAME_TO_CHECK=monasca.thread_count',
'--net', 'monasca-docker_default',
'-p', '0.0.0.0:8080:8080',
'--name', 'monasca-docker-smoke',
'fest/smoke-tests:pike-latest']
LOG.debug('Executing: {0}'.format(' '.join(smoke_tests_run)))
p = subprocess.Popen(smoke_tests_run)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
if p.wait() != 0:
LOG.error('SMOKE-TEST FAILED !!!')
raise SmokeTestFailedException("Smoke Tests Failed")
def run_tempest_tests_metrics():
LOG.info('Running Tempest-tests')
return
tempest_tests_run = ['docker', 'run',
'-e', 'KEYSTONE_IDENTITY_URI=http://keystone:35357',
'-e', 'OS_AUTH_URL=http://keystone:35357/v3',
'-e', 'MONASCA_WAIT_FOR_API=true',
'-e', 'STAY_ALIVE_ON_FAILURE=false',
'--net', 'monasca-docker_default',
'--name', 'monasca-docker-tempest',
'chaconpiza/tempest-tests:test']
LOG.debug('Executing: {0}'.format(' '.join(tempest_tests_run)))
p = subprocess.Popen(tempest_tests_run, stdout=subprocess.PIPE, universal_newlines=True)
def kill(signal, frame):
p.kill()
LOG.warn('Finished by Ctrl-c!')
sys.exit(2)
signal.signal(signal.SIGINT, kill)
start_time = datetime.datetime.now()
while True:
output = p.stdout.readline()
LOG.info(output.strip())
return_code = p.poll()
if return_code is not None:
LOG.debug('RETURN CODE: {0}'.format(return_code))
if return_code != 0:
LOG.error('TEMPEST-TEST FAILED !!!')
raise TempestTestFailedException("Tempest Tests finished but some tests failed")
if return_code == 0:
LOG.info('Tempest-tests succeeded')
# Process has finished, read rest of the output
for output in p.stdout.readlines():
LOG.debug(output.strip())
break
end_time = start_time + datetime.timedelta(minutes=TEMPEST_TIMEOUT)
if datetime.datetime.now() >= end_time:
LOG.error('TEMPEST-TEST TIMEOUT AFTER {0} MIN !!!'.format(TEMPEST_TIMEOUT))
p.kill()
raise TempestTestFailedException("Tempest Tests failed by timeout")
def handle_other(files, modules, tags, pipeline):
LOG.error('Unsupported event type: {0}, nothing to do.'.format(ci_event_type))
exit(2)
def print_env():
env_vars_used = ['pipeline={0}'.format(pipeline),
'non_voting={0}'.format(non_voting),
'printlogs={0}'.format(printlogs),
'verbose={0}'.format(verbose),
'CI_BRANCH="{0}"'.format(ci_branch),
'CI_EVENT_TYPE="{0}"'.format(ci_event_type),
'CI_COMMIT_RANGE="{0}"'.format(ci_commit_range)
]
LOG.info('Variables used in CI:\n {0}'.format('\n '.join(env_vars_used)))
def main():
try:
LOG.info("DOCKER_HUB_USERNAME: {0}".format(os.environ.get('DOCKER_HUB_USERNAME', None)))
LOG.info("DOCKER_HUB_PASSWORD: {0}".format(os.environ.get('DOCKER_HUB_PASSWORD', None)))
print_env()
if not pipeline or pipeline not in ('logs', 'metrics'):
LOG.error('UNKNOWN PIPELINE: {0} !!! Choose (metrics|logs)'.format(pipeline))
exit(2)
set_log_dir()
files = get_changed_files()
LOG.info('Changed files: {0}'.format(files))
modules = get_dirty_modules(files)
LOG.info('Dirty modules: {0}'.format(modules))
tags = get_message_tags()
LOG.info('Message tags: {0}'.format(tags))
if tags:
LOG.debug('Tags detected:')
for tag in tags:
LOG.debug(' '.format(tag))
else:
LOG.info('No tags detected.')
func = {
'cron': handle_pull_request,
'pull_request': handle_pull_request,
'push': handle_push
}.get(ci_event_type, handle_other)
func(files, modules, tags, pipeline)
except (FileReadException, FileWriteException, SubprocessException) as ex:
LOG.error("FAILED !!! RCA: {0}".format(ex))
exit(1)
except (InitJobFailedException, SmokeTestFailedException,
TempestTestFailedException) as ex:
if non_voting:
LOG.warn('{0} is non voting, skipping failure'.format(pipeline))
else:
LOG.error("FAILED !!! RCA: {0}".format(ex))
exit(1)
except Exception as ex:
LOG.error("UNKNOWN EXCEPTION !!! RCA: {0}".format(ex))
exit(1)
finally:
output_docker_ps()
output_docker_logs()
if printlogs:
print_logs()
if __name__ == '__main__':
main()
|
[] |
[] |
[
"DOCKER_HUB_USERNAME",
"CI_BRANCH",
"DOCKER_HUB_PASSWORD",
"CI_COMMIT_RANGE",
"CI_EVENT_TYPE"
] |
[]
|
["DOCKER_HUB_USERNAME", "CI_BRANCH", "DOCKER_HUB_PASSWORD", "CI_COMMIT_RANGE", "CI_EVENT_TYPE"]
|
python
| 5 | 0 | |
appengine_module/gae_ts_mon/test/instrument_webapp2_test.py
|
# Copyright 2019 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import os
import mock
import webapp2
from .test_support import test_case
from google.appengine.api.runtime import runtime
from infra_libs.ts_mon import config
from infra_libs.ts_mon import instrument_webapp2
from infra_libs.ts_mon.common import http_metrics
from infra_libs.ts_mon.common import interface
from infra_libs.ts_mon.common import targets
class InstrumentWebapp2Test(test_case.TestCase):
def setUp(self):
super(InstrumentWebapp2Test, self).setUp()
config.reset_for_unittest()
self.next_time = 42.0
self.time_increment = 3.0
def fake_time(self):
ret = self.next_time
self.next_time += self.time_increment
return ret
def test_instrument_webapp2_invoked_multiple_times(self):
class Handler(webapp2.RequestHandler):
def get(self):
self.response.write('success!')
app = webapp2.WSGIApplication([('/', Handler)])
self.assertFalse(instrument_webapp2._is_instrumented(app))
instrument_webapp2.instrument(app, time_fn=self.fake_time)
self.assertTrue(instrument_webapp2._is_instrumented(app))
instrument_webapp2.instrument(app, time_fn=self.fake_time)
self.assertTrue(instrument_webapp2._is_instrumented(app))
# trigger a test page handler and check if the value of the HTTP metric
# didn't increase twice.
app.get_response('/')
fields = {'name': '^/$', 'status': 200, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_success(self):
class Handler(webapp2.RequestHandler):
def get(self):
self.response.write('success!')
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app, time_fn=self.fake_time)
app.get_response('/')
fields = {'name': '^/$', 'status': 200, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
self.assertLessEqual(3000, http_metrics.server_durations.get(fields).sum)
self.assertEqual(
len('success!'),
http_metrics.server_response_bytes.get(fields).sum)
def test_abort(self):
class Handler(webapp2.RequestHandler):
def get(self):
self.abort(417)
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/')
fields = {'name': '^/$', 'status': 417, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_set_status(self):
class Handler(webapp2.RequestHandler):
def get(self):
self.response.set_status(418)
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/')
fields = {'name': '^/$', 'status': 418, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_exception(self):
class Handler(webapp2.RequestHandler):
def get(self):
raise ValueError
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/')
fields = {'name': '^/$', 'status': 500, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_http_exception(self):
class Handler(webapp2.RequestHandler):
def get(self):
raise webapp2.exc.HTTPExpectationFailed()
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/')
fields = {'name': '^/$', 'status': 417, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_return_response(self):
class Handler(webapp2.RequestHandler):
def get(self):
ret = webapp2.Response()
ret.set_status(418)
return ret
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/')
fields = {'name': '^/$', 'status': 418, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_robot(self):
class Handler(webapp2.RequestHandler):
def get(self):
ret = webapp2.Response()
ret.set_status(200)
return ret
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/', user_agent='GoogleBot')
fields = {'name': '^/$', 'status': 200, 'is_robot': True}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_missing_response_content_length(self):
class Handler(webapp2.RequestHandler):
def get(self):
del self.response.headers['content-length']
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/')
fields = {'name': '^/$', 'status': 200, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
self.assertIsNone(http_metrics.server_response_bytes.get(fields))
def test_not_found(self):
app = webapp2.WSGIApplication([])
instrument_webapp2.instrument(app)
app.get_response('/notfound')
fields = {'name': '', 'status': 404, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
def test_post(self):
class Handler(webapp2.RequestHandler):
def post(self):
pass
app = webapp2.WSGIApplication([('/', Handler)])
instrument_webapp2.instrument(app)
app.get_response('/', POST='foo')
fields = {'name': '^/$', 'status': 200, 'is_robot': False}
self.assertEqual(1, http_metrics.server_response_status.get(fields))
self.assertEqual(
len('foo'),
http_metrics.server_request_bytes.get(fields).sum)
class TaskNumAssignerHandlerTest(test_case.TestCase):
def setUp(self):
super(TaskNumAssignerHandlerTest, self).setUp()
config.reset_for_unittest()
target = targets.TaskTarget('test_service', 'test_job', 'test_region',
'test_host')
self.mock_state = interface.State(target=target)
# Workaround the fact that 'system' module is not mocked.
class _memory_usage(object):
def current(self):
return 10.0
env = os.environ.copy()
env['SERVER_SOFTWARE'] = 'PRODUCTION'
self.mock(runtime, 'memory_usage', _memory_usage)
self.mock(os, 'environ', env)
self.app = instrument_webapp2.create_app()
instrument_webapp2.instrument(self.app)
def tearDown(self):
mock.patch.stopall()
super(TaskNumAssignerHandlerTest, self).tearDown()
def test_success(self):
response = self.app.get_response(
'/internal/cron/ts_mon/send', headers=[('X-Appengine-Cron', 'true')])
self.assertEqual(response.status_int, 200)
def test_unauthorized(self):
response = self.app.get_response('/internal/cron/ts_mon/send')
self.assertEqual(response.status_int, 403)
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
youtube_dl/YoutubeDL.py
|
#!/usr/bin/env python
# coding: utf-8
from __future__ import absolute_import, unicode_literals
import collections
import contextlib
import copy
import datetime
import errno
import fileinput
import io
import itertools
import json
import locale
import operator
import os
import platform
import re
import shutil
import subprocess
import socket
import sys
import time
import tokenize
import traceback
import random
from string import ascii_letters
from .compat import (
compat_basestring,
compat_cookiejar,
compat_get_terminal_size,
compat_http_client,
compat_kwargs,
compat_numeric_types,
compat_os_name,
compat_str,
compat_tokenize_tokenize,
compat_urllib_error,
compat_urllib_request,
compat_urllib_request_DataHandler,
)
from .utils import (
age_restricted,
args_to_str,
ContentTooShortError,
date_from_str,
DateRange,
DEFAULT_OUTTMPL,
determine_ext,
determine_protocol,
DownloadError,
encode_compat_str,
encodeFilename,
error_to_compat_str,
expand_path,
ExtractorError,
format_bytes,
formatSeconds,
GeoRestrictedError,
int_or_none,
ISO3166Utils,
locked_file,
make_HTTPS_handler,
MaxDownloadsReached,
orderedSet,
PagedList,
parse_filesize,
PerRequestProxyHandler,
platform_name,
PostProcessingError,
preferredencoding,
prepend_extension,
register_socks_protocols,
render_table,
replace_extension,
SameFileError,
sanitize_filename,
sanitize_path,
sanitize_url,
sanitized_Request,
std_headers,
str_or_none,
subtitles_filename,
UnavailableVideoError,
url_basename,
version_tuple,
write_json_file,
write_string,
YoutubeDLCookieJar,
YoutubeDLCookieProcessor,
YoutubeDLHandler,
YoutubeDLRedirectHandler,
)
from .cache import Cache
from .extractor import get_info_extractor, gen_extractor_classes, _LAZY_LOADER
from .extractor.openload import PhantomJSwrapper
from .downloader import get_suitable_downloader
from .downloader.rtmp import rtmpdump_version
from .postprocessor import (
FFmpegFixupM3u8PP,
FFmpegFixupM4aPP,
FFmpegFixupStretchedPP,
FFmpegMergerPP,
FFmpegPostProcessor,
get_postprocessor,
)
from .version import __version__
if compat_os_name == 'nt':
import ctypes
class YoutubeDL(object):
"""YoutubeDL class.
YoutubeDL objects are the ones responsible of downloading the
actual video file and writing it to disk if the user has requested
it, among some other tasks. In most cases there should be one per
program. As, given a video URL, the downloader doesn't know how to
extract all the needed information, task that InfoExtractors do, it
has to pass the URL to one of them.
For this, YoutubeDL objects have a method that allows
InfoExtractors to be registered in a given order. When it is passed
a URL, the YoutubeDL object handles it to the first InfoExtractor it
finds that reports being able to handle it. The InfoExtractor extracts
all the information about the video or videos the URL refers to, and
YoutubeDL process the extracted information, possibly using a File
Downloader to download the video.
YoutubeDL objects accept a lot of parameters. In order not to saturate
the object constructor with arguments, it receives a dictionary of
options instead. These options are available through the params
attribute for the InfoExtractors to use. The YoutubeDL also
registers itself as the downloader in charge for the InfoExtractors
that are added to it, so this is a "mutual registration".
Available options:
username: Username for authentication purposes.
password: Password for authentication purposes.
videopassword: Password for accessing a video.
ap_mso: Adobe Pass multiple-system operator identifier.
ap_username: Multiple-system operator account username.
ap_password: Multiple-system operator account password.
usenetrc: Use netrc for authentication instead.
verbose: Print additional info to stdout.
quiet: Do not print messages to stdout.
no_warnings: Do not print out anything for warnings.
forceurl: Force printing final URL.
forcetitle: Force printing title.
forceid: Force printing ID.
forcethumbnail: Force printing thumbnail URL.
forcedescription: Force printing description.
forcefilename: Force printing final filename.
forceduration: Force printing duration.
forcejson: Force printing info_dict as JSON.
dump_single_json: Force printing the info_dict of the whole playlist
(or video) as a single JSON line.
simulate: Do not download the video files.
format: Video format code. See options.py for more information.
outtmpl: Template for output names.
outtmpl_na_placeholder: Placeholder for unavailable meta fields.
restrictfilenames: Do not allow "&" and spaces in file names
ignoreerrors: Do not stop on download errors.
force_generic_extractor: Force downloader to use the generic extractor
nooverwrites: Prevent overwriting files.
playliststart: Playlist item to start at.
playlistend: Playlist item to end at.
playlist_items: Specific indices of playlist to download.
playlistreverse: Download playlist items in reverse order.
playlistrandom: Download playlist items in random order.
matchtitle: Download only matching titles.
rejecttitle: Reject downloads for matching titles.
logger: Log messages to a logging.Logger instance.
logtostderr: Log messages to stderr instead of stdout.
writedescription: Write the video description to a .description file
writeinfojson: Write the video description to a .info.json file
writeannotations: Write the video annotations to a .annotations.xml file
writethumbnail: Write the thumbnail image to a file
write_all_thumbnails: Write all thumbnail formats to files
writesubtitles: Write the video subtitles to a file
writeautomaticsub: Write the automatically generated subtitles to a file
allsubtitles: Downloads all the subtitles of the video
(requires writesubtitles or writeautomaticsub)
listsubtitles: Lists all available subtitles for the video
subtitlesformat: The format code for subtitles
subtitleslangs: List of languages of the subtitles to download
keepvideo: Keep the video file after post-processing
daterange: A DateRange object, download only if the upload_date is in the range.
skip_download: Skip the actual download of the video file
cachedir: Location of the cache files in the filesystem.
False to disable filesystem cache.
noplaylist: Download single video instead of a playlist if in doubt.
age_limit: An integer representing the user's age in years.
Unsuitable videos for the given age are skipped.
min_views: An integer representing the minimum view count the video
must have in order to not be skipped.
Videos without view count information are always
downloaded. None for no limit.
max_views: An integer representing the maximum view count.
Videos that are more popular than that are not
downloaded.
Videos without view count information are always
downloaded. None for no limit.
download_archive: File name of a file where all downloads are recorded.
Videos already present in the file are not downloaded
again.
cookiefile: File name where cookies should be read from and dumped to.
nocheckcertificate:Do not verify SSL certificates
prefer_insecure: Use HTTP instead of HTTPS to retrieve information.
At the moment, this is only supported by YouTube.
proxy: URL of the proxy server to use
geo_verification_proxy: URL of the proxy to use for IP address verification
on geo-restricted sites.
socket_timeout: Time to wait for unresponsive hosts, in seconds
bidi_workaround: Work around buggy terminals without bidirectional text
support, using fridibi
debug_printtraffic:Print out sent and received HTTP traffic
include_ads: Download ads as well
default_search: Prepend this string if an input url is not valid.
'auto' for elaborate guessing
encoding: Use this encoding instead of the system-specified.
extract_flat: Do not resolve URLs, return the immediate result.
Pass in 'in_playlist' to only show this behavior for
playlist items.
postprocessors: A list of dictionaries, each with an entry
* key: The name of the postprocessor. See
youtube_dl/postprocessor/__init__.py for a list.
as well as any further keyword arguments for the
postprocessor.
progress_hooks: A list of functions that get called on download
progress, with a dictionary with the entries
* status: One of "downloading", "error", or "finished".
Check this first and ignore unknown values.
If status is one of "downloading", or "finished", the
following properties may also be present:
* filename: The final filename (always present)
* tmpfilename: The filename we're currently writing to
* downloaded_bytes: Bytes on disk
* total_bytes: Size of the whole file, None if unknown
* total_bytes_estimate: Guess of the eventual file size,
None if unavailable.
* elapsed: The number of seconds since download started.
* eta: The estimated time in seconds, None if unknown
* speed: The download speed in bytes/second, None if
unknown
* fragment_index: The counter of the currently
downloaded video fragment.
* fragment_count: The number of fragments (= individual
files that will be merged)
Progress hooks are guaranteed to be called at least once
(with status "finished") if the download is successful.
merge_output_format: Extension to use when merging formats.
fixup: Automatically correct known faults of the file.
One of:
- "never": do nothing
- "warn": only emit a warning
- "detect_or_warn": check whether we can do anything
about it, warn otherwise (default)
source_address: Client-side IP address to bind to.
call_home: Boolean, true iff we are allowed to contact the
youtube-dl servers for debugging.
sleep_interval: Number of seconds to sleep before each download when
used alone or a lower bound of a range for randomized
sleep before each download (minimum possible number
of seconds to sleep) when used along with
max_sleep_interval.
max_sleep_interval:Upper bound of a range for randomized sleep before each
download (maximum possible number of seconds to sleep).
Must only be used along with sleep_interval.
Actual sleep time will be a random float from range
[sleep_interval; max_sleep_interval].
listformats: Print an overview of available video formats and exit.
list_thumbnails: Print a table of all thumbnails and exit.
match_filter: A function that gets called with the info_dict of
every video.
If it returns a message, the video is ignored.
If it returns None, the video is downloaded.
match_filter_func in utils.py is one example for this.
no_color: Do not emit color codes in output.
geo_bypass: Bypass geographic restriction via faking X-Forwarded-For
HTTP header
geo_bypass_country:
Two-letter ISO 3166-2 country code that will be used for
explicit geographic restriction bypassing via faking
X-Forwarded-For HTTP header
geo_bypass_ip_block:
IP range in CIDR notation that will be used similarly to
geo_bypass_country
The following options determine which downloader is picked:
external_downloader: Executable of the external downloader to call.
None or unset for standard (built-in) downloader.
hls_prefer_native: Use the native HLS downloader instead of ffmpeg/avconv
if True, otherwise use ffmpeg/avconv if False, otherwise
use downloader suggested by extractor if None.
The following parameters are not used by YoutubeDL itself, they are used by
the downloader (see youtube_dl/downloader/common.py):
nopart, updatetime, buffersize, ratelimit, min_filesize, max_filesize, test,
noresizebuffer, retries, continuedl, noprogress, consoletitle,
xattr_set_filesize, external_downloader_args, hls_use_mpegts,
http_chunk_size.
The following options are used by the post processors:
prefer_ffmpeg: If False, use avconv instead of ffmpeg if both are available,
otherwise prefer ffmpeg.
ffmpeg_location: Location of the ffmpeg/avconv binary; either the path
to the binary or its containing directory.
postprocessor_args: A list of additional command-line arguments for the
postprocessor.
The following options are used by the Youtube extractor:
youtube_include_dash_manifest: If True (default), DASH manifests and related
data will be downloaded and processed by extractor.
You can reduce network I/O by disabling it if you don't
care about DASH.
"""
_NUMERIC_FIELDS = set((
'width', 'height', 'tbr', 'abr', 'asr', 'vbr', 'fps', 'filesize', 'filesize_approx',
'timestamp', 'upload_year', 'upload_month', 'upload_day',
'duration', 'view_count', 'like_count', 'dislike_count', 'repost_count',
'average_rating', 'comment_count', 'age_limit',
'start_time', 'end_time',
'chapter_number', 'season_number', 'episode_number',
'track_number', 'disc_number', 'release_year',
'playlist_index',
))
params = None
_ies = []
_pps = []
_download_retcode = None
_num_downloads = None
_playlist_level = 0
_playlist_urls = set()
_screen_file = None
def __init__(self, params=None, auto_init=True):
"""Create a FileDownloader object with the given options."""
if params is None:
params = {}
self._ies = []
self._ies_instances = {}
self._pps = []
self._progress_hooks = []
self._download_retcode = 0
self._num_downloads = 0
self._screen_file = [sys.stdout, sys.stderr][params.get('logtostderr', False)]
self._err_file = sys.stderr
self.params = {
# Default parameters
'nocheckcertificate': False,
}
self.params.update(params)
self.cache = Cache(self)
def check_deprecated(param, option, suggestion):
if self.params.get(param) is not None:
self.report_warning(
'%s is deprecated. Use %s instead.' % (option, suggestion))
return True
return False
if check_deprecated('cn_verification_proxy', '--cn-verification-proxy', '--geo-verification-proxy'):
if self.params.get('geo_verification_proxy') is None:
self.params['geo_verification_proxy'] = self.params['cn_verification_proxy']
check_deprecated('autonumber_size', '--autonumber-size', 'output template with %(autonumber)0Nd, where N in the number of digits')
check_deprecated('autonumber', '--auto-number', '-o "%(autonumber)s-%(title)s.%(ext)s"')
check_deprecated('usetitle', '--title', '-o "%(title)s-%(id)s.%(ext)s"')
if params.get('bidi_workaround', False):
try:
import pty
master, slave = pty.openpty()
width = compat_get_terminal_size().columns
if width is None:
width_args = []
else:
width_args = ['-w', str(width)]
sp_kwargs = dict(
stdin=subprocess.PIPE,
stdout=slave,
stderr=self._err_file)
try:
self._output_process = subprocess.Popen(
['bidiv'] + width_args, **sp_kwargs
)
except OSError:
self._output_process = subprocess.Popen(
['fribidi', '-c', 'UTF-8'] + width_args, **sp_kwargs)
self._output_channel = os.fdopen(master, 'rb')
except OSError as ose:
if ose.errno == errno.ENOENT:
self.report_warning('Could not find fribidi executable, ignoring --bidi-workaround . Make sure that fribidi is an executable file in one of the directories in your $PATH.')
else:
raise
if (sys.platform != 'win32'
and sys.getfilesystemencoding() in ['ascii', 'ANSI_X3.4-1968']
and not params.get('restrictfilenames', False)):
# Unicode filesystem API will throw errors (#1474, #13027)
self.report_warning(
'Assuming --restrict-filenames since file system encoding '
'cannot encode all characters. '
'Set the LC_ALL environment variable to fix this.')
self.params['restrictfilenames'] = True
if isinstance(params.get('outtmpl'), bytes):
self.report_warning(
'Parameter outtmpl is bytes, but should be a unicode string. '
'Put from __future__ import unicode_literals at the top of your code file or consider switching to Python 3.x.')
self._setup_opener()
if auto_init:
self.print_debug_header()
self.add_default_info_extractors()
for pp_def_raw in self.params.get('postprocessors', []):
pp_class = get_postprocessor(pp_def_raw['key'])
pp_def = dict(pp_def_raw)
del pp_def['key']
pp = pp_class(self, **compat_kwargs(pp_def))
self.add_post_processor(pp)
for ph in self.params.get('progress_hooks', []):
self.add_progress_hook(ph)
register_socks_protocols()
def warn_if_short_id(self, argv):
# short YouTube ID starting with dash?
idxs = [
i for i, a in enumerate(argv)
if re.match(r'^-[0-9A-Za-z_-]{10}$', a)]
if idxs:
correct_argv = (
['youtube-dl']
+ [a for i, a in enumerate(argv) if i not in idxs]
+ ['--'] + [argv[i] for i in idxs]
)
self.report_warning(
'Long argument string detected. '
'Use -- to separate parameters and URLs, like this:\n%s\n' %
args_to_str(correct_argv))
def add_info_extractor(self, ie):
"""Add an InfoExtractor object to the end of the list."""
self._ies.append(ie)
if not isinstance(ie, type):
self._ies_instances[ie.ie_key()] = ie
ie.set_downloader(self)
def get_info_extractor(self, ie_key):
"""
Get an instance of an IE with name ie_key, it will try to get one from
the _ies list, if there's no instance it will create a new one and add
it to the extractor list.
"""
ie = self._ies_instances.get(ie_key)
if ie is None:
ie = get_info_extractor(ie_key)()
self.add_info_extractor(ie)
return ie
def add_default_info_extractors(self):
"""
Add the InfoExtractors returned by gen_extractors to the end of the list
"""
for ie in gen_extractor_classes():
self.add_info_extractor(ie)
def add_post_processor(self, pp):
"""Add a PostProcessor object to the end of the chain."""
self._pps.append(pp)
pp.set_downloader(self)
def add_progress_hook(self, ph):
"""Add the progress hook (currently only for the file downloader)"""
self._progress_hooks.append(ph)
def _bidi_workaround(self, message):
if not hasattr(self, '_output_channel'):
return message
assert hasattr(self, '_output_process')
assert isinstance(message, compat_str)
line_count = message.count('\n') + 1
self._output_process.stdin.write((message + '\n').encode('utf-8'))
self._output_process.stdin.flush()
res = ''.join(self._output_channel.readline().decode('utf-8')
for _ in range(line_count))
return res[:-len('\n')]
def to_screen(self, message, skip_eol=False):
"""Print message to stdout if not in quiet mode."""
return self.to_stdout(message, skip_eol, check_quiet=True)
def _write_string(self, s, out=None):
write_string(s, out=out, encoding=self.params.get('encoding'))
def to_stdout(self, message, skip_eol=False, check_quiet=False):
"""Print message to stdout if not in quiet mode."""
if self.params.get('logger'):
self.params['logger'].debug(message)
elif not check_quiet or not self.params.get('quiet', False):
message = self._bidi_workaround(message)
terminator = ['\n', ''][skip_eol]
output = message + terminator
self._write_string(output, self._screen_file)
def to_stderr(self, message):
"""Print message to stderr."""
assert isinstance(message, compat_str)
if self.params.get('logger'):
self.params['logger'].error(message)
else:
message = self._bidi_workaround(message)
output = message + '\n'
self._write_string(output, self._err_file)
def to_console_title(self, message):
if not self.params.get('consoletitle', False):
return
if compat_os_name == 'nt':
if ctypes.windll.kernel32.GetConsoleWindow():
# c_wchar_p() might not be necessary if `message` is
# already of type unicode()
ctypes.windll.kernel32.SetConsoleTitleW(ctypes.c_wchar_p(message))
elif 'TERM' in os.environ:
self._write_string('\033]0;%s\007' % message, self._screen_file)
def save_console_title(self):
if not self.params.get('consoletitle', False):
return
if self.params.get('simulate', False):
return
if compat_os_name != 'nt' and 'TERM' in os.environ:
# Save the title on stack
self._write_string('\033[22;0t', self._screen_file)
def restore_console_title(self):
if not self.params.get('consoletitle', False):
return
if self.params.get('simulate', False):
return
if compat_os_name != 'nt' and 'TERM' in os.environ:
# Restore the title from stack
self._write_string('\033[23;0t', self._screen_file)
def __enter__(self):
self.save_console_title()
return self
def __exit__(self, *args):
self.restore_console_title()
if self.params.get('cookiefile') is not None:
self.cookiejar.save(ignore_discard=True, ignore_expires=True)
def trouble(self, message=None, tb=None):
"""Determine action to take when a download problem appears.
Depending on if the downloader has been configured to ignore
download errors or not, this method may throw an exception or
not when errors are found, after printing the message.
tb, if given, is additional traceback information.
"""
if message is not None:
self.to_stderr(message)
if self.params.get('verbose'):
if tb is None:
if sys.exc_info()[0]: # if .trouble has been called from an except block
tb = ''
if hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
tb += ''.join(traceback.format_exception(*sys.exc_info()[1].exc_info))
tb += encode_compat_str(traceback.format_exc())
else:
tb_data = traceback.format_list(traceback.extract_stack())
tb = ''.join(tb_data)
self.to_stderr(tb)
if not self.params.get('ignoreerrors', False):
if sys.exc_info()[0] and hasattr(sys.exc_info()[1], 'exc_info') and sys.exc_info()[1].exc_info[0]:
exc_info = sys.exc_info()[1].exc_info
else:
exc_info = sys.exc_info()
raise DownloadError(message, exc_info)
self._download_retcode = 1
def report_warning(self, message):
'''
Print the message to stderr, it will be prefixed with 'WARNING:'
If stderr is a tty file the 'WARNING:' will be colored
'''
if self.params.get('logger') is not None:
self.params['logger'].warning(message)
else:
if self.params.get('no_warnings'):
return
if not self.params.get('no_color') and self._err_file.isatty() and compat_os_name != 'nt':
_msg_header = '\033[0;33mWARNING:\033[0m'
else:
_msg_header = 'WARNING:'
warning_message = '%s %s' % (_msg_header, message)
self.to_stderr(warning_message)
def report_error(self, message, tb=None):
'''
Do the same as trouble, but prefixes the message with 'ERROR:', colored
in red if stderr is a tty file.
'''
if not self.params.get('no_color') and self._err_file.isatty() and compat_os_name != 'nt':
_msg_header = '\033[0;31mERROR:\033[0m'
else:
_msg_header = 'ERROR:'
error_message = '%s %s' % (_msg_header, message)
self.trouble(error_message, tb)
def report_file_already_downloaded(self, file_name):
"""Report file has already been fully downloaded."""
try:
self.to_screen('[download] %s has already been downloaded' % file_name)
except UnicodeEncodeError:
self.to_screen('[download] The file has already been downloaded')
def prepare_filename(self, info_dict):
"""Generate the output filename."""
try:
template_dict = dict(info_dict)
template_dict['epoch'] = int(time.time())
autonumber_size = self.params.get('autonumber_size')
if autonumber_size is None:
autonumber_size = 5
template_dict['autonumber'] = self.params.get('autonumber_start', 1) - 1 + self._num_downloads
if template_dict.get('resolution') is None:
if template_dict.get('width') and template_dict.get('height'):
template_dict['resolution'] = '%dx%d' % (template_dict['width'], template_dict['height'])
elif template_dict.get('height'):
template_dict['resolution'] = '%sp' % template_dict['height']
elif template_dict.get('width'):
template_dict['resolution'] = '%dx?' % template_dict['width']
sanitize = lambda k, v: sanitize_filename(
compat_str(v),
restricted=self.params.get('restrictfilenames'),
is_id=(k == 'id' or k.endswith('_id')))
template_dict = dict((k, v if isinstance(v, compat_numeric_types) else sanitize(k, v))
for k, v in template_dict.items()
if v is not None and not isinstance(v, (list, tuple, dict)))
template_dict = collections.defaultdict(lambda: self.params.get('outtmpl_na_placeholder', 'NA'), template_dict)
outtmpl = self.params.get('outtmpl', DEFAULT_OUTTMPL)
# For fields playlist_index and autonumber convert all occurrences
# of %(field)s to %(field)0Nd for backward compatibility
field_size_compat_map = {
'playlist_index': len(str(template_dict['n_entries'])),
'autonumber': autonumber_size,
}
FIELD_SIZE_COMPAT_RE = r'(?<!%)%\((?P<field>autonumber|playlist_index)\)s'
mobj = re.search(FIELD_SIZE_COMPAT_RE, outtmpl)
if mobj:
outtmpl = re.sub(
FIELD_SIZE_COMPAT_RE,
r'%%(\1)0%dd' % field_size_compat_map[mobj.group('field')],
outtmpl)
# Missing numeric fields used together with integer presentation types
# in format specification will break the argument substitution since
# string NA placeholder is returned for missing fields. We will patch
# output template for missing fields to meet string presentation type.
for numeric_field in self._NUMERIC_FIELDS:
if numeric_field not in template_dict:
# As of [1] format syntax is:
# %[mapping_key][conversion_flags][minimum_width][.precision][length_modifier]type
# 1. https://docs.python.org/2/library/stdtypes.html#string-formatting
FORMAT_RE = r'''(?x)
(?<!%)
%
\({0}\) # mapping key
(?:[#0\-+ ]+)? # conversion flags (optional)
(?:\d+)? # minimum field width (optional)
(?:\.\d+)? # precision (optional)
[hlL]? # length modifier (optional)
[diouxXeEfFgGcrs%] # conversion type
'''
outtmpl = re.sub(
FORMAT_RE.format(numeric_field),
r'%({0})s'.format(numeric_field), outtmpl)
# expand_path translates '%%' into '%' and '$$' into '$'
# correspondingly that is not what we want since we need to keep
# '%%' intact for template dict substitution step. Working around
# with boundary-alike separator hack.
sep = ''.join([random.choice(ascii_letters) for _ in range(32)])
# print('hychu, {%s}' % outtmpl)
outtmpl = outtmpl.replace('%%', '%{0}%'.format(sep)).replace('$$', '${0}$'.format(sep))
# outtmpl should be expand_path'ed before template dict substitution
# because meta fields may contain env variables we don't want to
# be expanded. For example, for outtmpl "%(title)s.%(ext)s" and
# title "Hello $PATH", we don't want `$PATH` to be expanded.
filename = expand_path(outtmpl).replace(sep, '') % template_dict
# filename = os.path.join('out', filename)
# print('hychu, The filename is {%s}.{%s}' % (outtmpl, filename))
# Temporary fix for #4787
# 'Treat' all problem characters by passing filename through preferredencoding
# to workaround encoding issues with subprocess on python2 @ Windows
if sys.version_info < (3, 0) and sys.platform == 'win32':
filename = encodeFilename(filename, True).decode(preferredencoding())
return sanitize_path(filename)
except ValueError as err:
self.report_error('Error in output template: ' + str(err) + ' (encoding: ' + repr(preferredencoding()) + ')')
return None
def _match_entry(self, info_dict, incomplete):
""" Returns None iff the file should be downloaded """
video_title = info_dict.get('title', info_dict.get('id', 'video'))
if 'title' in info_dict:
# This can happen when we're just evaluating the playlist
title = info_dict['title']
matchtitle = self.params.get('matchtitle', False)
if matchtitle:
if not re.search(matchtitle, title, re.IGNORECASE):
return '"' + title + '" title did not match pattern "' + matchtitle + '"'
rejecttitle = self.params.get('rejecttitle', False)
if rejecttitle:
if re.search(rejecttitle, title, re.IGNORECASE):
return '"' + title + '" title matched reject pattern "' + rejecttitle + '"'
date = info_dict.get('upload_date')
if date is not None:
dateRange = self.params.get('daterange', DateRange())
if date not in dateRange:
return '%s upload date is not in range %s' % (date_from_str(date).isoformat(), dateRange)
view_count = info_dict.get('view_count')
if view_count is not None:
min_views = self.params.get('min_views')
if min_views is not None and view_count < min_views:
return 'Skipping %s, because it has not reached minimum view count (%d/%d)' % (video_title, view_count, min_views)
max_views = self.params.get('max_views')
if max_views is not None and view_count > max_views:
return 'Skipping %s, because it has exceeded the maximum view count (%d/%d)' % (video_title, view_count, max_views)
if age_restricted(info_dict.get('age_limit'), self.params.get('age_limit')):
return 'Skipping "%s" because it is age restricted' % video_title
if self.in_download_archive(info_dict):
return '%s has already been recorded in archive' % video_title
if not incomplete:
match_filter = self.params.get('match_filter')
if match_filter is not None:
ret = match_filter(info_dict)
if ret is not None:
return ret
return None
@staticmethod
def add_extra_info(info_dict, extra_info):
'''Set the keys from extra_info in info dict if they are missing'''
for key, value in extra_info.items():
info_dict.setdefault(key, value)
def extract_info(self, url, download=True, ie_key=None, extra_info={},
process=True, force_generic_extractor=False):
'''
Returns a list with a dictionary for each video we find.
If 'download', also downloads the videos.
extra_info is a dict containing the extra values to add to each result
'''
if not ie_key and force_generic_extractor:
ie_key = 'Generic'
if ie_key:
ies = [self.get_info_extractor(ie_key)]
else:
ies = self._ies
for ie in ies:
if not ie.suitable(url):
continue
ie = self.get_info_extractor(ie.ie_key())
if not ie.working():
self.report_warning('The program functionality for this site has been marked as broken, '
'and will probably not work.')
return self.__extract_info(url, ie, download, extra_info, process)
else:
self.report_error('no suitable InfoExtractor for URL %s' % url)
def __handle_extraction_exceptions(func):
def wrapper(self, *args, **kwargs):
try:
return func(self, *args, **kwargs)
except GeoRestrictedError as e:
msg = e.msg
if e.countries:
msg += '\nThis video is available in %s.' % ', '.join(
map(ISO3166Utils.short2full, e.countries))
msg += '\nYou might want to use a VPN or a proxy server (with --proxy) to workaround.'
self.report_error(msg)
except ExtractorError as e: # An error we somewhat expected
self.report_error(compat_str(e), e.format_traceback())
except MaxDownloadsReached:
raise
except Exception as e:
if self.params.get('ignoreerrors', False):
self.report_error(error_to_compat_str(e), tb=encode_compat_str(traceback.format_exc()))
else:
raise
return wrapper
@__handle_extraction_exceptions
def __extract_info(self, url, ie, download, extra_info, process):
ie_result = ie.extract(url)
if ie_result is None: # Finished already (backwards compatibility; listformats and friends should be moved here)
return
if isinstance(ie_result, list):
# Backwards compatibility: old IE result format
ie_result = {
'_type': 'compat_list',
'entries': ie_result,
}
self.add_default_extra_info(ie_result, ie, url)
if process:
return self.process_ie_result(ie_result, download, extra_info)
else:
return ie_result
def add_default_extra_info(self, ie_result, ie, url):
self.add_extra_info(ie_result, {
'extractor': ie.IE_NAME,
'webpage_url': url,
'webpage_url_basename': url_basename(url),
'extractor_key': ie.ie_key(),
})
def process_ie_result(self, ie_result, download=True, extra_info={}):
"""
Take the result of the ie(may be modified) and resolve all unresolved
references (URLs, playlist items).
It will also download the videos if 'download'.
Returns the resolved ie_result.
"""
result_type = ie_result.get('_type', 'video')
if result_type in ('url', 'url_transparent'):
ie_result['url'] = sanitize_url(ie_result['url'])
extract_flat = self.params.get('extract_flat', False)
if ((extract_flat == 'in_playlist' and 'playlist' in extra_info)
or extract_flat is True):
self.__forced_printings(
ie_result, self.prepare_filename(ie_result),
incomplete=True)
return ie_result
if result_type == 'video':
self.add_extra_info(ie_result, extra_info)
return self.process_video_result(ie_result, download=download)
elif result_type == 'url':
# We have to add extra_info to the results because it may be
# contained in a playlist
return self.extract_info(ie_result['url'],
download,
ie_key=ie_result.get('ie_key'),
extra_info=extra_info)
elif result_type == 'url_transparent':
# Use the information from the embedding page
info = self.extract_info(
ie_result['url'], ie_key=ie_result.get('ie_key'),
extra_info=extra_info, download=False, process=False)
# extract_info may return None when ignoreerrors is enabled and
# extraction failed with an error, don't crash and return early
# in this case
if not info:
return info
force_properties = dict(
(k, v) for k, v in ie_result.items() if v is not None)
for f in ('_type', 'url', 'id', 'extractor', 'extractor_key', 'ie_key'):
if f in force_properties:
del force_properties[f]
new_result = info.copy()
new_result.update(force_properties)
# Extracted info may not be a video result (i.e.
# info.get('_type', 'video') != video) but rather an url or
# url_transparent. In such cases outer metadata (from ie_result)
# should be propagated to inner one (info). For this to happen
# _type of info should be overridden with url_transparent. This
# fixes issue from https://github.com/ytdl-org/youtube-dl/pull/11163.
if new_result.get('_type') == 'url':
new_result['_type'] = 'url_transparent'
return self.process_ie_result(
new_result, download=download, extra_info=extra_info)
elif result_type in ('playlist', 'multi_video'):
# Protect from infinite recursion due to recursively nested playlists
# (see https://github.com/ytdl-org/youtube-dl/issues/27833)
webpage_url = ie_result['webpage_url']
if webpage_url in self._playlist_urls:
self.to_screen(
'[download] Skipping already downloaded playlist: %s'
% ie_result.get('title') or ie_result.get('id'))
return
self._playlist_level += 1
self._playlist_urls.add(webpage_url)
try:
return self.__process_playlist(ie_result, download)
finally:
self._playlist_level -= 1
if not self._playlist_level:
self._playlist_urls.clear()
elif result_type == 'compat_list':
self.report_warning(
'Extractor %s returned a compat_list result. '
'It needs to be updated.' % ie_result.get('extractor'))
def _fixup(r):
self.add_extra_info(
r,
{
'extractor': ie_result['extractor'],
'webpage_url': ie_result['webpage_url'],
'webpage_url_basename': url_basename(ie_result['webpage_url']),
'extractor_key': ie_result['extractor_key'],
}
)
return r
ie_result['entries'] = [
self.process_ie_result(_fixup(r), download, extra_info)
for r in ie_result['entries']
]
return ie_result
else:
raise Exception('Invalid result type: %s' % result_type)
def __process_playlist(self, ie_result, download):
# We process each entry in the playlist
playlist = ie_result.get('title') or ie_result.get('id')
self.to_screen('[download] Downloading playlist: %s' % playlist)
playlist_results = []
playliststart = self.params.get('playliststart', 1) - 1
playlistend = self.params.get('playlistend')
# For backwards compatibility, interpret -1 as whole list
if playlistend == -1:
playlistend = None
playlistitems_str = self.params.get('playlist_items')
playlistitems = None
if playlistitems_str is not None:
def iter_playlistitems(format):
for string_segment in format.split(','):
if '-' in string_segment:
start, end = string_segment.split('-')
for item in range(int(start), int(end) + 1):
yield int(item)
else:
yield int(string_segment)
playlistitems = orderedSet(iter_playlistitems(playlistitems_str))
ie_entries = ie_result['entries']
def make_playlistitems_entries(list_ie_entries):
num_entries = len(list_ie_entries)
return [
list_ie_entries[i - 1] for i in playlistitems
if -num_entries <= i - 1 < num_entries]
def report_download(num_entries):
self.to_screen(
'[%s] playlist %s: Downloading %d videos' %
(ie_result['extractor'], playlist, num_entries))
if isinstance(ie_entries, list):
n_all_entries = len(ie_entries)
if playlistitems:
entries = make_playlistitems_entries(ie_entries)
else:
entries = ie_entries[playliststart:playlistend]
n_entries = len(entries)
self.to_screen(
'[%s] playlist %s: Collected %d video ids (downloading %d of them)' %
(ie_result['extractor'], playlist, n_all_entries, n_entries))
elif isinstance(ie_entries, PagedList):
if playlistitems:
entries = []
for item in playlistitems:
entries.extend(ie_entries.getslice(
item - 1, item
))
else:
entries = ie_entries.getslice(
playliststart, playlistend)
n_entries = len(entries)
report_download(n_entries)
else: # iterable
if playlistitems:
entries = make_playlistitems_entries(list(itertools.islice(
ie_entries, 0, max(playlistitems))))
else:
entries = list(itertools.islice(
ie_entries, playliststart, playlistend))
n_entries = len(entries)
report_download(n_entries)
if self.params.get('playlistreverse', False):
entries = entries[::-1]
if self.params.get('playlistrandom', False):
random.shuffle(entries)
x_forwarded_for = ie_result.get('__x_forwarded_for_ip')
for i, entry in enumerate(entries, 1):
self.to_screen('[download] Downloading video %s of %s' % (i, n_entries))
# This __x_forwarded_for_ip thing is a bit ugly but requires
# minimal changes
if x_forwarded_for:
entry['__x_forwarded_for_ip'] = x_forwarded_for
extra = {
'n_entries': n_entries,
'playlist': playlist,
'playlist_id': ie_result.get('id'),
'playlist_title': ie_result.get('title'),
'playlist_uploader': ie_result.get('uploader'),
'playlist_uploader_id': ie_result.get('uploader_id'),
'playlist_index': playlistitems[i - 1] if playlistitems else i + playliststart,
'extractor': ie_result['extractor'],
'webpage_url': ie_result['webpage_url'],
'webpage_url_basename': url_basename(ie_result['webpage_url']),
'extractor_key': ie_result['extractor_key'],
}
reason = self._match_entry(entry, incomplete=True)
if reason is not None:
self.to_screen('[download] ' + reason)
continue
entry_result = self.__process_iterable_entry(entry, download, extra)
# TODO: skip failed (empty) entries?
playlist_results.append(entry_result)
ie_result['entries'] = playlist_results
self.to_screen('[download] Finished downloading playlist: %s' % playlist)
return ie_result
@__handle_extraction_exceptions
def __process_iterable_entry(self, entry, download, extra_info):
return self.process_ie_result(
entry, download=download, extra_info=extra_info)
def _build_format_filter(self, filter_spec):
" Returns a function to filter the formats according to the filter_spec "
OPERATORS = {
'<': operator.lt,
'<=': operator.le,
'>': operator.gt,
'>=': operator.ge,
'=': operator.eq,
'!=': operator.ne,
}
operator_rex = re.compile(r'''(?x)\s*
(?P<key>width|height|tbr|abr|vbr|asr|filesize|filesize_approx|fps)
\s*(?P<op>%s)(?P<none_inclusive>\s*\?)?\s*
(?P<value>[0-9.]+(?:[kKmMgGtTpPeEzZyY]i?[Bb]?)?)
$
''' % '|'.join(map(re.escape, OPERATORS.keys())))
m = operator_rex.search(filter_spec)
if m:
try:
comparison_value = int(m.group('value'))
except ValueError:
comparison_value = parse_filesize(m.group('value'))
if comparison_value is None:
comparison_value = parse_filesize(m.group('value') + 'B')
if comparison_value is None:
raise ValueError(
'Invalid value %r in format specification %r' % (
m.group('value'), filter_spec))
op = OPERATORS[m.group('op')]
if not m:
STR_OPERATORS = {
'=': operator.eq,
'^=': lambda attr, value: attr.startswith(value),
'$=': lambda attr, value: attr.endswith(value),
'*=': lambda attr, value: value in attr,
}
str_operator_rex = re.compile(r'''(?x)
\s*(?P<key>ext|acodec|vcodec|container|protocol|format_id|language)
\s*(?P<negation>!\s*)?(?P<op>%s)(?P<none_inclusive>\s*\?)?
\s*(?P<value>[a-zA-Z0-9._-]+)
\s*$
''' % '|'.join(map(re.escape, STR_OPERATORS.keys())))
m = str_operator_rex.search(filter_spec)
if m:
comparison_value = m.group('value')
str_op = STR_OPERATORS[m.group('op')]
if m.group('negation'):
op = lambda attr, value: not str_op(attr, value)
else:
op = str_op
if not m:
raise ValueError('Invalid filter specification %r' % filter_spec)
def _filter(f):
actual_value = f.get(m.group('key'))
if actual_value is None:
return m.group('none_inclusive')
return op(actual_value, comparison_value)
return _filter
def _default_format_spec(self, info_dict, download=True):
def can_merge():
merger = FFmpegMergerPP(self)
return merger.available and merger.can_merge()
def prefer_best():
if self.params.get('simulate', False):
return False
if not download:
return False
if self.params.get('outtmpl', DEFAULT_OUTTMPL) == '-':
return True
if info_dict.get('is_live'):
return True
if not can_merge():
return True
return False
req_format_list = ['bestvideo+bestaudio', 'best']
if prefer_best():
req_format_list.reverse()
return '/'.join(req_format_list)
def build_format_selector(self, format_spec):
def syntax_error(note, start):
message = (
'Invalid format specification: '
'{0}\n\t{1}\n\t{2}^'.format(note, format_spec, ' ' * start[1]))
return SyntaxError(message)
PICKFIRST = 'PICKFIRST'
MERGE = 'MERGE'
SINGLE = 'SINGLE'
GROUP = 'GROUP'
FormatSelector = collections.namedtuple('FormatSelector', ['type', 'selector', 'filters'])
def _parse_filter(tokens):
filter_parts = []
for type, string, start, _, _ in tokens:
if type == tokenize.OP and string == ']':
return ''.join(filter_parts)
else:
filter_parts.append(string)
def _remove_unused_ops(tokens):
# Remove operators that we don't use and join them with the surrounding strings
# for example: 'mp4' '-' 'baseline' '-' '16x9' is converted to 'mp4-baseline-16x9'
ALLOWED_OPS = ('/', '+', ',', '(', ')')
last_string, last_start, last_end, last_line = None, None, None, None
for type, string, start, end, line in tokens:
if type == tokenize.OP and string == '[':
if last_string:
yield tokenize.NAME, last_string, last_start, last_end, last_line
last_string = None
yield type, string, start, end, line
# everything inside brackets will be handled by _parse_filter
for type, string, start, end, line in tokens:
yield type, string, start, end, line
if type == tokenize.OP and string == ']':
break
elif type == tokenize.OP and string in ALLOWED_OPS:
if last_string:
yield tokenize.NAME, last_string, last_start, last_end, last_line
last_string = None
yield type, string, start, end, line
elif type in [tokenize.NAME, tokenize.NUMBER, tokenize.OP]:
if not last_string:
last_string = string
last_start = start
last_end = end
else:
last_string += string
if last_string:
yield tokenize.NAME, last_string, last_start, last_end, last_line
def _parse_format_selection(tokens, inside_merge=False, inside_choice=False, inside_group=False):
selectors = []
current_selector = None
for type, string, start, _, _ in tokens:
# ENCODING is only defined in python 3.x
if type == getattr(tokenize, 'ENCODING', None):
continue
elif type in [tokenize.NAME, tokenize.NUMBER]:
current_selector = FormatSelector(SINGLE, string, [])
elif type == tokenize.OP:
if string == ')':
if not inside_group:
# ')' will be handled by the parentheses group
tokens.restore_last_token()
break
elif inside_merge and string in ['/', ',']:
tokens.restore_last_token()
break
elif inside_choice and string == ',':
tokens.restore_last_token()
break
elif string == ',':
if not current_selector:
raise syntax_error('"," must follow a format selector', start)
selectors.append(current_selector)
current_selector = None
elif string == '/':
if not current_selector:
raise syntax_error('"/" must follow a format selector', start)
first_choice = current_selector
second_choice = _parse_format_selection(tokens, inside_choice=True)
current_selector = FormatSelector(PICKFIRST, (first_choice, second_choice), [])
elif string == '[':
if not current_selector:
current_selector = FormatSelector(SINGLE, 'best', [])
format_filter = _parse_filter(tokens)
current_selector.filters.append(format_filter)
elif string == '(':
if current_selector:
raise syntax_error('Unexpected "("', start)
group = _parse_format_selection(tokens, inside_group=True)
current_selector = FormatSelector(GROUP, group, [])
elif string == '+':
if inside_merge:
raise syntax_error('Unexpected "+"', start)
video_selector = current_selector
audio_selector = _parse_format_selection(tokens, inside_merge=True)
if not video_selector or not audio_selector:
raise syntax_error('"+" must be between two format selectors', start)
current_selector = FormatSelector(MERGE, (video_selector, audio_selector), [])
else:
raise syntax_error('Operator not recognized: "{0}"'.format(string), start)
elif type == tokenize.ENDMARKER:
break
if current_selector:
selectors.append(current_selector)
return selectors
def _build_selector_function(selector):
if isinstance(selector, list):
fs = [_build_selector_function(s) for s in selector]
def selector_function(ctx):
for f in fs:
for format in f(ctx):
yield format
return selector_function
elif selector.type == GROUP:
selector_function = _build_selector_function(selector.selector)
elif selector.type == PICKFIRST:
fs = [_build_selector_function(s) for s in selector.selector]
def selector_function(ctx):
for f in fs:
picked_formats = list(f(ctx))
if picked_formats:
return picked_formats
return []
elif selector.type == SINGLE:
format_spec = selector.selector
def selector_function(ctx):
formats = list(ctx['formats'])
if not formats:
return
if format_spec == 'all':
for f in formats:
yield f
elif format_spec in ['best', 'worst', None]:
format_idx = 0 if format_spec == 'worst' else -1
audiovideo_formats = [
f for f in formats
if f.get('vcodec') != 'none' and f.get('acodec') != 'none']
if audiovideo_formats:
yield audiovideo_formats[format_idx]
# for extractors with incomplete formats (audio only (soundcloud)
# or video only (imgur)) we will fallback to best/worst
# {video,audio}-only format
elif ctx['incomplete_formats']:
yield formats[format_idx]
elif format_spec == 'bestaudio':
audio_formats = [
f for f in formats
if f.get('vcodec') == 'none']
if audio_formats:
yield audio_formats[-1]
elif format_spec == 'worstaudio':
audio_formats = [
f for f in formats
if f.get('vcodec') == 'none']
if audio_formats:
yield audio_formats[0]
elif format_spec == 'bestvideo':
video_formats = [
f for f in formats
if f.get('acodec') == 'none']
if video_formats:
yield video_formats[-1]
elif format_spec == 'worstvideo':
video_formats = [
f for f in formats
if f.get('acodec') == 'none']
if video_formats:
yield video_formats[0]
else:
extensions = ['mp4', 'flv', 'webm', '3gp', 'm4a', 'mp3', 'ogg', 'aac', 'wav']
if format_spec in extensions:
filter_f = lambda f: f['ext'] == format_spec
else:
filter_f = lambda f: f['format_id'] == format_spec
matches = list(filter(filter_f, formats))
if matches:
yield matches[-1]
elif selector.type == MERGE:
def _merge(formats_info):
format_1, format_2 = [f['format_id'] for f in formats_info]
# The first format must contain the video and the
# second the audio
if formats_info[0].get('vcodec') == 'none':
self.report_error('The first format must '
'contain the video, try using '
'"-f %s+%s"' % (format_2, format_1))
return
# Formats must be opposite (video+audio)
if formats_info[0].get('acodec') == 'none' and formats_info[1].get('acodec') == 'none':
self.report_error(
'Both formats %s and %s are video-only, you must specify "-f video+audio"'
% (format_1, format_2))
return
output_ext = (
formats_info[0]['ext']
if self.params.get('merge_output_format') is None
else self.params['merge_output_format'])
return {
'requested_formats': formats_info,
'format': '%s+%s' % (formats_info[0].get('format'),
formats_info[1].get('format')),
'format_id': '%s+%s' % (formats_info[0].get('format_id'),
formats_info[1].get('format_id')),
'width': formats_info[0].get('width'),
'height': formats_info[0].get('height'),
'resolution': formats_info[0].get('resolution'),
'fps': formats_info[0].get('fps'),
'vcodec': formats_info[0].get('vcodec'),
'vbr': formats_info[0].get('vbr'),
'stretched_ratio': formats_info[0].get('stretched_ratio'),
'acodec': formats_info[1].get('acodec'),
'abr': formats_info[1].get('abr'),
'ext': output_ext,
}
video_selector, audio_selector = map(_build_selector_function, selector.selector)
def selector_function(ctx):
for pair in itertools.product(
video_selector(copy.deepcopy(ctx)), audio_selector(copy.deepcopy(ctx))):
yield _merge(pair)
filters = [self._build_format_filter(f) for f in selector.filters]
def final_selector(ctx):
ctx_copy = copy.deepcopy(ctx)
for _filter in filters:
ctx_copy['formats'] = list(filter(_filter, ctx_copy['formats']))
return selector_function(ctx_copy)
return final_selector
stream = io.BytesIO(format_spec.encode('utf-8'))
try:
tokens = list(_remove_unused_ops(compat_tokenize_tokenize(stream.readline)))
except tokenize.TokenError:
raise syntax_error('Missing closing/opening brackets or parenthesis', (0, len(format_spec)))
class TokenIterator(object):
def __init__(self, tokens):
self.tokens = tokens
self.counter = 0
def __iter__(self):
return self
def __next__(self):
if self.counter >= len(self.tokens):
raise StopIteration()
value = self.tokens[self.counter]
self.counter += 1
return value
next = __next__
def restore_last_token(self):
self.counter -= 1
parsed_selector = _parse_format_selection(iter(TokenIterator(tokens)))
return _build_selector_function(parsed_selector)
def _calc_headers(self, info_dict):
res = std_headers.copy()
add_headers = info_dict.get('http_headers')
if add_headers:
res.update(add_headers)
cookies = self._calc_cookies(info_dict)
if cookies:
res['Cookie'] = cookies
if 'X-Forwarded-For' not in res:
x_forwarded_for_ip = info_dict.get('__x_forwarded_for_ip')
if x_forwarded_for_ip:
res['X-Forwarded-For'] = x_forwarded_for_ip
return res
def _calc_cookies(self, info_dict):
pr = sanitized_Request(info_dict['url'])
self.cookiejar.add_cookie_header(pr)
return pr.get_header('Cookie')
def process_video_result(self, info_dict, download=True):
assert info_dict.get('_type', 'video') == 'video'
if 'id' not in info_dict:
raise ExtractorError('Missing "id" field in extractor result')
if 'title' not in info_dict:
raise ExtractorError('Missing "title" field in extractor result')
def report_force_conversion(field, field_not, conversion):
self.report_warning(
'"%s" field is not %s - forcing %s conversion, there is an error in extractor'
% (field, field_not, conversion))
def sanitize_string_field(info, string_field):
field = info.get(string_field)
if field is None or isinstance(field, compat_str):
return
report_force_conversion(string_field, 'a string', 'string')
info[string_field] = compat_str(field)
def sanitize_numeric_fields(info):
for numeric_field in self._NUMERIC_FIELDS:
field = info.get(numeric_field)
if field is None or isinstance(field, compat_numeric_types):
continue
report_force_conversion(numeric_field, 'numeric', 'int')
info[numeric_field] = int_or_none(field)
sanitize_string_field(info_dict, 'id')
sanitize_numeric_fields(info_dict)
if 'playlist' not in info_dict:
# It isn't part of a playlist
info_dict['playlist'] = None
info_dict['playlist_index'] = None
thumbnails = info_dict.get('thumbnails')
if thumbnails is None:
thumbnail = info_dict.get('thumbnail')
if thumbnail:
info_dict['thumbnails'] = thumbnails = [{'url': thumbnail}]
if thumbnails:
thumbnails.sort(key=lambda t: (
t.get('preference') if t.get('preference') is not None else -1,
t.get('width') if t.get('width') is not None else -1,
t.get('height') if t.get('height') is not None else -1,
t.get('id') if t.get('id') is not None else '', t.get('url')))
for i, t in enumerate(thumbnails):
t['url'] = sanitize_url(t['url'])
if t.get('width') and t.get('height'):
t['resolution'] = '%dx%d' % (t['width'], t['height'])
if t.get('id') is None:
t['id'] = '%d' % i
if self.params.get('list_thumbnails'):
self.list_thumbnails(info_dict)
return
thumbnail = info_dict.get('thumbnail')
if thumbnail:
info_dict['thumbnail'] = sanitize_url(thumbnail)
elif thumbnails:
info_dict['thumbnail'] = thumbnails[-1]['url']
if 'display_id' not in info_dict and 'id' in info_dict:
info_dict['display_id'] = info_dict['id']
for ts_key, date_key in (
('timestamp', 'upload_date'),
('release_timestamp', 'release_date'),
):
if info_dict.get(date_key) is None and info_dict.get(ts_key) is not None:
# Working around out-of-range timestamp values (e.g. negative ones on Windows,
# see http://bugs.python.org/issue1646728)
try:
upload_date = datetime.datetime.utcfromtimestamp(info_dict[ts_key])
info_dict[date_key] = upload_date.strftime('%Y%m%d')
except (ValueError, OverflowError, OSError):
pass
# Auto generate title fields corresponding to the *_number fields when missing
# in order to always have clean titles. This is very common for TV series.
for field in ('chapter', 'season', 'episode'):
if info_dict.get('%s_number' % field) is not None and not info_dict.get(field):
info_dict[field] = '%s %d' % (field.capitalize(), info_dict['%s_number' % field])
for cc_kind in ('subtitles', 'automatic_captions'):
cc = info_dict.get(cc_kind)
if cc:
for _, subtitle in cc.items():
for subtitle_format in subtitle:
if subtitle_format.get('url'):
subtitle_format['url'] = sanitize_url(subtitle_format['url'])
if subtitle_format.get('ext') is None:
subtitle_format['ext'] = determine_ext(subtitle_format['url']).lower()
automatic_captions = info_dict.get('automatic_captions')
subtitles = info_dict.get('subtitles')
if self.params.get('listsubtitles', False):
if 'automatic_captions' in info_dict:
self.list_subtitles(
info_dict['id'], automatic_captions, 'automatic captions')
self.list_subtitles(info_dict['id'], subtitles, 'subtitles')
return
info_dict['requested_subtitles'] = self.process_subtitles(
info_dict['id'], subtitles, automatic_captions)
# We now pick which formats have to be downloaded
if info_dict.get('formats') is None:
# There's only one format available
formats = [info_dict]
else:
formats = info_dict['formats']
if not formats:
raise ExtractorError('No video formats found!')
def is_wellformed(f):
url = f.get('url')
if not url:
self.report_warning(
'"url" field is missing or empty - skipping format, '
'there is an error in extractor')
return False
if isinstance(url, bytes):
sanitize_string_field(f, 'url')
return True
# Filter out malformed formats for better extraction robustness
formats = list(filter(is_wellformed, formats))
formats_dict = {}
# We check that all the formats have the format and format_id fields
for i, format in enumerate(formats):
sanitize_string_field(format, 'format_id')
sanitize_numeric_fields(format)
format['url'] = sanitize_url(format['url'])
if not format.get('format_id'):
format['format_id'] = compat_str(i)
else:
# Sanitize format_id from characters used in format selector expression
format['format_id'] = re.sub(r'[\s,/+\[\]()]', '_', format['format_id'])
format_id = format['format_id']
if format_id not in formats_dict:
formats_dict[format_id] = []
formats_dict[format_id].append(format)
# Make sure all formats have unique format_id
for format_id, ambiguous_formats in formats_dict.items():
if len(ambiguous_formats) > 1:
for i, format in enumerate(ambiguous_formats):
format['format_id'] = '%s-%d' % (format_id, i)
for i, format in enumerate(formats):
if format.get('format') is None:
format['format'] = '{id} - {res}{note}'.format(
id=format['format_id'],
res=self.format_resolution(format),
note=' ({0})'.format(format['format_note']) if format.get('format_note') is not None else '',
)
# Automatically determine file extension if missing
if format.get('ext') is None:
format['ext'] = determine_ext(format['url']).lower()
# Automatically determine protocol if missing (useful for format
# selection purposes)
if format.get('protocol') is None:
format['protocol'] = determine_protocol(format)
# Add HTTP headers, so that external programs can use them from the
# json output
full_format_info = info_dict.copy()
full_format_info.update(format)
format['http_headers'] = self._calc_headers(full_format_info)
# Remove private housekeeping stuff
if '__x_forwarded_for_ip' in info_dict:
del info_dict['__x_forwarded_for_ip']
# TODO Central sorting goes here
if formats[0] is not info_dict:
# only set the 'formats' fields if the original info_dict list them
# otherwise we end up with a circular reference, the first (and unique)
# element in the 'formats' field in info_dict is info_dict itself,
# which can't be exported to json
info_dict['formats'] = formats
if self.params.get('listformats'):
self.list_formats(info_dict)
return
req_format = self.params.get('format')
if req_format is None:
req_format = self._default_format_spec(info_dict, download=download)
if self.params.get('verbose'):
self._write_string('[debug] Default format spec: %s\n' % req_format)
format_selector = self.build_format_selector(req_format)
# While in format selection we may need to have an access to the original
# format set in order to calculate some metrics or do some processing.
# For now we need to be able to guess whether original formats provided
# by extractor are incomplete or not (i.e. whether extractor provides only
# video-only or audio-only formats) for proper formats selection for
# extractors with such incomplete formats (see
# https://github.com/ytdl-org/youtube-dl/pull/5556).
# Since formats may be filtered during format selection and may not match
# the original formats the results may be incorrect. Thus original formats
# or pre-calculated metrics should be passed to format selection routines
# as well.
# We will pass a context object containing all necessary additional data
# instead of just formats.
# This fixes incorrect format selection issue (see
# https://github.com/ytdl-org/youtube-dl/issues/10083).
incomplete_formats = (
# All formats are video-only or
all(f.get('vcodec') != 'none' and f.get('acodec') == 'none' for f in formats)
# all formats are audio-only
or all(f.get('vcodec') == 'none' and f.get('acodec') != 'none' for f in formats))
ctx = {
'formats': formats,
'incomplete_formats': incomplete_formats,
}
formats_to_download = list(format_selector(ctx))
if not formats_to_download:
raise ExtractorError('requested format not available',
expected=True)
if download:
if len(formats_to_download) > 1:
self.to_screen('[info] %s: downloading video in %s formats' % (info_dict['id'], len(formats_to_download)))
for format in formats_to_download:
new_info = dict(info_dict)
new_info.update(format)
self.process_info(new_info)
# We update the info dict with the best quality format (backwards compatibility)
info_dict.update(formats_to_download[-1])
return info_dict
def process_subtitles(self, video_id, normal_subtitles, automatic_captions):
"""Select the requested subtitles and their format"""
available_subs = {}
if normal_subtitles and self.params.get('writesubtitles'):
available_subs.update(normal_subtitles)
if automatic_captions and self.params.get('writeautomaticsub'):
for lang, cap_info in automatic_captions.items():
if lang not in available_subs:
available_subs[lang] = cap_info
if (not self.params.get('writesubtitles') and not
self.params.get('writeautomaticsub') or not
available_subs):
return None
if self.params.get('allsubtitles', False):
requested_langs = available_subs.keys()
else:
if self.params.get('subtitleslangs', False):
requested_langs = self.params.get('subtitleslangs')
elif 'en' in available_subs:
requested_langs = ['en']
else:
requested_langs = [list(available_subs.keys())[0]]
formats_query = self.params.get('subtitlesformat', 'best')
formats_preference = formats_query.split('/') if formats_query else []
subs = {}
for lang in requested_langs:
formats = available_subs.get(lang)
if formats is None:
self.report_warning('%s subtitles not available for %s' % (lang, video_id))
continue
for ext in formats_preference:
if ext == 'best':
f = formats[-1]
break
matches = list(filter(lambda f: f['ext'] == ext, formats))
if matches:
f = matches[-1]
break
else:
f = formats[-1]
self.report_warning(
'No subtitle format found matching "%s" for language %s, '
'using %s' % (formats_query, lang, f['ext']))
subs[lang] = f
return subs
def __forced_printings(self, info_dict, filename, incomplete):
def print_mandatory(field):
if (self.params.get('force%s' % field, False)
and (not incomplete or info_dict.get(field) is not None)):
self.to_stdout(info_dict[field])
def print_optional(field):
if (self.params.get('force%s' % field, False)
and info_dict.get(field) is not None):
self.to_stdout(info_dict[field])
print_mandatory('title')
print_mandatory('id')
if self.params.get('forceurl', False) and not incomplete:
if info_dict.get('requested_formats') is not None:
for f in info_dict['requested_formats']:
self.to_stdout(f['url'] + f.get('play_path', ''))
else:
# For RTMP URLs, also include the playpath
self.to_stdout(info_dict['url'] + info_dict.get('play_path', ''))
print_optional('thumbnail')
print_optional('description')
if self.params.get('forcefilename', False) and filename is not None:
self.to_stdout(filename)
if self.params.get('forceduration', False) and info_dict.get('duration') is not None:
self.to_stdout(formatSeconds(info_dict['duration']))
print_mandatory('format')
if self.params.get('forcejson', False):
self.to_stdout(json.dumps(info_dict))
def process_info(self, info_dict):
"""Process a single resolved IE result."""
assert info_dict.get('_type', 'video') == 'video'
max_downloads = self.params.get('max_downloads')
if max_downloads is not None:
if self._num_downloads >= int(max_downloads):
raise MaxDownloadsReached()
# TODO: backward compatibility, to be removed
info_dict['fulltitle'] = info_dict['title']
if 'format' not in info_dict:
info_dict['format'] = info_dict['ext']
reason = self._match_entry(info_dict, incomplete=False)
if reason is not None:
self.to_screen('[download] ' + reason)
return
self._num_downloads += 1
info_dict['_filename'] = filename = self.prepare_filename(info_dict)
# Forced printings
self.__forced_printings(info_dict, filename, incomplete=False)
# Do nothing else if in simulate mode
if self.params.get('simulate', False):
return
if filename is None:
return
def ensure_dir_exists(path):
try:
dn = os.path.dirname(path)
if dn and not os.path.exists(dn):
os.makedirs(dn)
return True
except (OSError, IOError) as err:
if isinstance(err, OSError) and err.errno == errno.EEXIST:
return True
self.report_error('unable to create directory ' + error_to_compat_str(err))
return False
if not ensure_dir_exists(sanitize_path(encodeFilename(filename))):
return
if self.params.get('writedescription', False):
descfn = replace_extension(filename, 'description', info_dict.get('ext'))
if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(descfn)):
self.to_screen('[info] Video description is already present')
elif info_dict.get('description') is None:
self.report_warning('There\'s no description to write.')
else:
try:
self.to_screen('[info] Writing video description to: ' + descfn)
with io.open(encodeFilename(descfn), 'w', encoding='utf-8') as descfile:
descfile.write(info_dict['description'])
except (OSError, IOError):
self.report_error('Cannot write description file ' + descfn)
return
if self.params.get('writeannotations', False):
annofn = replace_extension(filename, 'annotations.xml', info_dict.get('ext'))
if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(annofn)):
self.to_screen('[info] Video annotations are already present')
elif not info_dict.get('annotations'):
self.report_warning('There are no annotations to write.')
else:
try:
self.to_screen('[info] Writing video annotations to: ' + annofn)
with io.open(encodeFilename(annofn), 'w', encoding='utf-8') as annofile:
annofile.write(info_dict['annotations'])
except (KeyError, TypeError):
self.report_warning('There are no annotations to write.')
except (OSError, IOError):
self.report_error('Cannot write annotations file: ' + annofn)
return
subtitles_are_requested = any([self.params.get('writesubtitles', False),
self.params.get('writeautomaticsub')])
if subtitles_are_requested and info_dict.get('requested_subtitles'):
# subtitles download errors are already managed as troubles in relevant IE
# that way it will silently go on when used with unsupporting IE
subtitles = info_dict['requested_subtitles']
ie = self.get_info_extractor(info_dict['extractor_key'])
for sub_lang, sub_info in subtitles.items():
sub_format = sub_info['ext']
sub_filename = subtitles_filename(filename, sub_lang, sub_format, info_dict.get('ext'))
if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(sub_filename)):
self.to_screen('[info] Video subtitle %s.%s is already present' % (sub_lang, sub_format))
else:
self.to_screen('[info] Writing video subtitles to: ' + sub_filename)
if sub_info.get('data') is not None:
try:
# Use newline='' to prevent conversion of newline characters
# See https://github.com/ytdl-org/youtube-dl/issues/10268
with io.open(encodeFilename(sub_filename), 'w', encoding='utf-8', newline='') as subfile:
subfile.write(sub_info['data'])
except (OSError, IOError):
self.report_error('Cannot write subtitles file ' + sub_filename)
return
else:
try:
sub_data = ie._request_webpage(
sub_info['url'], info_dict['id'], note=False).read()
with io.open(encodeFilename(sub_filename), 'wb') as subfile:
subfile.write(sub_data)
except (ExtractorError, IOError, OSError, ValueError) as err:
self.report_warning('Unable to download subtitle for "%s": %s' %
(sub_lang, error_to_compat_str(err)))
continue
if self.params.get('writeinfojson', False):
infofn = replace_extension(filename, 'info.json', info_dict.get('ext'))
if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(infofn)):
self.to_screen('[info] Video description metadata is already present')
else:
self.to_screen('[info] Writing video description metadata as JSON to: ' + infofn)
try:
write_json_file(self.filter_requested_info(info_dict), infofn)
except (OSError, IOError):
self.report_error('Cannot write metadata to JSON file ' + infofn)
return
self._write_thumbnails(info_dict, filename)
if not self.params.get('skip_download', False):
try:
def dl(name, info):
fd = get_suitable_downloader(info, self.params)(self, self.params)
for ph in self._progress_hooks:
fd.add_progress_hook(ph)
if self.params.get('verbose'):
self.to_screen('[debug] Invoking downloader on %r' % info.get('url'))
return fd.download(name, info)
if info_dict.get('requested_formats') is not None:
downloaded = []
success = True
merger = FFmpegMergerPP(self)
if not merger.available:
postprocessors = []
self.report_warning('You have requested multiple '
'formats but ffmpeg or avconv are not installed.'
' The formats won\'t be merged.')
else:
postprocessors = [merger]
def compatible_formats(formats):
video, audio = formats
# Check extension
video_ext, audio_ext = video.get('ext'), audio.get('ext')
if video_ext and audio_ext:
COMPATIBLE_EXTS = (
('mp3', 'mp4', 'm4a', 'm4p', 'm4b', 'm4r', 'm4v', 'ismv', 'isma'),
('webm')
)
for exts in COMPATIBLE_EXTS:
if video_ext in exts and audio_ext in exts:
return True
# TODO: Check acodec/vcodec
return False
filename_real_ext = os.path.splitext(filename)[1][1:]
filename_wo_ext = (
os.path.splitext(filename)[0]
if filename_real_ext == info_dict['ext']
else filename)
requested_formats = info_dict['requested_formats']
if self.params.get('merge_output_format') is None and not compatible_formats(requested_formats):
info_dict['ext'] = 'mkv'
self.report_warning(
'Requested formats are incompatible for merge and will be merged into mkv.')
# Ensure filename always has a correct extension for successful merge
filename = '%s.%s' % (filename_wo_ext, info_dict['ext'])
if os.path.exists(encodeFilename(filename)):
self.to_screen(
'[download] %s has already been downloaded and '
'merged' % filename)
else:
for f in requested_formats:
new_info = dict(info_dict)
new_info.update(f)
fname = prepend_extension(
self.prepare_filename(new_info),
'f%s' % f['format_id'], new_info['ext'])
if not ensure_dir_exists(fname):
return
downloaded.append(fname)
partial_success = dl(fname, new_info)
success = success and partial_success
info_dict['__postprocessors'] = postprocessors
info_dict['__files_to_merge'] = downloaded
else:
# Just a single file
success = dl(filename, info_dict)
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
self.report_error('unable to download video data: %s' % error_to_compat_str(err))
return
except (OSError, IOError) as err:
raise UnavailableVideoError(err)
except (ContentTooShortError, ) as err:
self.report_error('content too short (expected %s bytes and served %s)' % (err.expected, err.downloaded))
return
if success and filename != '-':
# Fixup content
fixup_policy = self.params.get('fixup')
if fixup_policy is None:
fixup_policy = 'detect_or_warn'
INSTALL_FFMPEG_MESSAGE = 'Install ffmpeg or avconv to fix this automatically.'
stretched_ratio = info_dict.get('stretched_ratio')
if stretched_ratio is not None and stretched_ratio != 1:
if fixup_policy == 'warn':
self.report_warning('%s: Non-uniform pixel ratio (%s)' % (
info_dict['id'], stretched_ratio))
elif fixup_policy == 'detect_or_warn':
stretched_pp = FFmpegFixupStretchedPP(self)
if stretched_pp.available:
info_dict.setdefault('__postprocessors', [])
info_dict['__postprocessors'].append(stretched_pp)
else:
self.report_warning(
'%s: Non-uniform pixel ratio (%s). %s'
% (info_dict['id'], stretched_ratio, INSTALL_FFMPEG_MESSAGE))
else:
assert fixup_policy in ('ignore', 'never')
if (info_dict.get('requested_formats') is None
and info_dict.get('container') == 'm4a_dash'):
if fixup_policy == 'warn':
self.report_warning(
'%s: writing DASH m4a. '
'Only some players support this container.'
% info_dict['id'])
elif fixup_policy == 'detect_or_warn':
fixup_pp = FFmpegFixupM4aPP(self)
if fixup_pp.available:
info_dict.setdefault('__postprocessors', [])
info_dict['__postprocessors'].append(fixup_pp)
else:
self.report_warning(
'%s: writing DASH m4a. '
'Only some players support this container. %s'
% (info_dict['id'], INSTALL_FFMPEG_MESSAGE))
else:
assert fixup_policy in ('ignore', 'never')
if (info_dict.get('protocol') == 'm3u8_native'
or info_dict.get('protocol') == 'm3u8'
and self.params.get('hls_prefer_native')):
if fixup_policy == 'warn':
self.report_warning('%s: malformed AAC bitstream detected.' % (
info_dict['id']))
elif fixup_policy == 'detect_or_warn':
fixup_pp = FFmpegFixupM3u8PP(self)
if fixup_pp.available:
info_dict.setdefault('__postprocessors', [])
info_dict['__postprocessors'].append(fixup_pp)
else:
self.report_warning(
'%s: malformed AAC bitstream detected. %s'
% (info_dict['id'], INSTALL_FFMPEG_MESSAGE))
else:
assert fixup_policy in ('ignore', 'never')
try:
self.post_process(filename, info_dict)
except (PostProcessingError) as err:
self.report_error('postprocessing: %s' % str(err))
return
self.record_download_archive(info_dict)
def download(self, url_list):
"""Download a given list of URLs."""
outtmpl = self.params.get('outtmpl', DEFAULT_OUTTMPL)
if (len(url_list) > 1
and outtmpl != '-'
and '%' not in outtmpl
and self.params.get('max_downloads') != 1):
raise SameFileError(outtmpl)
for url in url_list:
try:
# It also downloads the videos
res = self.extract_info(
url, force_generic_extractor=self.params.get('force_generic_extractor', False))
except UnavailableVideoError:
self.report_error('unable to download video')
except MaxDownloadsReached:
self.to_screen('[info] Maximum number of downloaded files reached.')
raise
else:
if self.params.get('dump_single_json', False):
self.to_stdout(json.dumps(res))
return self._download_retcode
def download_with_info_file(self, info_filename):
with contextlib.closing(fileinput.FileInput(
[info_filename], mode='r',
openhook=fileinput.hook_encoded('utf-8'))) as f:
# FileInput doesn't have a read method, we can't call json.load
info = self.filter_requested_info(json.loads('\n'.join(f)))
try:
self.process_ie_result(info, download=True)
except DownloadError:
webpage_url = info.get('webpage_url')
if webpage_url is not None:
self.report_warning('The info failed to download, trying with "%s"' % webpage_url)
return self.download([webpage_url])
else:
raise
return self._download_retcode
@staticmethod
def filter_requested_info(info_dict):
return dict(
(k, v) for k, v in info_dict.items()
if k not in ['requested_formats', 'requested_subtitles'])
def post_process(self, filename, ie_info):
"""Run all the postprocessors on the given file."""
info = dict(ie_info)
info['filepath'] = filename
pps_chain = []
if ie_info.get('__postprocessors') is not None:
pps_chain.extend(ie_info['__postprocessors'])
pps_chain.extend(self._pps)
for pp in pps_chain:
files_to_delete = []
try:
files_to_delete, info = pp.run(info)
except PostProcessingError as e:
self.report_error(e.msg)
if files_to_delete and not self.params.get('keepvideo', False):
for old_filename in files_to_delete:
self.to_screen('Deleting original file %s (pass -k to keep)' % old_filename)
try:
os.remove(encodeFilename(old_filename))
except (IOError, OSError):
self.report_warning('Unable to remove downloaded original file')
def _make_archive_id(self, info_dict):
video_id = info_dict.get('id')
if not video_id:
return
# Future-proof against any change in case
# and backwards compatibility with prior versions
extractor = info_dict.get('extractor_key') or info_dict.get('ie_key') # key in a playlist
if extractor is None:
url = str_or_none(info_dict.get('url'))
if not url:
return
# Try to find matching extractor for the URL and take its ie_key
for ie in self._ies:
if ie.suitable(url):
extractor = ie.ie_key()
break
else:
return
return extractor.lower() + ' ' + video_id
def in_download_archive(self, info_dict):
fn = self.params.get('download_archive')
if fn is None:
return False
vid_id = self._make_archive_id(info_dict)
if not vid_id:
return False # Incomplete video information
try:
with locked_file(fn, 'r', encoding='utf-8') as archive_file:
for line in archive_file:
if line.strip() == vid_id:
return True
except IOError as ioe:
if ioe.errno != errno.ENOENT:
raise
return False
def record_download_archive(self, info_dict):
fn = self.params.get('download_archive')
if fn is None:
return
vid_id = self._make_archive_id(info_dict)
assert vid_id
with locked_file(fn, 'a', encoding='utf-8') as archive_file:
archive_file.write(vid_id + '\n')
@staticmethod
def format_resolution(format, default='unknown'):
if format.get('vcodec') == 'none':
return 'audio only'
if format.get('resolution') is not None:
return format['resolution']
if format.get('height') is not None:
if format.get('width') is not None:
res = '%sx%s' % (format['width'], format['height'])
else:
res = '%sp' % format['height']
elif format.get('width') is not None:
res = '%dx?' % format['width']
else:
res = default
return res
def _format_note(self, fdict):
res = ''
if fdict.get('ext') in ['f4f', 'f4m']:
res += '(unsupported) '
if fdict.get('language'):
if res:
res += ' '
res += '[%s] ' % fdict['language']
if fdict.get('format_note') is not None:
res += fdict['format_note'] + ' '
if fdict.get('tbr') is not None:
res += '%4dk ' % fdict['tbr']
if fdict.get('container') is not None:
if res:
res += ', '
res += '%s container' % fdict['container']
if (fdict.get('vcodec') is not None
and fdict.get('vcodec') != 'none'):
if res:
res += ', '
res += fdict['vcodec']
if fdict.get('vbr') is not None:
res += '@'
elif fdict.get('vbr') is not None and fdict.get('abr') is not None:
res += 'video@'
if fdict.get('vbr') is not None:
res += '%4dk' % fdict['vbr']
if fdict.get('fps') is not None:
if res:
res += ', '
res += '%sfps' % fdict['fps']
if fdict.get('acodec') is not None:
if res:
res += ', '
if fdict['acodec'] == 'none':
res += 'video only'
else:
res += '%-5s' % fdict['acodec']
elif fdict.get('abr') is not None:
if res:
res += ', '
res += 'audio'
if fdict.get('abr') is not None:
res += '@%3dk' % fdict['abr']
if fdict.get('asr') is not None:
res += ' (%5dHz)' % fdict['asr']
if fdict.get('filesize') is not None:
if res:
res += ', '
res += format_bytes(fdict['filesize'])
elif fdict.get('filesize_approx') is not None:
if res:
res += ', '
res += '~' + format_bytes(fdict['filesize_approx'])
return res
def list_formats(self, info_dict):
formats = info_dict.get('formats', [info_dict])
table = [
[f['format_id'], f['ext'], self.format_resolution(f), self._format_note(f)]
for f in formats
if f.get('preference') is None or f['preference'] >= -1000]
if len(formats) > 1:
table[-1][-1] += (' ' if table[-1][-1] else '') + '(best)'
header_line = ['format code', 'extension', 'resolution', 'note']
self.to_screen(
'[info] Available formats for %s:\n%s' %
(info_dict['id'], render_table(header_line, table)))
def list_thumbnails(self, info_dict):
thumbnails = info_dict.get('thumbnails')
if not thumbnails:
self.to_screen('[info] No thumbnails present for %s' % info_dict['id'])
return
self.to_screen(
'[info] Thumbnails for %s:' % info_dict['id'])
self.to_screen(render_table(
['ID', 'width', 'height', 'URL'],
[[t['id'], t.get('width', 'unknown'), t.get('height', 'unknown'), t['url']] for t in thumbnails]))
def list_subtitles(self, video_id, subtitles, name='subtitles'):
if not subtitles:
self.to_screen('%s has no %s' % (video_id, name))
return
self.to_screen(
'Available %s for %s:' % (name, video_id))
self.to_screen(render_table(
['Language', 'formats'],
[[lang, ', '.join(f['ext'] for f in reversed(formats))]
for lang, formats in subtitles.items()]))
def urlopen(self, req):
""" Start an HTTP download """
if isinstance(req, compat_basestring):
req = sanitized_Request(req)
return self._opener.open(req, timeout=self._socket_timeout)
def print_debug_header(self):
if not self.params.get('verbose'):
return
if type('') is not compat_str:
# Python 2.6 on SLES11 SP1 (https://github.com/ytdl-org/youtube-dl/issues/3326)
self.report_warning(
'Your Python is broken! Update to a newer and supported version')
stdout_encoding = getattr(
sys.stdout, 'encoding', 'missing (%s)' % type(sys.stdout).__name__)
encoding_str = (
'[debug] Encodings: locale %s, fs %s, out %s, pref %s\n' % (
locale.getpreferredencoding(),
sys.getfilesystemencoding(),
stdout_encoding,
self.get_encoding()))
write_string(encoding_str, encoding=None)
self._write_string('[debug] youtube-dl version ' + __version__ + '\n')
if _LAZY_LOADER:
self._write_string('[debug] Lazy loading extractors enabled' + '\n')
try:
sp = subprocess.Popen(
['git', 'rev-parse', '--short', 'HEAD'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
cwd=os.path.dirname(os.path.abspath(__file__)))
out, err = sp.communicate()
out = out.decode().strip()
if re.match('[0-9a-f]+', out):
self._write_string('[debug] Git HEAD: ' + out + '\n')
except Exception:
try:
sys.exc_clear()
except Exception:
pass
def python_implementation():
impl_name = platform.python_implementation()
if impl_name == 'PyPy' and hasattr(sys, 'pypy_version_info'):
return impl_name + ' version %d.%d.%d' % sys.pypy_version_info[:3]
return impl_name
self._write_string('[debug] Python version %s (%s) - %s\n' % (
platform.python_version(), python_implementation(),
platform_name()))
exe_versions = FFmpegPostProcessor.get_versions(self)
exe_versions['rtmpdump'] = rtmpdump_version()
exe_versions['phantomjs'] = PhantomJSwrapper._version()
exe_str = ', '.join(
'%s %s' % (exe, v)
for exe, v in sorted(exe_versions.items())
if v
)
if not exe_str:
exe_str = 'none'
self._write_string('[debug] exe versions: %s\n' % exe_str)
proxy_map = {}
for handler in self._opener.handlers:
if hasattr(handler, 'proxies'):
proxy_map.update(handler.proxies)
self._write_string('[debug] Proxy map: ' + compat_str(proxy_map) + '\n')
if self.params.get('call_home', False):
ipaddr = self.urlopen('https://yt-dl.org/ip').read().decode('utf-8')
self._write_string('[debug] Public IP address: %s\n' % ipaddr)
latest_version = self.urlopen(
'https://yt-dl.org/latest/version').read().decode('utf-8')
if version_tuple(latest_version) > version_tuple(__version__):
self.report_warning(
'You are using an outdated version (newest version: %s)! '
'See https://yt-dl.org/update if you need help updating.' %
latest_version)
def _setup_opener(self):
timeout_val = self.params.get('socket_timeout')
self._socket_timeout = 600 if timeout_val is None else float(timeout_val)
opts_cookiefile = self.params.get('cookiefile')
opts_proxy = self.params.get('proxy')
if opts_cookiefile is None:
self.cookiejar = compat_cookiejar.CookieJar()
else:
opts_cookiefile = expand_path(opts_cookiefile)
self.cookiejar = YoutubeDLCookieJar(opts_cookiefile)
if os.access(opts_cookiefile, os.R_OK):
self.cookiejar.load(ignore_discard=True, ignore_expires=True)
cookie_processor = YoutubeDLCookieProcessor(self.cookiejar)
if opts_proxy is not None:
if opts_proxy == '':
proxies = {}
else:
proxies = {'http': opts_proxy, 'https': opts_proxy}
else:
proxies = compat_urllib_request.getproxies()
# Set HTTPS proxy to HTTP one if given (https://github.com/ytdl-org/youtube-dl/issues/805)
if 'http' in proxies and 'https' not in proxies:
proxies['https'] = proxies['http']
proxy_handler = PerRequestProxyHandler(proxies)
debuglevel = 1 if self.params.get('debug_printtraffic') else 0
https_handler = make_HTTPS_handler(self.params, debuglevel=debuglevel)
ydlh = YoutubeDLHandler(self.params, debuglevel=debuglevel)
redirect_handler = YoutubeDLRedirectHandler()
data_handler = compat_urllib_request_DataHandler()
# When passing our own FileHandler instance, build_opener won't add the
# default FileHandler and allows us to disable the file protocol, which
# can be used for malicious purposes (see
# https://github.com/ytdl-org/youtube-dl/issues/8227)
file_handler = compat_urllib_request.FileHandler()
def file_open(*args, **kwargs):
raise compat_urllib_error.URLError('file:// scheme is explicitly disabled in youtube-dl for security reasons')
file_handler.file_open = file_open
opener = compat_urllib_request.build_opener(
proxy_handler, https_handler, cookie_processor, ydlh, redirect_handler, data_handler, file_handler)
# Delete the default user-agent header, which would otherwise apply in
# cases where our custom HTTP handler doesn't come into play
# (See https://github.com/ytdl-org/youtube-dl/issues/1309 for details)
opener.addheaders = []
self._opener = opener
def encode(self, s):
if isinstance(s, bytes):
return s # Already encoded
try:
return s.encode(self.get_encoding())
except UnicodeEncodeError as err:
err.reason = err.reason + '. Check your system encoding configuration or use the --encoding option.'
raise
def get_encoding(self):
encoding = self.params.get('encoding')
if encoding is None:
encoding = preferredencoding()
return encoding
def _write_thumbnails(self, info_dict, filename):
if self.params.get('writethumbnail', False):
thumbnails = info_dict.get('thumbnails')
if thumbnails:
thumbnails = [thumbnails[-1]]
elif self.params.get('write_all_thumbnails', False):
thumbnails = info_dict.get('thumbnails')
else:
return
if not thumbnails:
# No thumbnails present, so return immediately
return
for t in thumbnails:
thumb_ext = determine_ext(t['url'], 'jpg')
suffix = '_%s' % t['id'] if len(thumbnails) > 1 else ''
thumb_display_id = '%s ' % t['id'] if len(thumbnails) > 1 else ''
t['filename'] = thumb_filename = replace_extension(filename + suffix, thumb_ext, info_dict.get('ext'))
if self.params.get('nooverwrites', False) and os.path.exists(encodeFilename(thumb_filename)):
self.to_screen('[%s] %s: Thumbnail %sis already present' %
(info_dict['extractor'], info_dict['id'], thumb_display_id))
else:
self.to_screen('[%s] %s: Downloading thumbnail %s...' %
(info_dict['extractor'], info_dict['id'], thumb_display_id))
try:
uf = self.urlopen(t['url'])
with open(encodeFilename(thumb_filename), 'wb') as thumbf:
shutil.copyfileobj(uf, thumbf)
self.to_screen('[%s] %s: Writing thumbnail %sto: %s' %
(info_dict['extractor'], info_dict['id'], thumb_display_id, thumb_filename))
except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
self.report_warning('Unable to download thumbnail "%s": %s' %
(t['url'], error_to_compat_str(err)))
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
test/helpers/ssh_command.go
|
// Copyright 2017-2019 Authors of Cilium
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package helpers
import (
"bytes"
"context"
"fmt"
"io"
"io/ioutil"
"net"
"os"
"strconv"
"time"
"github.com/kevinburke/ssh_config"
"golang.org/x/crypto/ssh"
"golang.org/x/crypto/ssh/agent"
)
// SSHCommand stores the data associated with executing a command.
// TODO: this is poorly named in that it's not related to a command only
// ran over SSH - rename this.
type SSHCommand struct {
// TODO: path is not a clear name - rename to something more clear.
Path string
Env []string
Stdin io.Reader
Stdout io.Writer
Stderr io.Writer
}
// SSHClient stores the information needed to SSH into a remote location for
// running tests.
type SSHClient struct {
Config *ssh.ClientConfig // ssh client configuration information.
Host string // Ip/Host from the target virtualserver
Port int // Port to connect to the target server
client *ssh.Client // Client implements a traditional SSH client that supports shells,
// subprocesses, TCP port/streamlocal forwarding and tunneled dialing.
}
// GetHostPort returns the host port representation of the ssh client
func (cli *SSHClient) GetHostPort() string {
return net.JoinHostPort(cli.Host, strconv.Itoa(cli.Port))
}
// SSHConfig contains metadata for an SSH session.
type SSHConfig struct {
target string
host string
user string
port int
identityFile string
}
// SSHConfigs maps the name of a host (VM) to its corresponding SSHConfiguration
type SSHConfigs map[string]*SSHConfig
// GetSSHClient initializes an SSHClient based on the provided SSHConfig
func (cfg *SSHConfig) GetSSHClient() *SSHClient {
sshConfig := &ssh.ClientConfig{
User: cfg.user,
Auth: []ssh.AuthMethod{
cfg.GetSSHAgent(),
},
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
Timeout: 15 * time.Second,
}
return &SSHClient{
Config: sshConfig,
Host: cfg.host,
Port: cfg.port,
}
}
func (client *SSHClient) String() string {
return fmt.Sprintf("host: %s, port: %d, user: %s", client.Host, client.Port, client.Config.User)
}
func (cfg *SSHConfig) String() string {
return fmt.Sprintf("target: %s, host: %s, port %d, user, %s, identityFile: %s", cfg.target, cfg.host, cfg.port, cfg.user, cfg.identityFile)
}
// GetSSHAgent returns the ssh.AuthMethod corresponding to SSHConfig cfg.
func (cfg *SSHConfig) GetSSHAgent() ssh.AuthMethod {
key, err := ioutil.ReadFile(cfg.identityFile)
if err != nil {
log.Fatalf("unable to retrieve ssh-key on target '%s': %s", cfg.target, err)
}
signer, err := ssh.ParsePrivateKey(key)
if err != nil {
log.Fatalf("unable to parse private key on target '%s': %s", cfg.target, err)
}
return ssh.PublicKeys(signer)
}
// ImportSSHconfig imports the SSH configuration stored at the provided path.
// Returns an error if the SSH configuration could not be instantiated.
func ImportSSHconfig(config []byte) (SSHConfigs, error) {
result := make(SSHConfigs)
cfg, err := ssh_config.Decode(bytes.NewBuffer(config))
if err != nil {
return nil, err
}
for _, host := range cfg.Hosts {
key := host.Patterns[0].String()
if key == "*" {
continue
}
port, _ := cfg.Get(key, "Port")
hostConfig := SSHConfig{target: key}
hostConfig.host, _ = cfg.Get(key, "Hostname")
hostConfig.identityFile, _ = cfg.Get(key, "identityFile")
hostConfig.user, _ = cfg.Get(key, "User")
hostConfig.port, _ = strconv.Atoi(port)
result[key] = &hostConfig
}
return result, nil
}
// copyWait runs an instance of io.Copy() in a goroutine, and returns a channel
// to receive the error result.
func copyWait(dst io.Writer, src io.Reader) chan error {
c := make(chan error, 1)
go func() {
_, err := io.Copy(dst, src)
c <- err
}()
return c
}
// runCommand runs the specified command on the provided SSH session, and
// gathers both of the sterr and stdout output into the writers provided by
// cmd. Returns whether the command was run and an optional error.
// Returns nil when the command completes successfully and all stderr,
// stdout output has been written. Returns an error otherwise.
func runCommand(session *ssh.Session, cmd *SSHCommand) (bool, error) {
stderr, err := session.StderrPipe()
if err != nil {
return false, fmt.Errorf("Unable to setup stderr for session: %v", err)
}
errChan := copyWait(cmd.Stderr, stderr)
stdout, err := session.StdoutPipe()
if err != nil {
return false, fmt.Errorf("Unable to setup stdout for session: %v", err)
}
outChan := copyWait(cmd.Stdout, stdout)
if err = session.Run(cmd.Path); err != nil {
return false, err
}
if err = <-errChan; err != nil {
return true, err
}
if err = <-outChan; err != nil {
return true, err
}
return true, nil
}
// RunCommand runs a SSHCommand using SSHClient client. The returned error is
// nil if the command runs, has no problems copying stdin, stdout, and stderr,
// and exits with a zero exit status.
func (client *SSHClient) RunCommand(cmd *SSHCommand) error {
session, err := client.newSession()
if err != nil {
return err
}
defer session.Close()
_, err = runCommand(session, cmd)
return err
}
// RunCommandInBackground runs an SSH command in a similar way to
// RunCommandContext, but with a context which allows the command to be
// cancelled at any time. When cancel is called the error of the command is
// returned instead the context error.
func (client *SSHClient) RunCommandInBackground(ctx context.Context, cmd *SSHCommand) error {
if ctx == nil {
panic("nil context provided to RunCommandInBackground()")
}
session, err := client.newSession()
if err != nil {
return err
}
defer session.Close()
modes := ssh.TerminalModes{
ssh.ECHO: 1, // enable echoing
ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
}
session.RequestPty("xterm-256color", 80, 80, modes)
stdin, err := session.StdinPipe()
if err != nil {
log.Errorf("Could not get stdin: %s", err)
}
go func() {
select {
case <-ctx.Done():
_, err := stdin.Write([]byte{3})
if err != nil {
log.Errorf("write ^C error: %s", err)
}
err = session.Wait()
if err != nil {
log.Errorf("wait error: %s", err)
}
if err = session.Signal(ssh.SIGHUP); err != nil {
log.Errorf("failed to kill command: %s", err)
}
if err = session.Close(); err != nil {
log.Errorf("failed to close session: %s", err)
}
}
}()
_, err = runCommand(session, cmd)
return err
}
// RunCommandContext runs an SSH command in a similar way to RunCommand but with
// a context. If context is canceled it will return the error of that given
// context.
func (client *SSHClient) RunCommandContext(ctx context.Context, cmd *SSHCommand) error {
if ctx == nil {
panic("nil context provided to RunCommandContext()")
}
var (
session *ssh.Session
sessionErrChan = make(chan error, 1)
)
go func() {
var sessionErr error
// This may block depending on the state of the setup tests are being
// ran against. As a result, these goroutines may leak, but the logic
// below will fail and propagate to the rest of the CI framework, which
// will error out anyway. It's better to leak in really bad cases since
// the CI will fail anyway. Unfortunately, the golang SSH library does
// not provide a way to propagate context through to creating sessions.
// Note that this is a closure on the session variable!
session, sessionErr = client.newSession()
if sessionErr != nil {
log.Infof("error creating session: %s", sessionErr)
sessionErrChan <- sessionErr
return
}
_, runErr := runCommand(session, cmd)
sessionErrChan <- runErr
if closeErr := session.Close(); closeErr != nil {
log.WithError(closeErr).Error("failed to close session")
}
}()
select {
case asyncErr := <-sessionErrChan:
return asyncErr
case <-ctx.Done():
if session != nil {
log.Warning("sending SIGHUP to session due to canceled context")
if err := session.Signal(ssh.SIGHUP); err != nil {
log.Errorf("failed to kill command when context is canceled: %s", err)
}
} else {
log.Error("timeout reached; no session was able to be created")
}
return ctx.Err()
}
}
func (client *SSHClient) newSession() (*ssh.Session, error) {
var connection *ssh.Client
var err error
if client.client != nil {
connection = client.client
} else {
connection, err = ssh.Dial(
"tcp",
fmt.Sprintf("%s:%d", client.Host, client.Port),
client.Config)
if err != nil {
return nil, fmt.Errorf("failed to dial: %s", err)
}
client.client = connection
}
session, err := connection.NewSession()
if err != nil {
return nil, fmt.Errorf("failed to create session: %s", err)
}
return session, nil
}
// SSHAgent returns the ssh.Authmethod using the Public keys. Returns nil if
// a connection to SSH_AUTH_SHOCK does not succeed.
func SSHAgent() ssh.AuthMethod {
if sshAgent, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK")); err == nil {
return ssh.PublicKeysCallback(agent.NewClient(sshAgent).Signers)
}
return nil
}
// GetSSHClient initializes an SSHClient for the specified host/port/user
// combination.
func GetSSHClient(host string, port int, user string) *SSHClient {
sshConfig := &ssh.ClientConfig{
User: user,
Auth: []ssh.AuthMethod{
SSHAgent(),
},
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
Timeout: 15 * time.Second,
}
return &SSHClient{
Config: sshConfig,
Host: host,
Port: port,
}
}
|
[
"\"SSH_AUTH_SOCK\""
] |
[] |
[
"SSH_AUTH_SOCK"
] |
[]
|
["SSH_AUTH_SOCK"]
|
go
| 1 | 0 | |
src/core/main.go
|
// Copyright 2018 Project Harbor Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package main
import (
"encoding/gob"
"fmt"
"os"
"os/signal"
"strconv"
"syscall"
"time"
"github.com/astaxie/beego"
_ "github.com/astaxie/beego/session/redis"
"github.com/goharbor/harbor/src/common/dao"
"github.com/goharbor/harbor/src/common/job"
"github.com/goharbor/harbor/src/common/models"
common_quota "github.com/goharbor/harbor/src/common/quota"
"github.com/goharbor/harbor/src/common/utils"
"github.com/goharbor/harbor/src/common/utils/log"
"github.com/goharbor/harbor/src/core/api"
quota "github.com/goharbor/harbor/src/core/api/quota"
_ "github.com/goharbor/harbor/src/core/api/quota/chart"
_ "github.com/goharbor/harbor/src/core/api/quota/registry"
_ "github.com/goharbor/harbor/src/core/auth/authproxy"
_ "github.com/goharbor/harbor/src/core/auth/db"
_ "github.com/goharbor/harbor/src/core/auth/ldap"
_ "github.com/goharbor/harbor/src/core/auth/oidc"
_ "github.com/goharbor/harbor/src/core/auth/uaa"
"github.com/goharbor/harbor/src/core/config"
"github.com/goharbor/harbor/src/core/filter"
"github.com/goharbor/harbor/src/core/middlewares"
_ "github.com/goharbor/harbor/src/core/notifier/topic"
"github.com/goharbor/harbor/src/core/service/token"
"github.com/goharbor/harbor/src/pkg/notification"
"github.com/goharbor/harbor/src/pkg/scan"
"github.com/goharbor/harbor/src/pkg/scan/dao/scanner"
"github.com/goharbor/harbor/src/pkg/scan/event"
"github.com/goharbor/harbor/src/pkg/scheduler"
"github.com/goharbor/harbor/src/pkg/types"
"github.com/goharbor/harbor/src/pkg/version"
"github.com/goharbor/harbor/src/replication"
"github.com/goharbor/harbor/src/server"
)
const (
adminUserID = 1
)
func updateInitPassword(userID int, password string) error {
queryUser := models.User{UserID: userID}
user, err := dao.GetUser(queryUser)
if err != nil {
return fmt.Errorf("Failed to get user, userID: %d %v", userID, err)
}
if user == nil {
return fmt.Errorf("user id: %d does not exist", userID)
}
if user.Salt == "" {
salt := utils.GenerateRandomString()
user.Salt = salt
user.Password = password
err = dao.ChangeUserPassword(*user)
if err != nil {
return fmt.Errorf("Failed to update user encrypted password, userID: %d, err: %v", userID, err)
}
log.Infof("User id: %d updated its encrypted password successfully.", userID)
} else {
log.Infof("User id: %d already has its encrypted password.", userID)
}
return nil
}
// Quota migration
func quotaSync() error {
projects, err := dao.GetProjects(nil)
if err != nil {
log.Errorf("list project error, %v", err)
return err
}
var pids []string
for _, project := range projects {
pids = append(pids, strconv.FormatInt(project.ProjectID, 10))
}
usages, err := dao.ListQuotaUsages(&models.QuotaUsageQuery{Reference: "project", ReferenceIDs: pids})
if err != nil {
log.Errorf("list quota usage error, %v", err)
return err
}
// The condition handles these two cases:
// 1, len(project) > 1 && len(usages) == 1. existing projects without usage, as we do always has 'library' usage in DB.
// 2, migration fails at the phase of inserting usage into DB, and parts of them are inserted successfully.
if len(projects) != len(usages) {
log.Info("Start to sync quota data .....")
if err := quota.Sync(config.GlobalProjectMgr, true); err != nil {
log.Errorf("Fail to sync quota data, %v", err)
return err
}
log.Info("Success to sync quota data .....")
return nil
}
// Only has one project without usage
zero := common_quota.ResourceList{
common_quota.ResourceCount: 0,
common_quota.ResourceStorage: 0,
}
if len(projects) == 1 && len(usages) == 1 {
totalRepo, err := dao.GetTotalOfRepositories()
if totalRepo == 0 {
return nil
}
refID, err := strconv.ParseInt(usages[0].ReferenceID, 10, 64)
if err != nil {
log.Error(err)
return err
}
usedRes, err := types.NewResourceList(usages[0].Used)
if err != nil {
log.Error(err)
return err
}
if types.Equals(usedRes, zero) && refID == projects[0].ProjectID {
log.Info("Start to sync quota data .....")
if err := quota.Sync(config.GlobalProjectMgr, true); err != nil {
log.Errorf("Fail to sync quota data, %v", err)
return err
}
log.Info("Success to sync quota data .....")
}
}
return nil
}
func gracefulShutdown(closing, done chan struct{}) {
signals := make(chan os.Signal, 1)
signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
log.Infof("capture system signal %s, to close \"closing\" channel", <-signals)
close(closing)
select {
case <-done:
log.Infof("Goroutines exited normally")
case <-time.After(time.Second * 3):
log.Infof("Timeout waiting goroutines to exit")
}
os.Exit(0)
}
func main() {
beego.BConfig.WebConfig.Session.SessionOn = true
beego.BConfig.WebConfig.Session.SessionName = config.SessionCookieName
redisURL := os.Getenv("_REDIS_URL")
if len(redisURL) > 0 {
gob.Register(models.User{})
beego.BConfig.WebConfig.Session.SessionProvider = "redis"
beego.BConfig.WebConfig.Session.SessionProviderConfig = redisURL
}
beego.AddTemplateExt("htm")
log.Info("initializing configurations...")
config.Init()
log.Info("configurations initialization completed")
token.InitCreators()
database, err := config.Database()
if err != nil {
log.Fatalf("failed to get database configuration: %v", err)
}
if err := dao.InitAndUpgradeDatabase(database); err != nil {
log.Fatalf("failed to initialize database: %v", err)
}
if err := config.Load(); err != nil {
log.Fatalf("failed to load config: %v", err)
}
// init the jobservice client
job.Init()
// init the scheduler
scheduler.Init()
password, err := config.InitialAdminPassword()
if err != nil {
log.Fatalf("failed to get admin's initial password: %v", err)
}
if err := updateInitPassword(adminUserID, password); err != nil {
log.Error(err)
}
// Init API handler
if err := api.Init(); err != nil {
log.Fatalf("Failed to initialize API handlers with error: %s", err.Error())
}
registerScanners()
closing := make(chan struct{})
done := make(chan struct{})
go gracefulShutdown(closing, done)
if err := replication.Init(closing, done); err != nil {
log.Fatalf("failed to init for replication: %v", err)
}
log.Info("initializing notification...")
notification.Init()
// Initialize the event handlers for handling artifact cascade deletion
event.Init()
filter.Init()
beego.InsertFilter("/api/*", beego.BeforeStatic, filter.SessionCheck)
beego.InsertFilter("/*", beego.BeforeRouter, filter.SecurityFilter)
beego.InsertFilter("/*", beego.BeforeRouter, filter.ReadonlyFilter)
server.RegisterRoutes()
syncRegistry := os.Getenv("SYNC_REGISTRY")
sync, err := strconv.ParseBool(syncRegistry)
if err != nil {
log.Errorf("Failed to parse SYNC_REGISTRY: %v", err)
// if err set it default to false
sync = false
}
if sync {
if err := api.SyncRegistry(config.GlobalProjectMgr); err != nil {
log.Error(err)
}
} else {
log.Infof("Because SYNC_REGISTRY set false , no need to sync registry \n")
}
log.Info("Init proxy")
if err := middlewares.Init(); err != nil {
log.Fatalf("init proxy error, %v", err)
}
syncQuota := os.Getenv("SYNC_QUOTA")
doSyncQuota, err := strconv.ParseBool(syncQuota)
if err != nil {
log.Errorf("Failed to parse SYNC_QUOTA: %v", err)
doSyncQuota = true
}
if doSyncQuota {
if err := quotaSync(); err != nil {
log.Fatalf("quota migration error, %v", err)
}
} else {
log.Infof("Because SYNC_QUOTA set false , no need to sync quota \n")
}
log.Infof("Version: %s, Git commit: %s", version.ReleaseVersion, version.GitCommit)
beego.RunWithMiddleWares("", middlewares.MiddleWares()...)
}
func registerScanners() {
wantedScanners := make([]scanner.Registration, 0)
uninstallURLs := make([]string, 0)
if config.WithTrivy() {
log.Info("Registering Trivy scanner")
wantedScanners = append(wantedScanners, scanner.Registration{
Name: "Trivy",
Description: "The Trivy scanner adapter",
URL: config.TrivyAdapterURL(),
UseInternalAddr: true,
Immutable: true,
})
} else {
log.Info("Removing Trivy scanner")
uninstallURLs = append(uninstallURLs, config.TrivyAdapterURL())
}
if config.WithClair() {
clairDB, err := config.ClairDB()
if err != nil {
log.Fatalf("failed to load clair database information: %v", err)
}
if err := dao.InitClairDB(clairDB); err != nil {
log.Fatalf("failed to initialize clair database: %v", err)
}
log.Info("Registering Clair scanner")
wantedScanners = append(wantedScanners, scanner.Registration{
Name: "Clair",
Description: "The Clair scanner adapter",
URL: config.ClairAdapterEndpoint(),
UseInternalAddr: true,
Immutable: true,
})
} else {
log.Info("Removing Clair scanner")
uninstallURLs = append(uninstallURLs, config.ClairAdapterEndpoint())
}
if err := scan.EnsureScanners(wantedScanners); err != nil {
log.Fatalf("failed to register scanners: %v", err)
}
if defaultScannerURL := getDefaultScannerURL(); defaultScannerURL != "" {
log.Infof("Setting %s as default scanner", defaultScannerURL)
if err := scan.EnsureDefaultScanner(defaultScannerURL); err != nil {
log.Fatalf("failed to set default scanner: %v", err)
}
}
if err := scan.RemoveImmutableScanners(uninstallURLs); err != nil {
log.Warningf("failed to remove scanners: %v", err)
}
}
func getDefaultScannerURL() string {
if config.WithTrivy() {
return config.TrivyAdapterURL()
}
if config.WithClair() {
return config.ClairAdapterEndpoint()
}
return ""
}
|
[
"\"_REDIS_URL\"",
"\"SYNC_REGISTRY\"",
"\"SYNC_QUOTA\""
] |
[] |
[
"SYNC_QUOTA",
"SYNC_REGISTRY",
"_REDIS_URL"
] |
[]
|
["SYNC_QUOTA", "SYNC_REGISTRY", "_REDIS_URL"]
|
go
| 3 | 0 | |
microservices/transportation/handlers/handlers.go
|
package handlers
import (
"context"
"encoding/csv"
"encoding/json"
"io/ioutil"
"log"
"net/http"
"os"
"strings"
"github.com/Risath18/xplored-transportation/models"
"github.com/gofiber/fiber/v2"
_ "github.com/lib/pq"
"googlemaps.github.io/maps"
)
//Import All Codes
var Codes map[string]models.AirportCodes
// helper function to initalize airport codes
func InitAirportCodes() {
Codes = ImportAirportCodes()
}
/*
* Helper Method to Import codes from CSV
*/
func ImportAirportCodes() map[string]models.AirportCodes {
// err := godotenv.Load("../../.env")
// if err != nil {
// log.Fatal("Error loading .env file")
// }
f, err := os.Open(os.Getenv("TRANSPORTATION_AIRPORT_CODE_CSV"))
if err != nil {
log.Fatal(err)
}
// remember to close the file at the end of the program
defer f.Close()
// read csv values using csv.Reader
csvReader := csv.NewReader(f)
data, err := csvReader.ReadAll()
if err != nil {
log.Fatal(err)
}
// convert records to array of structs
codesMap := make(map[string]models.AirportCodes)
for i, line := range data {
if i > 0 { // omit header line
var rec models.AirportCodes
var key string
for j, field := range line {
if j == 0 {
key = field
rec.Name = field
} else if j == 1 {
rec.Municipality = field
} else if j == 2 {
rec.Code = field
} else if j == 3 {
rec.Coordinates = field
}
codesMap[key] = rec
}
}
}
return codesMap
}
/*
* Dynamic Query to get Airport Codes based on various data
*/
func GetAirportCode(c *fiber.Ctx) error {
request := new(models.CodeRequest)
err := c.QueryParser(request)
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Body Error", "cause": "Couldn't process body of request"})
}
if request.Name == "" {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Missing Paramater"})
}
//Look for Names
tempMap := make(map[string]models.AirportCodes)
for k := range Codes {
if strings.HasPrefix(strings.ToLower(k), strings.ToLower(request.Name)) {
tempMap[k] = Codes[k]
}
}
//Look for City
for k := range Codes {
if strings.HasPrefix(strings.ToLower(Codes[k].Municipality), strings.ToLower(request.Name)) {
tempMap[k] = Codes[k]
}
}
//Look for Code
for k := range Codes {
if strings.HasPrefix(strings.ToLower(Codes[k].Code), strings.ToLower(request.Name)) {
tempMap[k] = Codes[k]
}
}
//If prefix contains less than 5, look for inside string.
if len(tempMap) < 5 {
for k := range Codes {
if strings.Contains(strings.ToLower(k), strings.ToLower(request.Name)) {
if _, ok := tempMap[k]; !ok {
tempMap[k] = Codes[k]
}
}
}
}
if len(tempMap) == 0 {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Invalid data"})
}
return c.Status(200).JSON(fiber.Map{"status": "Success", "data": tempMap})
}
/*
* Short Distance travel with Google API
*/
func GetTransShort(c *fiber.Ctx) error {
request := new(models.ShortRequest)
err := c.QueryParser(request)
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Body Error", "cause": "Couldn't process body of request"})
}
if request.Origin == "" || request.Destination == "" {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Missing Paramater"})
}
client, err := maps.NewClient(maps.WithAPIKey(os.Getenv("TRANSPORTATION_GOOGLE_API_KEY")))
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Failed to connect with API"})
}
r := &maps.DirectionsRequest{
Origin: request.Origin,
Destination: request.Destination,
DepartureTime: request.DepartureTime,
ArrivalTime: request.ArrivalTime,
Mode: request.Mode,
}
result, waypoints, err := client.Directions(context.Background(), r)
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": err})
}
return c.Status(200).JSON(fiber.Map{"status": err, "data": result, "waypoint": waypoints})
}
/*
* Flight information with Flights API
*/
func GetTransLong(c *fiber.Ctx) error {
request := new(models.LongRequest)
err := c.QueryParser(request)
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Body Error", "cause": "Couldn't process body of request"})
}
if request.Origin == "" || request.Destination == "" || request.DepartureDate == "" || request.Adults == "" {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Missing Paramater"})
}
url := os.Getenv("TRANSPORTATION_FLIGHT_API_URI") + "?"
if request.Origin != "" {
url = url + "&origin=" + request.Origin
}
if request.Destination != "" {
url = url + "&destination=" + request.Destination
}
if request.DepartureDate != "" {
url = url + "&departureDate=" + request.DepartureDate
}
if request.Adults != "" {
url = url + "&adults=" + request.Adults
}
if request.Currency != "" {
url = url + "¤cy=" + request.Currency
}
if request.ReturnDate != "" {
url = url + "&returnDate=" + request.ReturnDate
}
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("X-RapidAPI-Host", os.Getenv("TRANSPORTATION_FLIGHT_API_HOST"))
req.Header.Add("X-RapidAPI-Key", os.Getenv("TRANSPORTATION_FLIGHT_API_KEY"))
res, err := http.DefaultClient.Do(req)
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Body Error", "cause": "Couldn't make request to api"})
}
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
//JSONIFY
var jsonMap map[string]interface{}
json.Unmarshal([]byte(string(body)), &jsonMap)
return c.Status(200).JSON(fiber.Map{"status": err, "data": jsonMap})
}
/*
* Short Distance travel with Google API
*/
func GetAllModes(c *fiber.Ctx) error {
request := new(models.AllShortRequest)
err := c.QueryParser(request)
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Body Error", "cause": "Couldn't process body of request"})
}
if request.Origin == "" || request.Destination == "" {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Missing Paramater"})
}
client, err := maps.NewClient(maps.WithAPIKey(os.Getenv("TRANSPORTATION_GOOGLE_API_KEY")))
if err != nil {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": "Failed to connect with API"})
}
var modes[4] maps.Mode
modes[0] = "driving"
modes[1] = "bicycling"
modes[2] = "transit"
modes[3] = "walking"
var results[4][] maps.Route
var waypoints[4][] maps.GeocodedWaypoint
//Driving
r := &maps.DirectionsRequest{
Origin: request.Origin,
Destination: request.Destination,
DepartureTime: request.DepartureTime,
ArrivalTime: request.ArrivalTime,
Mode: modes[0],
}
tempResultOne, tempWaypointOne, errOne := client.Directions(context.Background(), r)
if errOne == nil {
results[0] = tempResultOne
waypoints[0] = tempWaypointOne
}
//Bicycling
r = &maps.DirectionsRequest{
Origin: request.Origin,
Destination: request.Destination,
DepartureTime: request.DepartureTime,
ArrivalTime: request.ArrivalTime,
Mode: modes[1],
}
tempResultTwo, tempWaypointTwo, errTwo := client.Directions(context.Background(), r)
if errTwo == nil {
results[1] = tempResultTwo
waypoints[1] = tempWaypointTwo
}
//transit
r = &maps.DirectionsRequest{
Origin: request.Origin,
Destination: request.Destination,
DepartureTime: request.DepartureTime,
ArrivalTime: request.ArrivalTime,
Mode: modes[2],
}
tempResultThree, tempWaypointThree, errThree := client.Directions(context.Background(), r)
if errThree == nil {
results[2] = tempResultThree
waypoints[2] = tempWaypointThree
}
//walking
r = &maps.DirectionsRequest{
Origin: request.Origin,
Destination: request.Destination,
DepartureTime: request.DepartureTime,
ArrivalTime: request.ArrivalTime,
Mode: modes[3],
}
tempResultFour, tempWaypointFour, errFour := client.Directions(context.Background(), r)
if errFour == nil {
results[3] = tempResultFour
waypoints[3] = tempWaypointFour
}
//May not do anything
if len(results) == 0 {
return c.Status(400).JSON(fiber.Map{"status": "fail", "type": err})
}
return c.Status(200).JSON(fiber.Map{"status": err, "data": results, "waypoint": waypoints})
}
|
[
"\"TRANSPORTATION_AIRPORT_CODE_CSV\"",
"\"TRANSPORTATION_GOOGLE_API_KEY\"",
"\"TRANSPORTATION_FLIGHT_API_URI\"",
"\"TRANSPORTATION_FLIGHT_API_HOST\"",
"\"TRANSPORTATION_FLIGHT_API_KEY\"",
"\"TRANSPORTATION_GOOGLE_API_KEY\""
] |
[] |
[
"TRANSPORTATION_FLIGHT_API_URI",
"TRANSPORTATION_GOOGLE_API_KEY",
"TRANSPORTATION_AIRPORT_CODE_CSV",
"TRANSPORTATION_FLIGHT_API_KEY",
"TRANSPORTATION_FLIGHT_API_HOST"
] |
[]
|
["TRANSPORTATION_FLIGHT_API_URI", "TRANSPORTATION_GOOGLE_API_KEY", "TRANSPORTATION_AIRPORT_CODE_CSV", "TRANSPORTATION_FLIGHT_API_KEY", "TRANSPORTATION_FLIGHT_API_HOST"]
|
go
| 5 | 0 | |
cmd/server/shared/shared.go
|
// Package shared provides the entrypoint to Sourcegraph's single docker
// image. It has functionality to setup the shared environment variables, as
// well as create the Procfile for goreman to run.
package shared
import (
"encoding/json"
"flag"
"log"
"os"
"path/filepath"
"strings"
"github.com/joho/godotenv"
"github.com/sourcegraph/sourcegraph/cmd/server/internal/goreman"
)
// FrontendInternalHost is the value of SRC_FRONTEND_INTERNAL.
const FrontendInternalHost = "127.0.0.1:3090"
// defaultEnv is environment variables that will be set if not already set.
var defaultEnv = map[string]string{
// Sourcegraph services running in this container
"SRC_GIT_SERVERS": "127.0.0.1:3178",
"SEARCHER_URL": "http://127.0.0.1:3181",
"REPO_UPDATER_URL": "http://127.0.0.1:3182",
"QUERY_RUNNER_URL": "http://127.0.0.1:3183",
"SRC_SYNTECT_SERVER": "http://127.0.0.1:9238",
"SYMBOLS_URL": "http://127.0.0.1:3184",
"REPLACER_URL": "http://127.0.0.1:3185",
"LSIF_SERVER_URL": "http://127.0.0.1:3186",
"SRC_HTTP_ADDR": ":8080",
"SRC_HTTPS_ADDR": ":8443",
"SRC_FRONTEND_INTERNAL": FrontendInternalHost,
"GITHUB_BASE_URL": "http://127.0.0.1:3180", // points to github-proxy
"GRAFANA_SERVER_URL": "http://127.0.0.1:3370",
// Limit our cache size to 100GB, same as prod. We should probably update
// searcher/symbols to ensure this value isn't larger than the volume for
// CACHE_DIR.
"SEARCHER_CACHE_SIZE_MB": "50000",
"REPLACER_CACHE_SIZE_MB": "50000",
"SYMBOLS_CACHE_SIZE_MB": "50000",
// Used to differentiate between deployments on dev, Docker, and Kubernetes.
"DEPLOY_TYPE": "docker-container",
// enables the debug proxy (/-/debug)
"SRC_PROF_HTTP": "",
"LOGO": "t",
"SRC_LOG_LEVEL": "warn",
// TODO other bits
// * DEBUG LOG_REQUESTS https://github.com/sourcegraph/sourcegraph/issues/8458
}
// Set verbosity based on simple interpretation of env var to avoid external dependencies (such as
// on github.com/sourcegraph/sourcegraph/internal/env).
var verbose = os.Getenv("SRC_LOG_LEVEL") == "dbug" || os.Getenv("SRC_LOG_LEVEL") == "info"
// Main is the main server command function which is shared between Sourcegraph
// server's open-source and enterprise variant.
func Main() {
flag.Parse()
log.SetFlags(0)
// Ensure CONFIG_DIR and DATA_DIR
// Load $CONFIG_DIR/env before we set any defaults
{
configDir := SetDefaultEnv("CONFIG_DIR", "/etc/sourcegraph")
err := os.MkdirAll(configDir, 0755)
if err != nil {
log.Fatalf("failed to ensure CONFIG_DIR exists: %s", err)
}
err = godotenv.Load(filepath.Join(configDir, "env"))
if err != nil && !os.IsNotExist(err) {
log.Fatalf("failed to load %s: %s", filepath.Join(configDir, "env"), err)
}
}
// Next persistence
{
SetDefaultEnv("SRC_REPOS_DIR", filepath.Join(DataDir, "repos"))
SetDefaultEnv("LSIF_STORAGE_ROOT", filepath.Join(DataDir, "lsif-storage"))
SetDefaultEnv("CACHE_DIR", filepath.Join(DataDir, "cache"))
}
// Special case some convenience environment variables
if redis, ok := os.LookupEnv("REDIS"); ok {
SetDefaultEnv("REDIS_ENDPOINT", redis)
}
data, err := json.MarshalIndent(SrcProfServices, "", " ")
if err != nil {
log.Println("Failed to marshal default SRC_PROF_SERVICES")
} else {
SetDefaultEnv("SRC_PROF_SERVICES", string(data))
}
for k, v := range defaultEnv {
SetDefaultEnv(k, v)
}
// Now we put things in the right place on the FS
if err := copySSH(); err != nil {
// TODO There are likely several cases where we don't need SSH
// working, we shouldn't prevent setup in those cases. The main one
// that comes to mind is an ORIGIN_MAP which creates https clone URLs.
log.Println("Failed to setup SSH authorization:", err)
log.Fatal("SSH authorization required for cloning from your codehost. Please see README.")
}
if err := copyNetrc(); err != nil {
log.Fatal("Failed to copy netrc:", err)
}
// TODO validate known_hosts contains all code hosts in config.
nginx, err := nginxProcFile()
if err != nil {
log.Fatal("Failed to setup nginx:", err)
}
procfile := []string{
nginx,
`frontend: env CONFIGURATION_MODE=server frontend`,
`gitserver: gitserver`,
`query-runner: query-runner`,
`symbols: symbols`,
`lsif-server: node /lsif/out/server.js`,
`lsif-worker: node /lsif/out/worker.js`,
`management-console: management-console`,
`searcher: searcher`,
`github-proxy: github-proxy`,
`repo-updater: repo-updater`,
`syntect_server: sh -c 'env QUIET=true ROCKET_ENV=production ROCKET_PORT=9238 ROCKET_LIMITS='"'"'{json=10485760}'"'"' ROCKET_SECRET_KEY='"'"'SeerutKeyIsI7releuantAndknvsuZPluaseIgnorYA='"'"' ROCKET_KEEP_ALIVE=0 ROCKET_ADDRESS='"'"'"127.0.0.1"'"'"' syntect_server | grep -v "Rocket has launched" | grep -v "Warning: environment is"' | grep -v 'Configured for production'`,
`prometheus: prometheus --config.file=/sg_config_prometheus/prometheus.yml --storage.tsdb.path=/var/opt/sourcegraph/prometheus --web.console.libraries=/usr/share/prometheus/console_libraries --web.console.templates=/usr/share/prometheus/consoles >> /var/opt/sourcegraph/prometheus.log 2>&1`,
`grafana: /usr/share/grafana/bin/grafana-server -config /sg_config_grafana/grafana-single-container.ini -homepath /usr/share/grafana >> /var/opt/sourcegraph/grafana.log 2>&1`,
}
procfile = append(procfile, ProcfileAdditions...)
redisStoreLine, err := maybeRedisStoreProcFile()
if err != nil {
log.Fatal(err)
}
if redisStoreLine != "" {
procfile = append(procfile, redisStoreLine)
}
redisCacheLine, err := maybeRedisCacheProcFile()
if err != nil {
log.Fatal(err)
}
if redisCacheLine != "" {
procfile = append(procfile, redisCacheLine)
}
if line, err := maybePostgresProcFile(); err != nil {
log.Fatal(err)
} else if line != "" {
procfile = append(procfile, line)
}
procfile = append(procfile, maybeZoektProcFile()...)
const goremanAddr = "127.0.0.1:5005"
if err := os.Setenv("GOREMAN_RPC_ADDR", goremanAddr); err != nil {
log.Fatal(err)
}
err = goreman.Start(goremanAddr, []byte(strings.Join(procfile, "\n")))
if err != nil {
log.Fatal(err)
}
}
|
[
"\"SRC_LOG_LEVEL\"",
"\"SRC_LOG_LEVEL\""
] |
[] |
[
"SRC_LOG_LEVEL"
] |
[]
|
["SRC_LOG_LEVEL"]
|
go
| 1 | 0 | |
cli/pcluster/commands.py
|
# Copyright 2013-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
# with the License. A copy of the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "LICENSE.txt" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions and
# limitations under the License.
# FIXME
# pylint: disable=too-many-locals
# pylint: disable=too-many-branches
# pylint: disable=too-many-statements
from __future__ import absolute_import, print_function
import datetime
import json
import logging
import os
import random
import shlex
import string
import subprocess as sub
import sys
import tarfile
import time
from builtins import str
from shutil import rmtree
from tempfile import mkdtemp, mkstemp
import boto3
import pkg_resources
from botocore.exceptions import ClientError
from tabulate import tabulate
import pcluster.utils as utils
from pcluster.config.pcluster_config import PclusterConfig
if sys.version_info[0] >= 3:
from urllib.request import urlretrieve
else:
from urllib import urlretrieve # pylint: disable=no-name-in-module
LOGGER = logging.getLogger(__name__)
def _create_bucket_with_batch_resources(stack_name, resources_dir, region):
random_string = "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(16))
# bucket names must be at least 3 and no more than 63 characters long
s3_bucket_name = "-".join([stack_name.lower()[: 63 - len(random_string) - 1], random_string])
try:
utils.create_s3_bucket(bucket_name=s3_bucket_name, region=region)
utils.upload_resources_artifacts(bucket_name=s3_bucket_name, root=resources_dir)
except boto3.client("s3").exceptions.BucketAlreadyExists:
LOGGER.error("Bucket %s already exists. Please retry cluster creation.", s3_bucket_name)
raise
except Exception:
utils.delete_s3_bucket(bucket_name=s3_bucket_name)
raise
return s3_bucket_name
def version():
return utils.get_installed_version()
def _check_for_updates(pcluster_config):
"""Check for updates."""
update_check = pcluster_config.get_section("global").get_param_value("update_check")
if update_check:
utils.check_if_latest_version()
def create(args): # noqa: C901 FIXME!!!
LOGGER.info("Beginning cluster creation for cluster: %s", args.cluster_name)
LOGGER.debug("Building cluster config based on args %s", str(args))
# Build the config based on args
pcluster_config = PclusterConfig(
config_file=args.config_file, cluster_label=args.cluster_template, fail_on_file_absence=True
)
pcluster_config.validate()
# get CFN parameters, template url and tags from config
cluster_section = pcluster_config.get_section("cluster")
cfn_params = pcluster_config.to_cfn()
_check_for_updates(pcluster_config)
batch_temporary_bucket = None
try:
cfn_client = boto3.client("cloudformation")
stack_name = utils.get_stack_name(args.cluster_name)
# If scheduler is awsbatch create bucket with resources
if cluster_section.get_param_value("scheduler") == "awsbatch":
batch_resources = pkg_resources.resource_filename(__name__, "resources/batch")
batch_temporary_bucket = _create_bucket_with_batch_resources(
stack_name=stack_name, resources_dir=batch_resources, region=pcluster_config.region
)
cfn_params["ResourcesS3Bucket"] = batch_temporary_bucket
LOGGER.info("Creating stack named: %s", stack_name)
LOGGER.debug(cfn_params)
# determine the CloudFormation Template URL to use
template_url = _evaluate_pcluster_template_url(pcluster_config, preferred_template_url=args.template_url)
# merge tags from configuration, command-line and internal ones
tags = _evaluate_tags(pcluster_config, preferred_tags=args.tags)
# append extra parameters from command-line
if args.extra_parameters:
LOGGER.debug("Adding extra parameters to the CFN parameters")
cfn_params.update(dict(args.extra_parameters))
# prepare input parameters for stack creation and create the stack
LOGGER.debug(cfn_params)
params = [{"ParameterKey": key, "ParameterValue": value} for key, value in cfn_params.items()]
stack = cfn_client.create_stack(
StackName=stack_name,
TemplateURL=template_url,
Parameters=params,
Capabilities=["CAPABILITY_IAM"],
DisableRollback=args.norollback,
Tags=tags,
)
LOGGER.debug("StackId: %s", stack.get("StackId"))
if not args.nowait:
utils.verify_stack_creation(stack_name, cfn_client)
LOGGER.info("")
result_stack = utils.get_stack(stack_name, cfn_client)
_print_stack_outputs(result_stack)
else:
stack_status = utils.get_stack(stack_name, cfn_client).get("StackStatus")
LOGGER.info("Status: %s", stack_status)
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.stdout.flush()
if batch_temporary_bucket:
utils.delete_s3_bucket(bucket_name=batch_temporary_bucket)
sys.exit(1)
except KeyboardInterrupt:
LOGGER.info("\nExiting...")
sys.exit(0)
except KeyError as e:
LOGGER.critical("ERROR: KeyError - reason:")
LOGGER.critical(e)
if batch_temporary_bucket:
utils.delete_s3_bucket(bucket_name=batch_temporary_bucket)
sys.exit(1)
except Exception as e:
LOGGER.critical(e)
if batch_temporary_bucket:
utils.delete_s3_bucket(bucket_name=batch_temporary_bucket)
sys.exit(1)
def _evaluate_pcluster_template_url(pcluster_config, preferred_template_url=None):
"""
Determine the CloudFormation Template URL to use.
Order is 1) preferred_template_url 2) Config file 3) default for version + region.
:param pcluster_config: PclusterConfig, it can contain the template_url
:param preferred_template_url: preferred template url to use, if not None
:return: the evaluated template url
"""
configured_template_url = pcluster_config.get_section("cluster").get_param_value("template_url")
return preferred_template_url or configured_template_url or _get_default_template_url(pcluster_config.region)
def _evaluate_tags(pcluster_config, preferred_tags=None):
"""
Merge given tags to the ones defined in the configuration file and convert them into the Key/Value format.
:param pcluster_config: PclusterConfig, it can contain tags
:param preferred_tags: tags that must take the precedence before the configured ones
:return: a merge of the tags + version tag
"""
tags = {}
configured_tags = pcluster_config.get_section("cluster").get_param_value("tags")
if configured_tags:
tags.update(configured_tags)
if preferred_tags:
# add tags from command line parameter, by overriding configured ones
tags.update(preferred_tags)
# add pcluster version
tags["Version"] = utils.get_installed_version()
# convert to CFN tags
return [{"Key": tag, "Value": tags[tag]} for tag in tags]
def _print_stack_outputs(stack):
"""
Print a limited set of the CloudFormation Stack outputs.
:param stack: the stack dictionary
"""
whitelisted_outputs = [
"ClusterUser",
"MasterPrivateIP",
"MasterPublicIP",
"BatchComputeEnvironmentArn",
"BatchJobQueueArn",
"BatchJobDefinitionArn",
"BatchJobDefinitionMnpArn",
"BatchUserRole",
]
if _is_ganglia_enabled(stack.get("Parameters")):
whitelisted_outputs.extend(["GangliaPrivateURL", "GangliaPublicURL"])
for output in stack.get("Outputs", []):
output_key = output.get("OutputKey")
if output_key in whitelisted_outputs:
LOGGER.info("%s: %s", output_key, output.get("OutputValue"))
def _is_ganglia_enabled(parameters):
is_ganglia_enabled = False
try:
cfn_extra_json = utils.get_cfn_param(parameters, "ExtraJson")
is_ganglia_enabled = json.loads(cfn_extra_json).get("cfncluster").get("ganglia_enabled") == "yes"
except Exception:
pass
return is_ganglia_enabled
def update(args): # noqa: C901 FIXME!!!
LOGGER.info("Updating: %s", args.cluster_name)
stack_name = utils.get_stack_name(args.cluster_name)
pcluster_config = PclusterConfig(
config_file=args.config_file, cluster_label=args.cluster_template, fail_on_file_absence=True
)
pcluster_config.validate()
cfn_params = pcluster_config.to_cfn()
cluster_section = pcluster_config.get_section("cluster")
cfn = boto3.client("cloudformation")
if cluster_section.get_param_value("scheduler") != "awsbatch":
if not args.reset_desired:
asg_name = _get_asg_name(stack_name)
desired_capacity = (
boto3.client("autoscaling")
.describe_auto_scaling_groups(AutoScalingGroupNames=[asg_name])
.get("AutoScalingGroups")[0]
.get("DesiredCapacity")
)
cfn_params["DesiredSize"] = str(desired_capacity)
else:
if args.reset_desired:
LOGGER.info("reset_desired flag does not work with awsbatch scheduler")
params = utils.get_stack(stack_name, cfn).get("Parameters")
for parameter in params:
if parameter.get("ParameterKey") == "ResourcesS3Bucket":
cfn_params["ResourcesS3Bucket"] = parameter.get("ParameterValue")
try:
LOGGER.debug(cfn_params)
if args.extra_parameters:
LOGGER.debug("Adding extra parameters to the CFN parameters")
cfn_params.update(dict(args.extra_parameters))
cfn_params = [{"ParameterKey": key, "ParameterValue": value} for key, value in cfn_params.items()]
LOGGER.info("Calling update_stack")
cfn.update_stack(
StackName=stack_name, UsePreviousTemplate=True, Parameters=cfn_params, Capabilities=["CAPABILITY_IAM"]
)
stack_status = utils.get_stack(stack_name, cfn).get("StackStatus")
if not args.nowait:
while stack_status == "UPDATE_IN_PROGRESS":
stack_status = utils.get_stack(stack_name, cfn).get("StackStatus")
events = cfn.describe_stack_events(StackName=stack_name).get("StackEvents")[0]
resource_status = (
"Status: %s - %s" % (events.get("LogicalResourceId"), events.get("ResourceStatus"))
).ljust(80)
sys.stdout.write("\r%s" % resource_status)
sys.stdout.flush()
time.sleep(5)
else:
stack_status = utils.get_stack(stack_name, cfn).get("StackStatus")
LOGGER.info("Status: %s", stack_status)
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.exit(1)
except KeyboardInterrupt:
LOGGER.info("\nExiting...")
sys.exit(0)
def start(args):
"""Restore ASG limits or awsbatch CE to min/max/desired."""
stack_name = utils.get_stack_name(args.cluster_name)
pcluster_config = PclusterConfig(config_file=args.config_file, cluster_name=args.cluster_name)
cluster_section = pcluster_config.get_section("cluster")
if cluster_section.get_param_value("scheduler") == "awsbatch":
LOGGER.info("Enabling AWS Batch compute environment : %s", args.cluster_name)
max_vcpus = cluster_section.get_param_value("max_vcpus")
desired_vcpus = cluster_section.get_param_value("desired_vcpus")
min_vcpus = cluster_section.get_param_value("min_vcpus")
ce_name = _get_batch_ce(stack_name)
_start_batch_ce(ce_name=ce_name, min_vcpus=min_vcpus, desired_vcpus=desired_vcpus, max_vcpus=max_vcpus)
else:
LOGGER.info("Starting compute fleet : %s", args.cluster_name)
max_queue_size = cluster_section.get_param_value("max_queue_size")
min_desired_size = (
cluster_section.get_param_value("initial_queue_size")
if cluster_section.get_param_value("maintain_initial_size")
else 0
)
asg_name = _get_asg_name(stack_name)
_set_asg_limits(asg_name=asg_name, min=min_desired_size, max=max_queue_size, desired=min_desired_size)
def stop(args):
"""Set ASG limits or awsbatch ce to min/max/desired = 0/0/0."""
stack_name = utils.get_stack_name(args.cluster_name)
pcluster_config = PclusterConfig(config_file=args.config_file, cluster_name=args.cluster_name)
cluster_section = pcluster_config.get_section("cluster")
if cluster_section.get_param_value("scheduler") == "awsbatch":
LOGGER.info("Disabling AWS Batch compute environment : %s", args.cluster_name)
ce_name = _get_batch_ce(stack_name)
_stop_batch_ce(ce_name=ce_name)
else:
LOGGER.info("Stopping compute fleet : %s", args.cluster_name)
asg_name = _get_asg_name(stack_name)
_set_asg_limits(asg_name=asg_name, min=0, max=0, desired=0)
def _get_batch_ce(stack_name):
"""
Get name of the AWS Batch Compute Environment.
:param stack_name: name of the master stack
:param config: config
:return: ce_name or exit if not found
"""
cfn = boto3.client("cloudformation")
try:
outputs = cfn.describe_stacks(StackName=stack_name).get("Stacks")[0].get("Outputs")
return utils.get_stack_output_value(outputs, "BatchComputeEnvironmentArn")
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.exit(1)
def _get_pcluster_version_from_stack(stack):
"""
Get the version of the stack if tagged.
:param stack: stack object
:return: version or empty string
"""
return next((tag.get("Value") for tag in stack.get("Tags") if tag.get("Key") == "Version"), "")
def _colorize(stack_status, args):
"""
Color the output, COMPLETE = green, FAILED = red, IN_PROGRESS = yellow.
:param stack_status: stack status
:param args: args
:return: colorized status string
"""
if not args.color:
return stack_status
end = "0m"
status_to_color = {"COMPLETE": "0;32m", "FAILED": "0;31m", "IN_PROGRESS": "10;33m"}
for status_label in status_to_color:
if status_label in stack_status:
return "\033[%s%s\033[%s" % (status_to_color[status_label], stack_status, end)
def list_stacks(args):
# Parse configuration file to read the AWS section
PclusterConfig.init_aws(config_file=args.config_file)
try:
result = []
for stack in utils.paginate_boto3(boto3.client("cloudformation").describe_stacks):
if stack.get("ParentId") is None and stack.get("StackName").startswith(utils.PCLUSTER_STACK_PREFIX):
pcluster_version = _get_pcluster_version_from_stack(stack)
result.append(
[
stack.get("StackName")[len(utils.PCLUSTER_STACK_PREFIX) :], # noqa: E203
_colorize(stack.get("StackStatus"), args),
pcluster_version,
]
)
LOGGER.info(tabulate(result, tablefmt="plain"))
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.exit(1)
except KeyboardInterrupt:
LOGGER.info("Exiting...")
sys.exit(0)
def _poll_master_server_state(stack_name):
ec2 = boto3.client("ec2")
try:
master_id = utils.get_master_server_id(stack_name)
instance = ec2.describe_instance_status(InstanceIds=[master_id]).get("InstanceStatuses")[0]
state = instance.get("InstanceState").get("Name")
sys.stdout.write("\rMasterServer: %s" % state.upper())
sys.stdout.flush()
while state not in ["running", "stopped", "terminated", "shutting-down"]:
time.sleep(5)
state = (
ec2.describe_instance_status(InstanceIds=[master_id])
.get("InstanceStatuses")[0]
.get("InstanceState")
.get("Name")
)
master_status = "\r\033[KMasterServer: %s" % state.upper()
sys.stdout.write(master_status)
sys.stdout.flush()
if state in ["terminated", "shutting-down"]:
LOGGER.info("State: %s is irrecoverable. Cluster needs to be re-created.", state)
sys.exit(1)
master_status = "\rMasterServer: %s\n" % state.upper()
sys.stdout.write(master_status)
sys.stdout.flush()
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.stdout.flush()
sys.exit(1)
except KeyboardInterrupt:
LOGGER.info("\nExiting...")
sys.exit(0)
return state
def _get_ec2_instances(stack):
try:
resources = boto3.client("cloudformation").describe_stack_resources(StackName=stack).get("StackResources")
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.stdout.flush()
sys.exit(1)
temp_instances = [r for r in resources if r.get("ResourceType") == "AWS::EC2::Instance"]
stack_instances = []
for instance in temp_instances:
stack_instances.append([instance.get("LogicalResourceId"), instance.get("PhysicalResourceId")])
return stack_instances
def _get_asg_name(stack_name):
try:
resources = boto3.client("cloudformation").describe_stack_resources(StackName=stack_name).get("StackResources")
return [r for r in resources if r.get("LogicalResourceId") == "ComputeFleet"][0].get("PhysicalResourceId")
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.stdout.flush()
sys.exit(1)
except IndexError:
LOGGER.critical("Stack %s does not have a ComputeFleet", stack_name)
sys.exit(1)
def _set_asg_limits(asg_name, min, max, desired):
asg = boto3.client("autoscaling")
asg.update_auto_scaling_group(
AutoScalingGroupName=asg_name, MinSize=int(min), MaxSize=int(max), DesiredCapacity=int(desired)
)
def _get_asg_instances(stack):
asg = boto3.client("autoscaling")
asg_name = _get_asg_name(stack)
asg = asg.describe_auto_scaling_groups(AutoScalingGroupNames=[asg_name]).get("AutoScalingGroups")[0]
name = [tag.get("Value") for tag in asg.get("Tags") if tag.get("Key") == "aws:cloudformation:logical-id"][0]
temp_instances = []
for instance in asg.get("Instances"):
temp_instances.append([name, instance.get("InstanceId")])
return temp_instances
def _start_batch_ce(ce_name, min_vcpus, desired_vcpus, max_vcpus):
try:
boto3.client("batch").update_compute_environment(
computeEnvironment=ce_name,
state="ENABLED",
computeResources={
"minvCpus": int(min_vcpus),
"maxvCpus": int(max_vcpus),
"desiredvCpus": int(desired_vcpus),
},
)
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.exit(1)
def _stop_batch_ce(ce_name):
boto3.client("batch").update_compute_environment(computeEnvironment=ce_name, state="DISABLED")
def instances(args):
stack_name = utils.get_stack_name(args.cluster_name)
pcluster_config = PclusterConfig(config_file=args.config_file, cluster_name=args.cluster_name)
cluster_section = pcluster_config.get_section("cluster")
instances = []
instances.extend(_get_ec2_instances(stack_name))
if cluster_section.get_param_value("scheduler") != "awsbatch":
instances.extend(_get_asg_instances(stack_name))
for instance in instances:
LOGGER.info("%s %s", instance[0], instance[1])
if cluster_section.get_param_value("scheduler") == "awsbatch":
LOGGER.info("Run 'awsbhosts --cluster %s' to list the compute instances", args.cluster_name)
def ssh(args, extra_args): # noqa: C901 FIXME!!!
"""
Execute an SSH command to the master instance, according to the [aliases] section if there.
:param args: pcluster CLI args
:param extra_args: pcluster CLI extra_args
"""
pcluster_config = PclusterConfig(fail_on_error=False) # FIXME it always search for the default config file
if args.command in pcluster_config.get_section("aliases").params:
ssh_command = pcluster_config.get_section("aliases").get_param_value(args.command)
else:
ssh_command = "ssh {CFN_USER}@{MASTER_IP} {ARGS}"
try:
master_ip, username = utils.get_master_ip_and_username(args.cluster_name)
try:
from shlex import quote as cmd_quote
except ImportError:
from pipes import quote as cmd_quote
# build command
cmd = ssh_command.format(
CFN_USER=username, MASTER_IP=master_ip, ARGS=" ".join(cmd_quote(str(arg)) for arg in extra_args)
)
# run command
log_message = "SSH command: {0}".format(cmd)
if not args.dryrun:
LOGGER.debug(log_message)
os.system(cmd)
else:
LOGGER.info(log_message)
except KeyboardInterrupt:
LOGGER.info("\nExiting...")
sys.exit(0)
def status(args): # noqa: C901 FIXME!!!
stack_name = utils.get_stack_name(args.cluster_name)
# Parse configuration file to read the AWS section
PclusterConfig.init_aws(config_file=args.config_file)
cfn = boto3.client("cloudformation")
try:
stack_status = utils.get_stack(stack_name, cfn).get("StackStatus")
sys.stdout.write("\rStatus: %s" % stack_status)
sys.stdout.flush()
if not args.nowait:
while stack_status not in [
"CREATE_COMPLETE",
"UPDATE_COMPLETE",
"UPDATE_ROLLBACK_COMPLETE",
"ROLLBACK_COMPLETE",
"CREATE_FAILED",
"DELETE_FAILED",
]:
time.sleep(5)
stack_status = utils.get_stack(stack_name, cfn).get("StackStatus")
events = cfn.describe_stack_events(StackName=stack_name).get("StackEvents")[0]
resource_status = (
"Status: %s - %s" % (events.get("LogicalResourceId"), events.get("ResourceStatus"))
).ljust(80)
sys.stdout.write("\r%s" % resource_status)
sys.stdout.flush()
sys.stdout.write("\rStatus: %s\n" % stack_status)
sys.stdout.flush()
if stack_status in ["CREATE_COMPLETE", "UPDATE_COMPLETE"]:
state = _poll_master_server_state(stack_name)
if state == "running":
stack = utils.get_stack(stack_name, cfn)
_print_stack_outputs(stack)
elif stack_status in ["ROLLBACK_COMPLETE", "CREATE_FAILED", "DELETE_FAILED", "UPDATE_ROLLBACK_COMPLETE"]:
events = cfn.describe_stack_events(StackName=stack_name).get("StackEvents")
for event in events:
if event.get("ResourceStatus") in ["CREATE_FAILED", "DELETE_FAILED", "UPDATE_FAILED"]:
LOGGER.info(
"%s %s %s %s %s",
event.get("Timestamp"),
event.get("ResourceStatus"),
event.get("ResourceType"),
event.get("LogicalResourceId"),
event.get("ResourceStatusReason"),
)
else:
sys.stdout.write("\n")
sys.stdout.flush()
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.stdout.flush()
sys.exit(1)
except KeyboardInterrupt:
LOGGER.info("\nExiting...")
sys.exit(0)
def delete(args):
saw_update = False
LOGGER.info("Deleting: %s", args.cluster_name)
stack_name = utils.get_stack_name(args.cluster_name)
# Parse configuration file to read the AWS section
PclusterConfig.init_aws(config_file=args.config_file)
cfn = boto3.client("cloudformation")
try:
# delete_stack does not raise an exception if stack does not exist
# Use describe_stacks to explicitly check if the stack exists
cfn.describe_stacks(StackName=stack_name)
cfn.delete_stack(StackName=stack_name)
saw_update = True
stack_status = utils.get_stack(stack_name, cfn).get("StackStatus")
sys.stdout.write("\rStatus: %s" % stack_status)
sys.stdout.flush()
LOGGER.debug("Status: %s", stack_status)
if not args.nowait:
while stack_status == "DELETE_IN_PROGRESS":
time.sleep(5)
stack_status = utils.get_stack(stack_name, cfn).get("StackStatus")
events = cfn.describe_stack_events(StackName=stack_name).get("StackEvents")[0]
resource_status = (
"Status: %s - %s" % (events.get("LogicalResourceId"), events.get("ResourceStatus"))
).ljust(80)
sys.stdout.write("\r%s" % resource_status)
sys.stdout.flush()
sys.stdout.write("\rStatus: %s\n" % stack_status)
sys.stdout.flush()
LOGGER.debug("Status: %s", stack_status)
else:
sys.stdout.write("\n")
sys.stdout.flush()
if stack_status == "DELETE_FAILED":
LOGGER.info("Cluster did not delete successfully. Run 'pcluster delete %s' again", args.cluster_name)
except ClientError as e:
if e.response.get("Error").get("Message").endswith("does not exist"):
if saw_update:
LOGGER.info("\nCluster deleted successfully.")
sys.exit(0)
LOGGER.critical(e.response.get("Error").get("Message"))
sys.stdout.flush()
sys.exit(1)
except KeyboardInterrupt:
LOGGER.info("\nExiting...")
sys.exit(0)
def _get_cookbook_url(region, template_url, args, tmpdir):
if args.custom_ami_cookbook is not None:
return args.custom_ami_cookbook
cookbook_version = _get_cookbook_version(template_url, tmpdir)
s3_suffix = ".cn" if region.startswith("cn") else ""
return "https://s3.%s.amazonaws.com%s/%s-aws-parallelcluster/cookbooks/%s.tgz" % (
region,
s3_suffix,
region,
cookbook_version,
)
def _get_cookbook_version(template_url, tmpdir):
tmp_template_file = os.path.join(tmpdir, "aws-parallelcluster-template.json")
try:
LOGGER.info("Template: %s", template_url)
urlretrieve(url=template_url, filename=tmp_template_file)
with open(tmp_template_file) as cfn_file:
cfn_data = json.load(cfn_file)
return cfn_data.get("Mappings").get("PackagesVersions").get("default").get("cookbook")
except IOError as e:
LOGGER.error("Unable to download template at URL %s", template_url)
LOGGER.critical("Error: %s", str(e))
sys.exit(1)
except (ValueError, AttributeError) as e:
LOGGER.error("Unable to parse template at URL %s", template_url)
LOGGER.critical("Error: %s", str(e))
sys.exit(1)
def _get_cookbook_dir(region, template_url, args, tmpdir):
cookbook_url = ""
try:
tmp_cookbook_archive = os.path.join(tmpdir, "aws-parallelcluster-cookbook.tgz")
cookbook_url = _get_cookbook_url(region, template_url, args, tmpdir)
LOGGER.info("Cookbook: %s", cookbook_url)
urlretrieve(url=cookbook_url, filename=tmp_cookbook_archive)
tar = tarfile.open(tmp_cookbook_archive)
cookbook_archive_root = tar.firstmember.path
tar.extractall(path=tmpdir)
tar.close()
return os.path.join(tmpdir, cookbook_archive_root)
except (IOError, tarfile.ReadError) as e:
LOGGER.error("Unable to download cookbook at URL %s", cookbook_url)
LOGGER.critical("Error: %s", str(e))
sys.exit(1)
def _dispose_packer_instance(results):
time.sleep(2)
try:
ec2_client = boto3.client("ec2")
instance = ec2_client.describe_instance_status(
InstanceIds=[results["PACKER_INSTANCE_ID"]], IncludeAllInstances=True
).get("InstanceStatuses")[0]
instance_state = instance.get("InstanceState").get("Name")
if instance_state in ["running", "pending", "stopping", "stopped"]:
LOGGER.info("Terminating Instance %s created by Packer", results["PACKER_INSTANCE_ID"])
ec2_client.terminate_instances(InstanceIds=[results["PACKER_INSTANCE_ID"]])
except ClientError as e:
LOGGER.critical(e.response.get("Error").get("Message"))
sys.exit(1)
def _run_packer(packer_command, packer_env):
erase_line = "\x1b[2K"
_command = shlex.split(packer_command)
results = {}
_, path_log = mkstemp(prefix="packer.log." + datetime.datetime.now().strftime("%Y%m%d-%H%M%S" + "."), text=True)
LOGGER.info("Packer log: %s", path_log)
try:
dev_null = open(os.devnull, "rb")
packer_env.update(os.environ.copy())
process = sub.Popen(
_command, env=packer_env, stdout=sub.PIPE, stderr=sub.STDOUT, stdin=dev_null, universal_newlines=True
)
with open(path_log, "w") as packer_log:
while process.poll() is None:
output_line = process.stdout.readline().strip()
packer_log.write("\n%s" % output_line)
packer_log.flush()
sys.stdout.write(erase_line)
sys.stdout.write("\rPacker status: %s" % output_line[:90] + (output_line[90:] and ".."))
sys.stdout.flush()
if output_line.find("packer build") > 0:
results["PACKER_COMMAND"] = output_line
if output_line.find("Instance ID:") > 0:
results["PACKER_INSTANCE_ID"] = output_line.rsplit(":", 1)[1].strip(" \n\t")
sys.stdout.write(erase_line)
sys.stdout.write("\rPacker Instance ID: %s\n" % results["PACKER_INSTANCE_ID"])
sys.stdout.flush()
if output_line.find("AMI:") > 0:
results["PACKER_CREATED_AMI"] = output_line.rsplit(":", 1)[1].strip(" \n\t")
if output_line.find("Prevalidating AMI Name:") > 0:
results["PACKER_CREATED_AMI_NAME"] = output_line.rsplit(":", 1)[1].strip(" \n\t")
sys.stdout.write("\texit code %s\n" % process.returncode)
sys.stdout.flush()
return results
except sub.CalledProcessError:
sys.stdout.flush()
LOGGER.error("Failed to run %s\n", _command)
sys.exit(1)
except (IOError, OSError):
sys.stdout.flush()
LOGGER.error("Failed to run %s\nCommand not found", packer_command)
sys.exit(1)
except KeyboardInterrupt:
sys.stdout.flush()
LOGGER.info("\nExiting...")
sys.exit(0)
finally:
dev_null.close()
if results.get("PACKER_INSTANCE_ID"):
_dispose_packer_instance(results)
def _print_create_ami_results(results):
if results.get("PACKER_CREATED_AMI"):
LOGGER.info(
"\nCustom AMI %s created with name %s", results["PACKER_CREATED_AMI"], results["PACKER_CREATED_AMI_NAME"]
)
print(
"\nTo use it, add the following variable to the AWS ParallelCluster config file, "
"under the [cluster ...] section"
)
print("custom_ami = %s" % results["PACKER_CREATED_AMI"])
else:
LOGGER.info("\nNo custom AMI created")
def create_ami(args):
LOGGER.info("Building AWS ParallelCluster AMI. This could take a while...")
LOGGER.debug("Building AMI based on args %s", str(args))
results = {}
instance_type = args.instance_type
try:
# FIXME it doesn't work if there is no a default section
pcluster_config = PclusterConfig(config_file=args.config_file, fail_on_file_absence=True)
vpc_section = pcluster_config.get_section("vpc")
vpc_id = args.vpc_id if args.vpc_id else vpc_section.get_param_value("vpc_id")
subnet_id = args.subnet_id if args.subnet_id else vpc_section.get_param_value("master_subnet_id")
packer_env = {
"CUSTOM_AMI_ID": args.base_ami_id,
"AWS_FLAVOR_ID": instance_type,
"AMI_NAME_PREFIX": args.custom_ami_name_prefix,
"AWS_VPC_ID": vpc_id,
"AWS_SUBNET_ID": subnet_id,
"ASSOCIATE_PUBLIC_IP": "true" if args.associate_public_ip else "false",
}
aws_section = pcluster_config.get_section("aws")
aws_region = aws_section.get_param_value("aws_region_name")
if aws_section and aws_section.get_param_value("aws_access_key_id"):
packer_env["AWS_ACCESS_KEY_ID"] = aws_section.get_param_value("aws_access_key_id")
if aws_section and aws_section.get_param_value("aws_secret_access_key"):
packer_env["AWS_SECRET_ACCESS_KEY"] = aws_section.get_param_value("aws_secret_access_key")
LOGGER.info("Base AMI ID: %s", args.base_ami_id)
LOGGER.info("Base AMI OS: %s", args.base_ami_os)
LOGGER.info("Instance Type: %s", instance_type)
LOGGER.info("Region: %s", aws_region)
LOGGER.info("VPC ID: %s", vpc_id)
LOGGER.info("Subnet ID: %s", subnet_id)
template_url = _evaluate_pcluster_template_url(pcluster_config)
tmp_dir = mkdtemp()
cookbook_dir = _get_cookbook_dir(aws_region, template_url, args, tmp_dir)
packer_command = (
cookbook_dir
+ "/amis/build_ami.sh --os "
+ args.base_ami_os
+ " --partition region"
+ " --region "
+ aws_region
+ " --custom"
)
results = _run_packer(packer_command, packer_env)
except KeyboardInterrupt:
LOGGER.info("\nExiting...")
sys.exit(0)
finally:
_print_create_ami_results(results)
if "tmp_dir" in locals() and tmp_dir:
rmtree(tmp_dir)
def _get_default_template_url(region):
return (
"https://s3.{REGION}.amazonaws.com{SUFFIX}/{REGION}-aws-parallelcluster/templates/"
"aws-parallelcluster-{VERSION}.cfn.json".format(
REGION=region, SUFFIX=".cn" if region.startswith("cn") else "", VERSION=utils.get_installed_version()
)
)
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
9_Dynamic/4.py
|
# https://www.hackerrank.com/challenges/decibinary-numbers/problem
# 7/8 Test Cases Passed
#!/bin/python3
import math
import os
import random
import re
import sys
import bisect
from collections import defaultdict, Counter
#
# Complete the 'decibinaryNumbers' function below.
#
# The function is expected to return a LONG_INTEGER.
# The function accepts LONG_INTEGER x as parameter.
#
class Decibinary:
def __init__(self):
self.COUNT = [[1, 1]]
self.cum_sums = [1]
self.min_dig = [0]
for p in range(20): self.min_dig.append(9 * 2 ** p + self.min_dig[-1])
def decibinaryNumbers(self, x):
if x > self.cum_sums[-1]:
n = len(self.COUNT)
num=x
while self.cum_sums[-1] < num:
min_digits = bisect.bisect_left(self.min_dig, n)
max_digits = math.floor(math.log(n, 2)) + 1
self.COUNT.append([0] * (max_digits + 1))
for m in range(min_digits, max_digits + 1):
self.COUNT[n][m] = self.COUNT[n][m - 1]
for d in range(1, 10):
remainder = n - d * 2 ** (m - 1)
if remainder >= 0:
self.COUNT[n][m] += self.COUNT[remainder][min(m - 1, len(self.COUNT[remainder]) - 1)]
else:
break
self.cum_sums.append(self.cum_sums[-1] + self.COUNT[-1][-1])
n += 1
if x == 1: return 0
n = bisect.bisect_left(self.cum_sums, x)
n_rem = x - self.cum_sums[n - 1]
m = bisect.bisect_left(self.COUNT[n], n_rem)
m_rem = n_rem - self.COUNT[n][m - 1]
return int(self.reconstruct(n, m, m_rem))
def reconstruct(self, n, m, rem, partial=0):
if m == 1: return partial + n
skipped = 0
for k in range(not partial, 10):
dig_val = k * 2 ** (m - 1)
smaller = n - dig_val
s_m = min(len(self.COUNT[smaller]) - 1, m - 1)
skipped += self.COUNT[smaller][s_m]
if skipped >= rem:
partial += k * 10 ** (m-1) #math.pow(10,(m - 1))
new_rem = rem - (skipped - self.COUNT[smaller][s_m])
return self.reconstruct(smaller, s_m, new_rem, partial)
if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')
q = int(input().strip())
db = Decibinary()
for q_itr in range(q):
x = int(input().strip())
result = db.decibinaryNumbers(x)
fptr.write(str(result) + '\n')
fptr.close()
|
[] |
[] |
[
"OUTPUT_PATH"
] |
[]
|
["OUTPUT_PATH"]
|
python
| 1 | 0 | |
src/src/create_tf_record.py
|
# -*-coding: utf-8 -*-
"""
@Project: create_tfrecord
@File : create_tfrecord.py
@Author : panjq
@E-mail : [email protected]
@Date : 2018-07-27 17:19:54
@desc : 将图片数据保存为单个tfrecord文件
"""
##########################################################################
import tensorflow as tf
import numpy as np
import os
import cv2
import matplotlib.pyplot as plt
import random
from PIL import Image
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
train_path = './train_new/img'
test_path = './test_new/img'
list = set(os.listdir(test_path))
classes=sorted(list,key=str.lower)
print(classes)
##########################################################################
def _int64_feature(value):
return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
# 生成字符串型的属性
def _bytes_feature(value):
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
# 生成实数型的属性
def float_list_feature(value):
return tf.train.Feature(float_list=tf.train.FloatList(value=value))
def get_example_nums(tf_records_filenames):
'''
统计tf_records图像的个数(example)个数
:param tf_records_filenames: tf_records文件路径
:return:
'''
nums= 0
for record in tf.python_io.tf_record_iterator(tf_records_filenames):
nums += 1
return nums
def show_image(title,image):
'''
显示图片
:param title: 图像标题
:param image: 图像的数据
:return:
'''
# plt.figure("show_image")
# print(image.dtype)
plt.imshow(image)
plt.axis('on') # 关掉坐标轴为 off
plt.title(title) # 图像题目
plt.show()
# def load_labels_file(filename,labels_num=1,shuffle=False):
# '''
# 载图txt文件，文件中每行为一个图片信息，且以空格隔开：图像路径 标签1 标签2，如：test_image/1.jpg 0 2
# :param filename:
# :param labels_num :labels个数
# :param shuffle :是否打乱顺序
# :return:images type->list
# :return:labels type->list
# '''
# images=[]
# labels=[]
# with open(filename) as f:
# lines_list=f.readlines()
# if shuffle:
# random.shuffle(lines_list)
#
# for lines in lines_list:
# line=lines.rstrip().split(' ')
# label=[]
# for i in range(labels_num):
# label.append(int(line[i+1]))
# images.append(line[0])
# labels.append(label)
# return images,labels
def load_labels_file(filename,num=1,shuffle=False):
'''
载图txt文件，文件中每行为一个图片信息，且以空格隔开：图像路径 标签1 标签2，如：test_image/1.jpg 0 2
:param filename:
:param labels_num :labels个数
:param shuffle :是否打乱顺序
:return:images type->list
:return:labels type->list
'''
images=[]
labels=[]
# with open(filename) as f:
# lines_list=f.readlines()
# if shuffle:
# random.shuffle(lines_list)
#
# for lines in lines_list:
# line=lines.rstrip().split(' ')
# label=[]
# for i in range(labels_num):
# label.append(int(line[i+1]))
# images.append(line[0])
# labels.append(label)
# return images,labels
for index,name in enumerate(classes):
# print(index,name)
class_path = filename+'/'+name+'/'
# print(class_path)
for img_name in os.listdir(class_path):
img_path = class_path+img_name
# print(img_path)
images.append(img_path)
labels.append(index)
# img = Image.open(img_path)
# img = img.resize((224,224))
# img_raw = img.tobytes()
# with open(train_label,'a') as f:
# f.write(str(index)+'\n')
randnum = random.randint(0, 100)
random.seed(randnum)
random.shuffle(images)
random.seed(randnum)
random.shuffle(labels)
return images,labels
def read_image(filename, resize_height, resize_width,normalization=False):
'''
读取图片数据,默认返回的是uint8,[0,255]
:param filename:
:param resize_height:
:param resize_width:
:param normalization:是否归一化到[0.,1.0]
:return: 返回的图片数据
'''
bgr_image = cv2.imread(filename)
if len(bgr_image.shape)==2:#若是灰度图则转为三通道
print("Warning:gray image",filename)
bgr_image = cv2.cvtColor(bgr_image, cv2.COLOR_GRAY2BGR)
rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)#将BGR转为RGB
# show_image(filename,rgb_image)
# rgb_image=Image.open(filename)
if resize_height>0 and resize_width>0:
rgb_image=cv2.resize(rgb_image,(resize_width,resize_height))
rgb_image=np.asanyarray(rgb_image)
if normalization:
# 不能写成:rgb_image=rgb_image/255
rgb_image=rgb_image/255.0
# show_image("src resize image",image)
return rgb_image
def get_batch_images(images,labels,batch_size,labels_nums,one_hot=False,shuffle=False,num_threads=64):
'''
:param images:图像
:param labels:标签
:param batch_size:
:param labels_nums:标签个数
:param one_hot:是否将labels转为one_hot的形式
:param shuffle:是否打乱顺序,一般train时shuffle=True,验证时shuffle=False
:return:返回batch的images和labels
'''
min_after_dequeue = 200
capacity = min_after_dequeue + 3 * batch_size # 保证capacity必须大于min_after_dequeue参数值
if shuffle:
images_batch, labels_batch = tf.train.shuffle_batch([images,labels],
batch_size=batch_size,
capacity=capacity,
min_after_dequeue=min_after_dequeue,
num_threads=num_threads)
else:
images_batch, labels_batch = tf.train.batch([images,labels],
batch_size=batch_size,
capacity=capacity,
num_threads=num_threads)
if one_hot:
labels_batch = tf.one_hot(labels_batch, labels_nums, 1, 0)
return images_batch,labels_batch
def read_records(filename,resize_height, resize_width,type=None):
'''
解析record文件:源文件的图像数据是RGB,uint8,[0,255],一般作为训练数据时,需要归一化到[0,1]
:param filename:
:param resize_height:
:param resize_width:
:param type:选择图像数据的返回类型
None:默认将uint8-[0,255]转为float32-[0,255]
normalization:归一化float32-[0,1]
centralization:归一化float32-[0,1],再减均值中心化
:return:
'''
# 创建文件队列,不限读取的数量
filename_queue = tf.train.string_input_producer([filename])
# create a reader from file queue
reader = tf.TFRecordReader()
# reader从文件队列中读入一个序列化的样本
_, serialized_example = reader.read(filename_queue)
# get feature from serialized example
# 解析符号化的样本
features = tf.parse_single_example(
serialized_example,
features={
'image_raw': tf.FixedLenFeature([], tf.string),
'height': tf.FixedLenFeature([], tf.int64),
'width': tf.FixedLenFeature([], tf.int64),
'depth': tf.FixedLenFeature([], tf.int64),
'label': tf.FixedLenFeature([], tf.int64)
}
)
tf_image = tf.decode_raw(features['image_raw'], tf.uint8)#获得图像原始的数据
tf_height = features['height']
tf_width = features['width']
tf_depth = features['depth']
tf_label = tf.cast(features['label'], tf.int32)
# PS:恢复原始图像数据,reshape的大小必须与保存之前的图像shape一致,否则出错
# tf_image=tf.reshape(tf_image, [-1]) # 转换为行向量
tf_image=tf.reshape(tf_image, [resize_height, resize_width, 3]) # 设置图像的维度
# 恢复数据后,才可以对图像进行resize_images:输入uint->输出float32
# tf_image=tf.image.resize_images(tf_image,[224, 224])
# 存储的图像类型为uint8,tensorflow训练时数据必须是tf.float32
if type is None:
tf_image = tf.cast(tf_image, tf.float32)
elif type=='normalization':# [1]若需要归一化请使用:
# 仅当输入数据是uint8,才会归一化[0,255]
# tf_image = tf.image.convert_image_dtype(tf_image, tf.float32)
tf_image = tf.cast(tf_image, tf.float32) * (1. / 255.0) # 归一化
elif type=='centralization':
# 若需要归一化,且中心化,假设均值为0.5,请使用:
tf_image = tf.cast(tf_image, tf.float32) * (1. / 255) - 0.5 #中心化
# 这里仅仅返回图像和标签
# return tf_image, tf_height,tf_width,tf_depth,tf_label
return tf_image,tf_label
def create_records(image_dir, output_record_dir, resize_height, resize_width,shuffle,log=5):
'''
实现将图像原始数据,label,长,宽等信息保存为record文件
注意:读取的图像数据默认是uint8,再转为tf的字符串型BytesList保存,解析请需要根据需要转换类型
:param image_dir:原始图像的目录
:param file:输入保存图片信息的txt文件(image_dir+file构成图片的路径)
:param output_record_dir:保存record文件的路径
:param resize_height:
:param resize_width:
PS:当resize_height或者resize_width=0是,不执行resize
:param shuffle:是否打乱顺序
:param log:log信息打印间隔
'''
# 加载文件,仅获取一个label
images_list, labels_list=load_labels_file(image_dir,1,shuffle)
writer = tf.python_io.TFRecordWriter(output_record_dir)
for i, [image_name, labels] in enumerate(zip(images_list, labels_list)):
image_path=image_name
# print(image_path)
# print(labels)
if not os.path.exists(image_path):
print('Err:no image',image_path)
continue
image = read_image(image_path, resize_height, resize_width)
image_raw = image.tostring()
if i%log==0 or i==len(images_list)-1:
print('------------processing:%d-th------------' % (i))
print('current image_path=%s' % (image_path),'shape:{}'.format(image.shape),'labels:{}'.format(labels))
# 这里仅保存一个label,多label适当增加"'label': _int64_feature(label)"项
label=labels
example = tf.train.Example(features=tf.train.Features(feature={
'image_raw': _bytes_feature(image_raw),
'height': _int64_feature(image.shape[0]),
'width': _int64_feature(image.shape[1]),
'depth': _int64_feature(image.shape[2]),
'labels': _int64_feature(label)
}))
writer.write(example.SerializeToString())
writer.close()
def disp_records(record_file,resize_height, resize_width,show_nums=4):
'''
解析record文件，并显示show_nums张图片，主要用于验证生成record文件是否成功
:param tfrecord_file: record文件路径
:return:
'''
# 读取record函数
tf_image, tf_label = read_records(record_file,resize_height,resize_width,type='normalization')
# 显示前4个图片
init_op = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init_op)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for i in range(show_nums):
image,label = sess.run([tf_image,tf_label]) # 在会话中取出image和label
# image = tf_image.eval()
# 直接从record解析的image是一个向量,需要reshape显示
# image = image.reshape([height,width,depth])
#print('shape:{},tpye:{},labels:{}'.format(image.shape,image.dtype,label))
# pilimg = Image.fromarray(np.asarray(image_eval_reshape))
# pilimg.show()
show_image("image:%d"%(label),image)
coord.request_stop()
coord.join(threads)
def batch_test(record_file,resize_height, resize_width):
'''
:param record_file: record文件路径
:param resize_height:
:param resize_width:
:return:
:PS:image_batch, label_batch一般作为网络的输入
'''
# 读取record函数
tf_image,tf_label = read_records(record_file,resize_height,resize_width,type='normalization')
image_batch, label_batch= get_batch_images(tf_image,tf_label,batch_size=4,labels_nums=5,one_hot=False,shuffle=False)
init = tf.global_variables_initializer()
with tf.Session() as sess: # 开始一个会话
sess.run(init)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
for i in range(4):
# 在会话中取出images和labels
images, labels = sess.run([image_batch, label_batch])
# 这里仅显示每个batch里第一张图片
show_image("image", images[0, :, :, :])
print('shape:{},tpye:{},labels:{}'.format(images.shape,images.dtype,labels))
# 停止所有线程
coord.request_stop()
coord.join(threads)
# if __name__ == '__main__':
# # 参数设置
#
# resize_height = 224 # 指定存储图片高度
# resize_width = 224 # 指定存储图片宽度
# shuffle=True
# log=5
# # 产生train.record文件
# image_dir='dataset/train'
# train_labels = 'dataset/train.txt' # 图片路径
# train_record_output = 'dataset/record/train.tfrecords'
# create_records(image_dir,train_labels, train_record_output, resize_height, resize_width,shuffle,log)
# train_nums=get_example_nums(train_record_output)
# print("save train example nums={}".format(train_nums))
#
# # 产生val.record文件
# image_dir='dataset/val'
# val_labels = 'dataset/val.txt' # 图片路径
# val_record_output = 'dataset/record/val.tfrecords'
# create_records(image_dir,val_labels, val_record_output, resize_height, resize_width,shuffle,log)
# val_nums=get_example_nums(val_record_output)
# print("save val example nums={}".format(val_nums))
#
# # 测试显示函数
# # disp_records(train_record_output,resize_height, resize_width)
# batch_test(train_record_output,resize_height, resize_width)
if __name__ == '__main__':
# 参数设置
resize_height = 224 # 指定存储图片高度
resize_width = 224 # 指定存储图片宽度
shuffle=True
log=5
# 产生train.record文件
image_dir='./train_new/img'
# train_labels = './onsets/train.txt' # 图片路径
train_record_output = 'train.tfrecord'
create_records(image_dir, train_record_output, resize_height, resize_width,shuffle,log)
train_nums=get_example_nums(train_record_output)
print("save train example nums={}".format(train_nums))
# 产生val.record文件
image_dir='./test_new/img'
# val_labels = './onsets/val.txt' # 图片路径
val_record_output = 'val.tfrecord'
create_records(image_dir, val_record_output, resize_height, resize_width,shuffle,log)
val_nums=get_example_nums(val_record_output)
print("save val example nums={}".format(val_nums))
# 测试显示函数
# disp_records(train_record_output,resize_height, resize_width)
# batch_test(train_record_output,resize_height, resize_width)
|
[] |
[] |
[
"CUDA_VISIBLE_DEVICES"
] |
[]
|
["CUDA_VISIBLE_DEVICES"]
|
python
| 1 | 0 | |
teuthology/__init__.py
|
import os
# Tell gevent not to patch os.waitpid() since it is susceptible to race
# conditions. See:
# http://www.gevent.org/gevent.monkey.html#gevent.monkey.patch_os
os.environ['GEVENT_NOWAITPID'] = 'true'
# Use manhole to give us a way to debug hung processes
# https://pypi.python.org/pypi/manhole
import manhole
manhole.install(
verbose=False,
# Listen for SIGUSR1
oneshot_on="USR1"
)
from gevent import monkey
monkey.patch_all(
dns=False,
# Don't patch subprocess to avoid http://tracker.ceph.com/issues/14990
subprocess=False,
)
import sys
from gevent.hub import Hub
# Don't write pyc files
sys.dont_write_bytecode = True
from .orchestra import monkey
monkey.patch_all()
import logging
import subprocess
__version__ = '1.0.0'
# do our best, but if it fails, continue with above
try:
__version__ += '-' + subprocess.check_output(
'git rev-parse --short HEAD'.split(),
cwd=os.path.dirname(os.path.realpath(__file__))
).strip()
except Exception as e:
# before logging; should be unusual
print >>sys.stderr, 'Can\'t get version from git rev-parse', e
# If we are running inside a virtualenv, ensure we have its 'bin' directory in
# our PATH. This doesn't happen automatically if scripts are called without
# first activating the virtualenv.
exec_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
if os.path.split(exec_dir)[-1] == 'bin' and exec_dir not in os.environ['PATH']:
os.environ['PATH'] = ':'.join((exec_dir, os.environ['PATH']))
# We don't need to see log entries for each connection opened
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(
logging.WARN)
# if requests doesn't bundle it, shut it up anyway
logging.getLogger('urllib3.connectionpool').setLevel(
logging.WARN)
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s.%(msecs)03d %(levelname)s:%(name)s:%(message)s')
log = logging.getLogger(__name__)
log.debug('teuthology version: %s', __version__)
def setup_log_file(log_path):
root_logger = logging.getLogger()
handlers = root_logger.handlers
for handler in handlers:
if isinstance(handler, logging.FileHandler) and \
handler.stream.name == log_path:
log.debug("Already logging to %s; not adding new handler",
log_path)
return
formatter = logging.Formatter(
fmt=u'%(asctime)s.%(msecs)03d %(levelname)s:%(name)s:%(message)s',
datefmt='%Y-%m-%dT%H:%M:%S')
handler = logging.FileHandler(filename=log_path)
handler.setFormatter(formatter)
root_logger.addHandler(handler)
root_logger.info('teuthology version: %s', __version__)
def install_except_hook():
"""
Install an exception hook that first logs any uncaught exception, then
raises it.
"""
def log_exception(exc_type, exc_value, exc_traceback):
if not issubclass(exc_type, KeyboardInterrupt):
log.critical("Uncaught exception", exc_info=(exc_type, exc_value,
exc_traceback))
sys.__excepthook__(exc_type, exc_value, exc_traceback)
sys.excepthook = log_exception
def patch_gevent_hub_error_handler():
Hub._origin_handle_error = Hub.handle_error
def custom_handle_error(self, context, type, value, tb):
if not issubclass(type, Hub.SYSTEM_ERROR + Hub.NOT_ERROR):
log.error("Uncaught exception (Hub)", exc_info=(type, value, tb))
self._origin_handle_error(context, type, value, tb)
Hub.handle_error = custom_handle_error
patch_gevent_hub_error_handler()
|
[] |
[] |
[
"GEVENT_NOWAITPID",
"PATH"
] |
[]
|
["GEVENT_NOWAITPID", "PATH"]
|
python
| 2 | 0 | |
cmd/dashboard/main.go
|
/*
Copyright 2019 The Tekton Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
"context"
"fmt"
"net/http"
"os"
"time"
routeclient "github.com/openshift/client-go/route/clientset/versioned"
"github.com/tektoncd/dashboard/pkg/controllers"
"github.com/tektoncd/dashboard/pkg/endpoints"
logging "github.com/tektoncd/dashboard/pkg/logging"
"github.com/tektoncd/dashboard/pkg/router"
clientset "github.com/tektoncd/pipeline/pkg/client/clientset/versioned"
resourceclientset "github.com/tektoncd/pipeline/pkg/client/resource/clientset/versioned"
k8sclientset "k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"knative.dev/pkg/signals"
)
// Stores config env
type config struct {
kubeConfigPath string
// Should conform with http.Server.Addr field
port string
installNamespace string
}
func main() {
// Initialize config
dashboardConfig := config{
kubeConfigPath: os.Getenv("KUBECONFIG"),
port: ":8080",
installNamespace: os.Getenv("INSTALLED_NAMESPACE"),
}
portNumber := os.Getenv("PORT")
if portNumber != "" {
dashboardConfig.port = ":" + portNumber
logging.Log.Infof("Port number from config: %s", portNumber)
}
var cfg *rest.Config
var err error
if len(dashboardConfig.kubeConfigPath) != 0 {
cfg, err = clientcmd.BuildConfigFromFlags("", dashboardConfig.kubeConfigPath)
if err != nil {
logging.Log.Errorf("Error building kubeconfig from %s: %s", dashboardConfig.kubeConfigPath, err.Error())
}
} else {
if cfg, err = rest.InClusterConfig(); err != nil {
logging.Log.Errorf("Error building kubeconfig: %s", err.Error())
}
}
pipelineClient, err := clientset.NewForConfig(cfg)
if err != nil {
logging.Log.Errorf("Error building pipeline clientset: %s", err.Error())
}
pipelineResourceClient, err := resourceclientset.NewForConfig(cfg)
if err != nil {
logging.Log.Errorf("Error building pipelineresource clientset: %s", err.Error())
}
k8sClient, err := k8sclientset.NewForConfig(cfg)
if err != nil {
logging.Log.Errorf("Error building k8s clientset: %s", err.Error())
}
routeClient, err := routeclient.NewForConfig(cfg)
if err != nil {
logging.Log.Errorf("Error building route clientset: %s", err.Error())
}
resource := endpoints.Resource{
PipelineClient: pipelineClient,
PipelineResourceClient: pipelineResourceClient,
K8sClient: k8sClient,
RouteClient: routeClient,
}
ctx := signals.NewContext()
routerHandler := router.Register(resource)
logging.Log.Info("Creating controllers")
resyncDur := time.Second * 30
controllers.StartTektonControllers(resource.PipelineClient, resource.PipelineResourceClient, resyncDur, ctx.Done())
controllers.StartKubeControllers(resource.K8sClient, resyncDur, dashboardConfig.installNamespace, routerHandler, ctx.Done())
logging.Log.Infof("Creating server and entering wait loop")
server := &http.Server{Addr: dashboardConfig.port, Handler: routerHandler}
errCh := make(chan error, 1)
defer close(errCh)
go func() {
// Don't forward ErrServerClosed as that indicates we're already shutting down.
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
errCh <- fmt.Errorf("dashboard server failed: %w", err)
}
}()
select {
case err := <-errCh:
logging.Log.Fatal(err)
case <-ctx.Done():
if err := server.Shutdown(context.Background()); err != nil {
logging.Log.Fatal(err)
}
}
}
|
[
"\"KUBECONFIG\"",
"\"INSTALLED_NAMESPACE\"",
"\"PORT\""
] |
[] |
[
"INSTALLED_NAMESPACE",
"PORT",
"KUBECONFIG"
] |
[]
|
["INSTALLED_NAMESPACE", "PORT", "KUBECONFIG"]
|
go
| 3 | 0 | |
gitinfo/utils.py
|
from __future__ import annotations
from anytree import NodeMixin
from datetime import datetime, timezone
from dotenv import load_dotenv
from os import environ
from os.path import join, dirname
from typing import Tuple, List, Any, Dict, Optional
import re
import requests
from rich.box import Box
__all__ = [
"get_data", "get_token", "get_url_info", "human_size", "humanize_time",
"populate_tree", "ROUNDED_BORDER", "run_query", "set_token", "sort_entries"
]
ROUNDED_BORDER: Box = Box(
"""\
╭──╮
│ │
│ │
│ │
│ │
│ │
│ │
╰──╯
"""
)
def get_token() -> str:
"""
Retrieves the Github Personal Access Token from .env file
"""
dotenv_path = join(dirname(__file__), '.env')
load_dotenv(dotenv_path)
return environ.get("GITSORT_TOKEN")
def set_token(token: str) -> None:
"""
Set your Github personal access token in order to access
private repositories and extend the usage of the GraphQL API.
"""
import os
from dotenv import load_dotenv
from os.path import join, dirname
dotenv_path = join(dirname(__file__), '.env')
load_dotenv(dotenv_path)
gitsort_token = os.environ.get("GITSORT_TOKEN")
if not gitsort_token:
with open(dotenv_path, "w") as f:
f.write(f"GITSORT_TOKEN={token}")
print("Github Token set!")
else:
inp = input("Github token already set! Do you want to update it? [y/n] ").lower()
while inp not in ["y", "n"]:
print("Invalid answer")
inp = input("Github token already set! Do you want to update it? [y/n] ").lower()
if inp == "y":
with open(dotenv_path, "w") as f:
f.write(f"GITSORT_TOKEN={token}")
print("Github Token updated!")
def run_query(
query: str,
token: str,
variables: dict | None = None,
headers: dict | None = None
) -> Tuple[dict, str]:
"""
Runs a Github GraphQL query and returns the result
:param query: str
GraphQL query
:param token: str
The users Github Personal Access Token
:param variables: dict
GraphQL Variables
:param headers: dict
Request headers
:return: tuple
The response and rate limit
"""
if not headers:
headers = {"Authorization": f"Bearer {token}"}
request = requests.post(
'https://api.github.com/graphql',
json={'query': query, 'variables': variables},
headers=headers
)
if request.status_code == 200:
return request.json(), request.headers["X-RateLimit-Remaining"]
else:
raise Exception("Query failed to run by returning code of {}. {}".format(request.status_code, query))
def get_data(
query: str,
token: str,
query_variables: Dict[str, str]
) -> Tuple[bool, Any, str]:
"""
Get data from query
:param query: str
Graphql Query
:param token: str
Github Personal Access Token
:param query_variables: dict
Variables used in query
:return: tuple
returns a tuple of tree items:
0. bool: True if query failed and return error messages else False
1. Any: Data returned from query
2. str: Rate limit
"""
data, rate_limit = run_query(query, token, query_variables)
if list(data.keys())[0] == "errors":
return True, data["errors"][0]["message"], rate_limit
try:
return False, data["data"]["repository"], rate_limit
except TypeError:
return True, "Query failed. Make sure path and branch is valid.", rate_limit
def get_url_info(url: str) -> Tuple[str, str] | List[str]:
"""
Retrieves owner and repository from a string
:param url: str
Either some form of Github Url or path such as `user/repo/whatever`
:return: tuple | list
Tuple containing owner and repo
"""
is_link = re.compile(r"^(git(hub)?|https?)")
is_git_path = re.compile(r"^[a-zA-Z0-9\-_.]+/[a-zA-Z0-9\-_.]+")
git_url_regex = re.compile(r"^(https|git)?(://|@)?([^/:]+)[/:](?P<owner>[^/:]+)/(?P<name>.+)(.git)?$")
is_git_repo = re.compile(r"((.git)|/)$")
if is_link.match(url):
if is_git_path.match(url):
return url.split("/")[:2]
match = git_url_regex.match(url)
if not match:
raise Exception("Invalid path")
name = match.group("name").split("/")[0]
name = is_git_repo.sub("", name)
owner = match.group("owner")
return owner, name
else:
if url.count("/") > 0:
return url.split("/")[:2]
raise Exception("Link/path must contain both user and repo")
def humanize_time(time_str: str) -> str:
"""
Convert datetime into a more human-friendly format
:param time_str: str
Time string in the ISO 8601 format
:return: str
Human friendly format: <number> <time_period> ago
"""
if not time_str:
return "null"
now = datetime.now()
date = datetime.strptime(time_str, "%Y-%m-%dT%H:%M:%SZ")
date = date.replace(tzinfo=timezone.utc)
diff = int(now.timestamp() - date.timestamp())
times = [
1, 60, 3600, 86400, 604800, 2629746, 31556925
]
times_str = [
"Second", "Minute", "Hour", "Day", "Week", "Month", "Year"
]
temp = [diff // t for t in times][::-1]
for i, t in enumerate(temp):
if t != 0:
return f"{t} {times_str[6-i]}{'' if t == 1 else 's'} ago"
def human_size(bytes: int | float, units: Optional[List[str]] = None) -> str:
"""
Convert bytes into a more human-friendly format
:param bytes: int
Number of bytes
:param units: Optional[List[str]]
units used
:return: str
Return size in human friendly format: <number> <size_unit>
"""
if units is None:
units = ['bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB']
return f"{round(bytes, 2)} " + units[0] if bytes < 1024 else human_size(bytes / 1024, units[1:])
class FileEntry(NodeMixin):
def __init__(
self,
name: str,
size: str | int = None,
parent=None,
children=None
) -> None:
super(FileEntry, self).__init__()
if size != None:
self.name = f"{name} ([green]{human_size(size)}[/])"
else:
self.name = f"[blue]{name}/[/]"
self.parent = parent
if children:
self.children = children
class FileEntryRoot(NodeMixin):
def __init__(self, name: str, parent=None, children=None):
super(FileEntryRoot, self).__init__()
self.name = name
self.parent = parent
if children:
self.children = children
def populate_tree(
root_name: str,
data: list,
collapse_blobs: bool = False
) -> "anytree.Node":
"""
Populate the tree
:param root_name: str
Name of root node
:param data: dict
Data
:param collapse_blobs: bool
Collapse files or not
:return: anytree.node
"""
root = FileEntryRoot(root_name)
def edges(tree: FileEntry | FileEntryRoot, parent=None):
collapsed_count = 0
collapsed_size = 0
for entry in tree:
if entry["type"] == "blob":
if collapse_blobs:
collapsed_size += entry["object"]["byteSize"]
collapsed_count += 1
else:
_ = FileEntry(entry["name"], entry["object"]["byteSize"], parent=parent)
else:
node = FileEntry(entry["name"], parent=parent)
if entry["object"]:
edges(entry["object"]["entries"], parent=node)
if collapse_blobs:
_ = FileEntry(f"[orange1]{collapsed_count}[/] Files", collapsed_size, parent=parent)
edges(data, root)
return root
class Reversor:
def __init__(self, obj: Any) -> None:
self.obj = obj
def __eq__(self, other: Any) -> bool:
return other.obj == self.obj
def __lt__(self, other: Any) -> bool:
return other.obj < self.obj
def sort_entries(entries: List[Any]) -> List[Any]:
"""
Recursively sort the data first based on type
then alphabetically
:param entries: list
Entries
:return: list
Entries but sorted
"""
entries = sorted(
entries, key=lambda x: (
Reversor(x["type"]), # First sort by type (reversed)
x["name"].lower() # Then sort by alphabetical
)
)
for entry in entries:
if entry["type"] == "tree" and entry["object"]:
entry["object"]["entries"] = sort_entries(entry["object"]["entries"])
return entries
|
[] |
[] |
[
"GITSORT_TOKEN"
] |
[]
|
["GITSORT_TOKEN"]
|
python
| 1 | 0 | |
heat/tests/functional/test_AutoScalingMultiAZSample.py
|
# vim: tabstop=4 shiftwidth=4 softtabstop=4
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
#
import util
import verify
from nose.plugins.attrib import attr
import unittest
import os
from time import sleep
@attr(speed='slow')
@attr(tag=['func', 'autoscaling', 'AutoScalingMultiAZSample.template'])
class AutoScalingMultiAZSampleFunctionalTest(unittest.TestCase):
def setUp(self):
template = 'AutoScalingMultiAZSample.template'
stack_paramstr = ';'.join(['InstanceType=m1.small',
'DBUsername=dbuser',
'DBPassword=' + os.environ['OS_PASSWORD']])
self.stack = util.Stack(self, template, 'F17', 'x86_64', 'cfntools',
stack_paramstr)
self.WebServerGroup0 = util.Instance(self, 'WebServerGroup-0')
def tearDown(self):
pass
self.stack.cleanup()
def test_instance(self):
self.stack.create()
self.WebServerGroup0.wait_for_boot()
self.WebServerGroup0.check_cfntools()
self.WebServerGroup0.wait_for_provisioning()
# TODO: verify the code below tests the template properly
# TODO(sdake) use a util exists function for nonexistent instances (needs dev)
# Trigger the load balancer by taking up memory
self.WebServerGroup0.exec_command('memhog -r100000 1500m')
# Give the load balancer 2 minutes to react
sleep(2 * 60)
self.WebServerGroup1 = util.Instance(self, 'WebServerGroup-1')
# Verify the second instance gets launched
self.assertTrue(self.WebServerGroup1.exists())
self.WebServerGroup1.wait_for_boot()
self.WebServerGroup1.check_cfntools()
self.WebServerGroup1.wait_for_provisioning()
# ensure wordpress was installed by checking for expected
# configuration file over ssh
self.assertTrue(self.WebServerGroup0.file_present
('/etc/wordpress/wp-config.php'))
print "Wordpress installation detected on WSG0"
# ensure wordpress was installed by checking for expected
# configuration file over ssh
self.assertTrue(self.WebServerGroup1.file_present
('/etc/wordpress/wp-config.php'))
print "Wordpress installation detected on WSG1"
# Verify the output URL parses as expected, ie check that
# the wordpress installation is operational
stack_url = self.stack.get_stack_output("URL")
print "Got stack output WebsiteURL=%s, verifying" % stack_url
ver = verify.VerifyStack()
self.assertTrue(ver.verify_wordpress(stack_url))
|
[] |
[] |
[
"OS_PASSWORD"
] |
[]
|
["OS_PASSWORD"]
|
python
| 1 | 0 | |
magefile.go
|
// +build mage
package main
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/magefile/mage/mg"
"github.com/magefile/mage/sh"
)
// can be overwritten by GOEXE
var goExe = "go"
// can be overwritten by PY3EXE
var py3Exe = "python3"
// can be overwritten by CLIEXE
var cliExe = "cartridge"
var goPackageName = "github.com/tarantool/cartridge-cli/cli"
var packagePath = "./cli"
var generateModePath = filepath.Join(packagePath, "create", "codegen", "generate_mode.go")
var generatedFilesPath = fmt.Sprintf("./%s", filepath.Join(packagePath, "create", "codegen", "static"))
var generatedFSFile = "cartridge_vfsdata_gen.go"
var generatedModeFile = "cartridge_filemodes_gen.go"
var completionPath = "./completion"
var tmpPath = "./tmp"
var sdkDirName = "tarantool-enterprise"
var sdkDirPath = filepath.Join(tmpPath, sdkDirName)
func getBuildEnv() map[string]string {
var err error
var curDir string
var gitTag string
var gitCommit string
if curDir, err = os.Getwd(); err != nil {
fmt.Printf("Failed to get current directory: %s\n", err)
}
if _, err := exec.LookPath("git"); err == nil {
gitTag, _ = sh.Output("git", "describe", "--tags")
gitCommit, _ = sh.Output("git", "rev-parse", "--short", "HEAD")
}
versionLabel := os.Getenv("VERSION_LABEL")
return map[string]string{
"PACKAGE": goPackageName,
"GIT_TAG": gitTag,
"GIT_COMMIT": gitCommit,
"VERSION_LABEL": versionLabel,
"PWD": curDir,
}
}
var ldflags = []string{
"-s", "-w",
"-X ${PACKAGE}/version.gitTag=${GIT_TAG}",
"-X ${PACKAGE}/version.gitCommit=${GIT_COMMIT}",
"-X ${PACKAGE}/version.versionLabel=${VERSION_LABEL}",
}
var ldflagsStr = strings.Join(ldflags, " ")
var asmflags = "all=-trimpath=${PWD}"
var gcflags = "all=-trimpath=${PWD}"
func init() {
var err error
if specifiedGoExe := os.Getenv("GOEXE"); specifiedGoExe != "" {
goExe = specifiedGoExe
}
if specifiedCliExe := os.Getenv("CLIEXE"); specifiedCliExe != "" {
cliExe = specifiedCliExe
} else {
if cliExe, err = filepath.Abs(cliExe); err != nil {
panic(err)
}
}
// We want to use Go 1.11 modules even if the source lives inside GOPATH.
// The default is "auto".
os.Setenv("GO111MODULE", "on")
}
// Run go vet and flake8
func Lint() error {
fmt.Println("Generating Go code...")
mg.Deps(GenerateGoCode)
fmt.Println("Running go vet...")
if err := sh.RunV(goExe, "vet", packagePath); err != nil {
return err
}
fmt.Println("Running flake8...")
if err := sh.RunV(py3Exe, "-m", "flake8"); err != nil {
return err
}
fmt.Println("Running luacheck for test projects files...")
if err := sh.RunV(".rocks/bin/luacheck", "test/files"); err != nil {
return err
}
return nil
}
// Run unit tests
func Unit() error {
fmt.Println("Running unit tests...")
mg.Deps(GenerateGoCode)
if mg.Verbose() {
return sh.RunV(goExe, "test", "-v", "./cli/...")
} else {
return sh.RunV(goExe, "test", "./cli/...")
}
}
// Run integration tests
func Integration() error {
fmt.Println("Running integration tests...")
return sh.RunV(py3Exe, "-m", "pytest", "test/integration")
}
// Run examples tests
func TestExamples() error {
fmt.Println("Running examples tests...")
return sh.RunV(py3Exe, "-m", "pytest", "test/examples")
}
// Run e2e tests
func E2e() error {
fmt.Println("Running e2e tests...")
return sh.RunV(py3Exe, "-m", "pytest", "test/e2e")
}
// Run all tests
func Test() {
mg.SerialDeps(Lint, Unit, Integration, TestExamples, E2e)
}
// Build cartridge-cli executable
func Build() error {
var err error
fmt.Println("Building...")
mg.Deps(GenerateGoCode)
err = sh.RunWith(
getBuildEnv(), goExe, "build",
"-o", cliExe,
"-ldflags", ldflagsStr,
"-asmflags", asmflags,
"-gcflags", gcflags,
packagePath,
)
if err != nil {
return fmt.Errorf("Failed to build cartridge-cli executable: %s", err)
}
return nil
}
// Generate Go code that statically implements filesystem
// and map with modes for that filesystem.
func GenerateGoCode() error {
err := sh.RunWith(
getBuildEnv(), goExe,
"generate", "-tags=dev",
generatedFilesPath,
)
if err != nil {
return err
}
err = sh.RunWith(
getBuildEnv(), goExe,
"run", generateModePath,
)
if err != nil {
return err
}
return nil
}
// Generate completion scripts for bash and zsh
func GenCompletion() error {
if err := Build(); err != nil {
return err
}
fmt.Println("Generate autocompletion...")
if err := sh.Run(cliExe, "gen", "completion"); err != nil {
return fmt.Errorf("Failed to generate autocompletion scripts: %s", err)
}
return nil
}
// Download Tarantool Enterprise to tmp/tarantool-enterprise dir
func Sdk() error {
if _, err := os.Stat(sdkDirPath); os.IsNotExist(err) {
if err := downloadSdk(); err != nil {
return err
}
} else if err != nil {
return fmt.Errorf("Failed to check if SDK exists: %s", err)
} else {
fmt.Printf("Found Tarantool Enterprise SDK: %s\n", sdkDirPath)
}
fmt.Printf("Run `source %s/env.sh` to activate Tarantool Enterprise\n", sdkDirPath)
return nil
}
// Clean up after yourself
func Clean() {
fmt.Println("Cleaning...")
os.Remove(filepath.Join(generatedFilesPath, generatedFSFile))
os.Remove(filepath.Join(generatedFilesPath, generatedModeFile))
os.RemoveAll(cliExe)
os.RemoveAll(completionPath)
}
func downloadSdk() error {
bundleVersion := os.Getenv("BUNDLE_VERSION")
if bundleVersion == "" {
return fmt.Errorf("Please, specify BUNDLE_VERSION")
}
downloadToken := os.Getenv("DOWNLOAD_TOKEN")
if downloadToken == "" {
return fmt.Errorf("Please, specify DOWNLOAD_TOKEN")
}
archivedSDKName := fmt.Sprintf("tarantool-enterprise-bundle-%s.tar.gz", bundleVersion)
sdkDownloadUrl := fmt.Sprintf(
"https://tarantool:%[email protected]/enterprise/%s",
downloadToken,
archivedSDKName,
)
fmt.Printf("Download Tarantool Enterprise SDK %s...\n", bundleVersion)
archivedSDKPath := filepath.Join(tmpPath, archivedSDKName)
if err := downloadFile(sdkDownloadUrl, archivedSDKPath); err != nil {
return fmt.Errorf("Failed to download archived SDK: %s", err)
}
defer os.RemoveAll(archivedSDKPath)
fmt.Println("Unarchive Tarantool Enterprise SDK...")
if err := sh.RunV("tar", "-xzf", archivedSDKPath, "-C", tmpPath); err != nil {
return fmt.Errorf("Failed to unarchive SDK: %s")
}
return nil
}
|
[
"\"VERSION_LABEL\"",
"\"GOEXE\"",
"\"CLIEXE\"",
"\"BUNDLE_VERSION\"",
"\"DOWNLOAD_TOKEN\""
] |
[] |
[
"DOWNLOAD_TOKEN",
"VERSION_LABEL",
"GOEXE",
"BUNDLE_VERSION",
"CLIEXE"
] |
[]
|
["DOWNLOAD_TOKEN", "VERSION_LABEL", "GOEXE", "BUNDLE_VERSION", "CLIEXE"]
|
go
| 5 | 0 | |
python/ray/serve/backend_worker.py
|
import asyncio
import logging
import traceback
import inspect
from collections.abc import Iterable
from itertools import groupby
from typing import Union, List, Any, Callable, Type
import time
import starlette.responses
from starlette.requests import Request
import ray
from ray.actor import ActorHandle
from ray._private.async_compat import sync_to_async
from ray.serve.batching import _BatchQueue
from ray.serve.utils import (ASGIHTTPSender, parse_request_item, _get_logger,
chain_future, unpack_future, import_attr)
from ray.serve.exceptions import RayServeException
from ray.util import metrics
from ray.serve.config import BackendConfig
from ray.serve.long_poll import LongPollClient, LongPollNamespace
from ray.serve.router import Query, RequestMetadata
from ray.serve.constants import (
BACKEND_RECONFIGURE_METHOD,
DEFAULT_LATENCY_BUCKET_MS,
)
from ray.exceptions import RayTaskError
logger = _get_logger()
def create_backend_replica(backend_def: Union[Callable, Type[Callable], str]):
"""Creates a replica class wrapping the provided function or class.
This approach is picked over inheritance to avoid conflict between user
provided class and the RayServeReplica class.
"""
backend_def = backend_def
# TODO(architkulkarni): Add type hints after upgrading cloudpickle
class RayServeWrappedReplica(object):
def __init__(self, backend_tag, replica_tag, init_args,
backend_config: BackendConfig, controller_name: str):
if isinstance(backend_def, str):
backend = import_attr(backend_def)
else:
backend = backend_def
if inspect.isfunction(backend):
is_function = True
elif inspect.isclass(backend):
is_function = False
else:
assert False, ("backend_def must be function, class, or "
"corresponding import path.")
# Set the controller name so that serve.connect() in the user's
# backend code will connect to the instance that this backend is
# running in.
ray.serve.api._set_internal_replica_context(
backend_tag, replica_tag, controller_name)
if is_function:
_callable = backend
else:
_callable = backend(*init_args)
assert controller_name, "Must provide a valid controller_name"
controller_handle = ray.get_actor(controller_name)
self.backend = RayServeReplica(_callable, backend_config,
is_function, controller_handle)
@ray.method(num_returns=2)
async def handle_request(
self,
request_metadata: RequestMetadata,
*request_args,
**request_kwargs,
):
# Directly receive input because it might contain an ObjectRef.
query = Query(request_args, request_kwargs, request_metadata)
return await self.backend.handle_request(query)
def ready(self):
pass
async def drain_pending_queries(self):
return await self.backend.drain_pending_queries()
if isinstance(backend_def, str):
RayServeWrappedReplica.__name__ = "RayServeReplica_{}".format(
backend_def)
else:
RayServeWrappedReplica.__name__ = "RayServeReplica_{}".format(
backend_def.__name__)
return RayServeWrappedReplica
def wrap_to_ray_error(function_name: str,
exception: Exception) -> RayTaskError:
"""Utility method to wrap exceptions in user code."""
try:
# Raise and catch so we can access traceback.format_exc()
raise exception
except Exception as e:
traceback_str = ray._private.utils.format_error_message(
traceback.format_exc())
return ray.exceptions.RayTaskError(function_name, traceback_str, e)
class RayServeReplica:
"""Handles requests with the provided callable."""
def __init__(self, _callable: Callable, backend_config: BackendConfig,
is_function: bool, controller_handle: ActorHandle) -> None:
self.backend_tag = ray.serve.api.get_replica_context().backend_tag
self.replica_tag = ray.serve.api.get_replica_context().replica_tag
self.callable = _callable
self.is_function = is_function
self.config = backend_config
self.batch_queue = _BatchQueue(self.config.max_batch_size or 1,
self.config.batch_wait_timeout)
self.reconfigure(self.config.user_config)
self.num_ongoing_requests = 0
self.request_counter = metrics.Counter(
"serve_backend_request_counter",
description=("The number of queries that have been "
"processed in this replica."),
tag_keys=("backend", ))
self.request_counter.set_default_tags({"backend": self.backend_tag})
self.loop = asyncio.get_event_loop()
self.long_poll_client = LongPollClient(
controller_handle,
{
(LongPollNamespace.BACKEND_CONFIGS, self.backend_tag): self.
_update_backend_configs,
},
call_in_event_loop=self.loop,
)
self.error_counter = metrics.Counter(
"serve_backend_error_counter",
description=("The number of exceptions that have "
"occurred in the backend."),
tag_keys=("backend", ))
self.error_counter.set_default_tags({"backend": self.backend_tag})
self.restart_counter = metrics.Counter(
"serve_backend_replica_starts",
description=("The number of times this replica "
"has been restarted due to failure."),
tag_keys=("backend", "replica"))
self.restart_counter.set_default_tags({
"backend": self.backend_tag,
"replica": self.replica_tag
})
self.queuing_latency_tracker = metrics.Histogram(
"serve_backend_queuing_latency_ms",
description=("The latency for queries in the replica's queue "
"waiting to be processed or batched."),
boundaries=DEFAULT_LATENCY_BUCKET_MS,
tag_keys=("backend", "replica"))
self.queuing_latency_tracker.set_default_tags({
"backend": self.backend_tag,
"replica": self.replica_tag
})
self.processing_latency_tracker = metrics.Histogram(
"serve_backend_processing_latency_ms",
description="The latency for queries to be processed.",
boundaries=DEFAULT_LATENCY_BUCKET_MS,
tag_keys=("backend", "replica", "batch_size"))
self.processing_latency_tracker.set_default_tags({
"backend": self.backend_tag,
"replica": self.replica_tag
})
self.num_queued_items = metrics.Gauge(
"serve_replica_queued_queries",
description=("The current number of queries queued in "
"the backend replicas."),
tag_keys=("backend", "replica"))
self.num_queued_items.set_default_tags({
"backend": self.backend_tag,
"replica": self.replica_tag
})
self.num_processing_items = metrics.Gauge(
"serve_replica_processing_queries",
description="The current number of queries being processed.",
tag_keys=("backend", "replica"))
self.num_processing_items.set_default_tags({
"backend": self.backend_tag,
"replica": self.replica_tag
})
self.restart_counter.inc()
ray_logger = logging.getLogger("ray")
for handler in ray_logger.handlers:
handler.setFormatter(
logging.Formatter(
handler.formatter._fmt +
f" component=serve backend={self.backend_tag} "
f"replica={self.replica_tag}"))
asyncio.get_event_loop().create_task(self.main_loop())
def get_runner_method(self, request_item: Query) -> Callable:
method_name = request_item.metadata.call_method
if not hasattr(self.callable, method_name):
raise RayServeException("Backend doesn't have method {} "
"which is specified in the request. "
"The available methods are {}".format(
method_name, dir(self.callable)))
if self.is_function:
return self.callable
return getattr(self.callable, method_name)
async def ensure_serializable_response(self, response: Any) -> Any:
if isinstance(response, starlette.responses.StreamingResponse):
async def mock_receive():
# This is called in a tight loop in response() just to check
# for an http disconnect. So rather than return immediately
# we should suspend execution to avoid wasting CPU cycles.
never_set_event = asyncio.Event()
await never_set_event.wait()
sender = ASGIHTTPSender()
await response(scope=None, receive=mock_receive, send=sender)
return sender.build_starlette_response()
return response
async def invoke_single(self, request_item: Query) -> Any:
logger.debug("Replica {} started executing request {}".format(
self.replica_tag, request_item.metadata.request_id))
arg = parse_request_item(request_item)
start = time.time()
try:
# TODO(simon): Split this section out when invoke_batch is removed.
if self.config.internal_metadata.is_asgi_app:
request: Request = arg
scope = request.scope
root_path = self.config.internal_metadata.path_prefix
# The incoming scope["path"] contains prefixed path and it
# won't be stripped by FastAPI.
request.scope["path"] = scope["path"].replace(root_path, "", 1)
# root_path is used such that the reverse look up and
# redirection works.
request.scope["root_path"] = root_path
sender = ASGIHTTPSender()
await self.callable._serve_asgi_app(
request.scope,
request._receive,
sender,
)
result = sender.build_starlette_response()
else:
method_to_call = sync_to_async(
self.get_runner_method(request_item))
result = await method_to_call(arg)
result = await self.ensure_serializable_response(result)
self.request_counter.inc()
except Exception as e:
import os
if "RAY_PDB" in os.environ:
ray.util.pdb.post_mortem()
result = wrap_to_ray_error(method_to_call.__name__, e)
self.error_counter.inc()
latency_ms = (time.time() - start) * 1000
self.processing_latency_tracker.observe(
latency_ms, tags={"batch_size": "1"})
return result
async def invoke_batch(self, request_item_list: List[Query]) -> List[Any]:
args = []
call_methods = set()
batch_size = len(request_item_list)
# Construct the batch of requests
for item in request_item_list:
logger.debug("Replica {} started executing request {}".format(
self.replica_tag, item.metadata.request_id))
args.append(parse_request_item(item))
call_methods.add(self.get_runner_method(item))
timing_start = time.time()
try:
if len(call_methods) != 1:
raise RayServeException(
f"Queries contain mixed calling methods: {call_methods}. "
"Please only send the same type of requests in batching "
"mode.")
self.request_counter.inc(batch_size)
call_method = sync_to_async(call_methods.pop())
result_list = await call_method(args)
if not isinstance(result_list, Iterable) or isinstance(
result_list, (dict, set)):
error_message = ("RayServe expects an ordered iterable object "
"but the replica returned a {}".format(
type(result_list)))
raise RayServeException(error_message)
# Normalize the result into a list type. This operation is fast
# in Python because it doesn't copy anything.
result_list = list(result_list)
if (len(result_list) != batch_size):
error_message = ("Worker doesn't preserve batch size. The "
"input has length {} but the returned list "
"has length {}. Please return a list of "
"results with length equal to the batch size"
".".format(batch_size, len(result_list)))
raise RayServeException(error_message)
for i, result in enumerate(result_list):
result_list[i] = (await
self.ensure_serializable_response(result))
except Exception as e:
wrapped_exception = wrap_to_ray_error(call_method.__name__, e)
self.error_counter.inc()
result_list = [wrapped_exception for _ in range(batch_size)]
latency_ms = (time.time() - timing_start) * 1000
self.processing_latency_tracker.observe(
latency_ms, tags={"batch_size": str(batch_size)})
return result_list
async def main_loop(self) -> None:
while True:
# NOTE(simon): There's an issue when user updated batch size and
# batch wait timeout during the execution, these values will not be
# updated until after the current iteration.
batch = await self.batch_queue.wait_for_batch()
# Record metrics
self.num_queued_items.set(self.batch_queue.qsize())
self.num_processing_items.set(self.num_ongoing_requests -
self.batch_queue.qsize())
for query in batch:
queuing_time = (time.time() - query.tick_enter_replica) * 1000
self.queuing_latency_tracker.observe(queuing_time)
all_evaluated_futures = []
if not self.config.internal_metadata.accepts_batches:
query = batch[0]
evaluated = asyncio.ensure_future(self.invoke_single(query))
all_evaluated_futures = [evaluated]
chain_future(evaluated, query.async_future)
else:
get_call_method = (
lambda query: query.metadata.call_method # noqa: E731
)
sorted_batch = sorted(batch, key=get_call_method)
for _, group in groupby(sorted_batch, key=get_call_method):
group = list(group)
evaluated = asyncio.ensure_future(self.invoke_batch(group))
all_evaluated_futures.append(evaluated)
result_futures = [q.async_future for q in group]
chain_future(
unpack_future(evaluated, len(group)), result_futures)
if self.config.internal_metadata.is_blocking:
# We use asyncio.wait here so if the result is exception,
# it will not be raised.
await asyncio.wait(all_evaluated_futures)
def reconfigure(self, user_config) -> None:
if user_config:
if self.is_function:
raise ValueError(
"backend_def must be a class to use user_config")
elif not hasattr(self.callable, BACKEND_RECONFIGURE_METHOD):
raise RayServeException("user_config specified but backend " +
self.backend_tag + " missing " +
BACKEND_RECONFIGURE_METHOD + " method")
reconfigure_method = getattr(self.callable,
BACKEND_RECONFIGURE_METHOD)
reconfigure_method(user_config)
def _update_backend_configs(self, new_config: BackendConfig) -> None:
self.config = new_config
self.batch_queue.set_config(self.config.max_batch_size or 1,
self.config.batch_wait_timeout)
self.reconfigure(self.config.user_config)
async def handle_request(self, request: Query) -> asyncio.Future:
request.tick_enter_replica = time.time()
logger.debug("Replica {} received request {}".format(
self.replica_tag, request.metadata.request_id))
request.async_future = asyncio.get_event_loop().create_future()
self.num_ongoing_requests += 1
self.batch_queue.put(request)
result = await request.async_future
request_time_ms = (time.time() - request.tick_enter_replica) * 1000
logger.debug("Replica {} finished request {} in {:.2f}ms".format(
self.replica_tag, request.metadata.request_id, request_time_ms))
self.num_ongoing_requests -= 1
# Returns a small object for router to track request status.
return b"", result
async def drain_pending_queries(self):
"""Perform graceful shutdown.
Trigger a graceful shutdown protocol that will wait for all the queued
tasks to be completed and return to the controller.
"""
sleep_time = self.config.experimental_graceful_shutdown_wait_loop_s
while True:
# Sleep first because we want to make sure all the routers receive
# the notification to remove this replica first.
await asyncio.sleep(sleep_time)
num_queries_waiting = self.batch_queue.qsize()
if (num_queries_waiting == 0) and (self.num_ongoing_requests == 0):
break
else:
logger.info(
f"Waiting for an additional {sleep_time}s "
f"to shutdown replica {self.replica_tag} because "
f"num_queries_waiting {num_queries_waiting} and "
f"num_ongoing_requests {self.num_ongoing_requests}")
ray.actor.exit_actor()
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
internal/nhctl/utils/util.go
|
package utils
import (
"crypto/sha1"
"encoding/json"
"errors"
"fmt"
"io"
"io/ioutil"
"nocalhost/pkg/nhctl/tools"
"os"
"os/user"
"path/filepath"
"reflect"
"runtime"
"strconv"
)
func GetHomePath() string {
if sudoUser := os.Getenv("SUDO_USER"); sudoUser != "" {
if u, err := user.Lookup(sudoUser); err == nil {
return u.HomeDir
}
} else {
u, err := user.Current()
if err == nil {
return u.HomeDir
}
}
return ""
}
func IsSudoUser() bool {
if sudoUser := os.Getenv("SUDO_USER"); sudoUser != "" {
return true
}
return false
}
func Sha1ToString(str string) string {
hash := sha1.New()
hash.Write([]byte(str))
return fmt.Sprintf("%x", hash.Sum(nil))
}
func GetNhctlBinName() string {
if runtime.GOOS == "windows" {
return "nhctl.exe"
}
return "nhctl"
}
func CopyFile(src, dst string) (err error) {
in, err := os.Open(src)
if err != nil {
return
}
defer in.Close()
out, err := os.Create(dst)
if err != nil {
return
}
defer func() {
if e := out.Close(); e != nil {
err = e
}
}()
_, err = io.Copy(out, in)
if err != nil {
return
}
err = out.Sync()
if err != nil {
return
}
si, err := os.Stat(src)
if err != nil {
return
}
err = os.Chmod(dst, si.Mode())
if err != nil {
return
}
return
}
// CopyDir recursively copies a directory tree, attempting to preserve permissions.
// Source directory must exist
// Symlinks are ignored and skipped.
func CopyDir(src string, dst string) (err error) {
src = filepath.Clean(src)
dst = filepath.Clean(dst)
si, err := os.Stat(src)
if err != nil {
return err
}
if !si.IsDir() {
return fmt.Errorf("source is not a directory")
}
_, err = os.Stat(dst)
if err != nil && !os.IsNotExist(err) {
return
}
//if err == nil {
// return fmt.Errorf("destination already exists")
//}
err = os.MkdirAll(dst, si.Mode())
if err != nil {
return
}
entries, err := ioutil.ReadDir(src)
if err != nil {
return
}
for _, entry := range entries {
srcPath := filepath.Join(src, entry.Name())
dstPath := filepath.Join(dst, entry.Name())
if entry.IsDir() {
err = CopyDir(srcPath, dstPath)
if err != nil {
return
}
} else {
// Skip symlinks.
if entry.Mode()&os.ModeSymlink != 0 {
continue
}
err = CopyFile(srcPath, dstPath)
if err != nil {
return
}
}
}
return
}
func CheckKubectlVersion(compareMinor int) error {
commonParams := []string{"version", "-o", "json"}
jsonBody, err := tools.ExecCommand(nil, false, "kubectl", commonParams...)
if err != nil {
return err
}
var result map[string]interface{}
err = json.Unmarshal([]byte(jsonBody), &result)
if err != nil {
return err
}
targetResult := reflect.ValueOf(result["clientVersion"])
target := targetResult.Interface().(map[string]interface{})
minor, err := strconv.Atoi(target["minor"].(string))
if err != nil {
return err
}
if compareMinor > minor {
return errors.New(fmt.Sprintf("kubectl version required %d+", compareMinor))
}
return nil
}
|
[
"\"SUDO_USER\"",
"\"SUDO_USER\""
] |
[] |
[
"SUDO_USER"
] |
[]
|
["SUDO_USER"]
|
go
| 1 | 0 | |
src/sentry/utils/pytest.py
|
from __future__ import absolute_import
import mock
import os
import pytest
import signal
import urllib
from datetime import datetime
from django.conf import settings
from selenium import webdriver
def pytest_configure(config):
# HACK: Only needed for testing!
os.environ.setdefault('_SENTRY_SKIP_CONFIGURATION', '1')
os.environ.setdefault('RECAPTCHA_TESTING', 'True')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sentry.conf.server')
settings.SOUTH_TESTS_MIGRATE = os.environ.get('SENTRY_SOUTH_TESTS_MIGRATE', '1') == '1'
if not settings.configured:
# only configure the db if its not already done
test_db = os.environ.get('DB', 'postgres')
if test_db == 'mysql':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.mysql',
'NAME': 'sentry',
'USER': 'root',
})
# mysql requires running full migration all the time
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == 'postgres':
settings.DATABASES['default'].update({
'ENGINE': 'sentry.db.postgres',
'USER': 'postgres',
'NAME': 'sentry',
})
# postgres requires running full migration all the time
# since it has to install stored functions which come from
# an actual migration.
settings.SOUTH_TESTS_MIGRATE = True
elif test_db == 'sqlite':
settings.DATABASES['default'].update({
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
})
settings.TEMPLATE_DEBUG = True
# Disable static compiling in tests
settings.STATIC_BUNDLES = {}
# override a few things with our test specifics
settings.INSTALLED_APPS = tuple(settings.INSTALLED_APPS) + (
'tests',
)
# Need a predictable key for tests that involve checking signatures
settings.SENTRY_PUBLIC = False
if not settings.SENTRY_CACHE:
settings.SENTRY_CACHE = 'sentry.cache.django.DjangoCache'
settings.SENTRY_CACHE_OPTIONS = {}
# This speeds up the tests considerably, pbkdf2 is by design, slow.
settings.PASSWORD_HASHERS = [
'django.contrib.auth.hashers.MD5PasswordHasher',
]
# Replace real sudo middleware with our mock sudo middleware
# to assert that the user is always in sudo mode
middleware = list(settings.MIDDLEWARE_CLASSES)
sudo = middleware.index('sentry.middleware.sudo.SudoMiddleware')
middleware[sudo] = 'sentry.testutils.middleware.SudoMiddleware'
settings.MIDDLEWARE_CLASSES = tuple(middleware)
# enable draft features
settings.SENTRY_OPTIONS['mail.enable-replies'] = True
settings.SENTRY_ALLOW_ORIGIN = '*'
settings.SENTRY_TSDB = 'sentry.tsdb.inmemory.InMemoryTSDB'
settings.SENTRY_TSDB_OPTIONS = {}
settings.RECAPTCHA_PUBLIC_KEY = 'a' * 40
settings.RECAPTCHA_PRIVATE_KEY = 'b' * 40
settings.BROKER_BACKEND = 'memory'
settings.BROKER_URL = None
settings.CELERY_ALWAYS_EAGER = False
settings.CELERY_EAGER_PROPAGATES_EXCEPTIONS = True
settings.DISABLE_RAVEN = True
settings.CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
}
}
if not hasattr(settings, 'SENTRY_OPTIONS'):
settings.SENTRY_OPTIONS = {}
settings.SENTRY_OPTIONS.update({
'redis.clusters': {
'default': {
'hosts': {
0: {
'db': 9,
},
},
},
},
'mail.backend': 'django.core.mail.backends.locmem.EmailBackend',
'system.url-prefix': 'http://testserver',
})
# django mail uses socket.getfqdn which doesn't play nice if our
# networking isn't stable
patcher = mock.patch('socket.getfqdn', return_value='localhost')
patcher.start()
from sentry.runner.initializer import (
bootstrap_options, initialize_receivers, fix_south, bind_cache_to_option_store)
bootstrap_options(settings)
fix_south(settings)
bind_cache_to_option_store()
initialize_receivers()
from sentry.utils.redis import clusters
with clusters.get('default').all() as client:
client.flushdb()
# force celery registration
from sentry.celery import app # NOQA
# disable DISALLOWED_IPS
from sentry import http
http.DISALLOWED_IPS = set()
def pytest_runtest_teardown(item):
from sentry.app import tsdb
tsdb.flush()
from sentry.utils.redis import clusters
with clusters.get('default').all() as client:
client.flushdb()
from celery.task.control import discard_all
discard_all()
# TODO(dcramer): ideally we could bundle up more of the browser logic here
# rather than splitting it between the fixtures and AcceptanceTestCase
@pytest.fixture(scope='session')
def percy(request, browser):
import percy
# Initialize Percy.
loader = percy.ResourceLoader(
root_dir=settings.STATIC_ROOT,
base_url=urllib.quote(settings.STATIC_URL),
webdriver=browser,
)
percy_config = percy.Config(default_widths=settings.PERCY_DEFAULT_TESTING_WIDTHS)
percy = percy.Runner(loader=loader, config=percy_config)
percy.initialize_build()
request.addfinalizer(percy.finalize_build)
return percy
@pytest.fixture(scope='session')
def browser(request):
# Initialize Selenium.
# NOTE: this relies on the phantomjs binary packaged from npm to be in the right
# location in node_modules.
phantomjs_path = os.path.join(
settings.NODE_MODULES_ROOT,
'phantomjs-prebuilt',
'bin',
'phantomjs',
)
browser = webdriver.PhantomJS(executable_path=phantomjs_path)
def fin():
# Teardown Selenium.
browser.close()
# TODO: remove this when fixed in: https://github.com/seleniumhq/selenium/issues/767
browser.service.process.send_signal(signal.SIGTERM)
browser.quit()
request.addfinalizer(fin)
return browser
@pytest.fixture(scope='class')
def screenshots_path_class(request, browser):
date = datetime.utcnow()
# AcceptanceTestCase.snapshot saves local screenshots here
path = os.path.normpath(os.path.join(
os.path.dirname(__file__), os.pardir, os.pardir, os.pardir, 'tmp', 'selenium-screenshots', date.strftime('%s'))
)
print('Screenshots will be stored in {}'.format(path))
os.makedirs(path)
request.cls.screenshots_path = path
@pytest.fixture(scope='class')
def browser_class(request, browser):
request.cls.browser = browser
@pytest.fixture(scope='class')
def percy_class(request, percy):
request.cls.percy = percy
@pytest.fixture(scope='function')
def reset_browser_session(request):
if not hasattr(request, 'browser'):
return
browser.delete_all_cookies()
browser.get('about:blank')
|
[] |
[] |
[
"DB",
"SENTRY_SOUTH_TESTS_MIGRATE"
] |
[]
|
["DB", "SENTRY_SOUTH_TESTS_MIGRATE"]
|
python
| 2 | 0 | |
x-pack/elastic-agent/pkg/agent/cmd/run.go
|
// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
// or more contributor license agreements. Licensed under the Elastic License;
// you may not use this file except in compliance with the Elastic License.
package cmd
import (
"fmt"
"os"
"os/signal"
"syscall"
"github.com/spf13/cobra"
"github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/agent/application"
"github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/agent/application/paths"
"github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/agent/errors"
"github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/cli"
"github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/config"
"github.com/elastic/beats/v7/x-pack/elastic-agent/pkg/core/logger"
)
func newRunCommandWithArgs(flags *globalFlags, _ []string, streams *cli.IOStreams) *cobra.Command {
return &cobra.Command{
Use: "run",
Short: "Start the elastic-agent.",
Run: func(_ *cobra.Command, _ []string) {
if err := run(flags, streams); err != nil {
fmt.Fprintf(streams.Err, "%v\n", err)
os.Exit(1)
}
},
}
}
func run(flags *globalFlags, streams *cli.IOStreams) error {
pathConfigFile := flags.Config()
config, err := config.LoadYAML(pathConfigFile)
if err != nil {
return errors.New(err,
fmt.Sprintf("could not read configuration file %s", pathConfigFile),
errors.TypeFilesystem,
errors.M(errors.MetaKeyPath, pathConfigFile))
}
logger, err := logger.NewFromConfig("", config)
if err != nil {
return err
}
locker := application.NewAppLocker(paths.Data())
if err := locker.TryLock(); err != nil {
return err
}
defer locker.Unlock()
app, err := application.New(logger, pathConfigFile)
if err != nil {
return err
}
if err := app.Start(); err != nil {
return err
}
// listen for kill signal
signals := make(chan os.Signal, 1)
signal.Notify(signals, syscall.SIGINT, syscall.SIGKILL, syscall.SIGTERM, syscall.SIGQUIT)
<-signals
return app.Stop()
}
|
[] |
[] |
[] |
[]
|
[]
|
go
| null | null | null |
lakalici/wsgi.py
|
"""
WSGI config for lakalici project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.7/howto/deployment/wsgi/
"""
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "lakalici.settings")
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
common/src/main/java/com/turn/ttorrent/common/TorrentCreator.java
|
package com.turn.ttorrent.common;
import com.turn.ttorrent.Constants;
import com.turn.ttorrent.bcodec.BEValue;
import com.turn.ttorrent.bcodec.BEncoder;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import java.io.*;
import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import static com.turn.ttorrent.common.TorrentMetadataKeys.*;
public class TorrentCreator {
private final static Logger logger = TorrentLoggerFactory.getLogger();
/**
* Torrent file piece length (in bytes), we use 512 kB.
*/
public static final int DEFAULT_PIECE_LENGTH = 512 * 1024;
private static final int HASHING_TIMEOUT_SEC = 15;
public static int HASHING_THREADS_COUNT = Runtime.getRuntime().availableProcessors();
private static final ExecutorService HASHING_EXECUTOR = Executors.newFixedThreadPool(HASHING_THREADS_COUNT, new ThreadFactory() {
@Override
public Thread newThread(@NotNull final Runnable r) {
final Thread thread = new Thread(r);
thread.setDaemon(true);
return thread;
}
});
/**
* Create a {@link TorrentMetadata} object for a file.
*
* <p>
* Hash the given file to create the {@link TorrentMetadata} object representing
* the Torrent meta info about this file, needed for announcing and/or
* sharing said file.
* </p>
*
* @param source The file to use in the torrent.
* @param announce The announce URI that will be used for this torrent.
* @param createdBy The creator's name, or any string identifying the
* torrent's creator.
*/
public static TorrentMetadata create(File source, URI announce, String createdBy)
throws InterruptedException, IOException {
return create(source, null, announce, createdBy);
}
/**
* Create a {@link TorrentMetadata} object for a set of files.
*
* <p>
* Hash the given files to create the multi-file {@link TorrentMetadata} object
* representing the Torrent meta-info about them, needed for announcing
* and/or sharing these files. Since we created the torrent, we're
* considering we'll be a full initial seeder for it.
* </p>
*
* @param parent The parent directory or location of the torrent files,
* also used as the torrent's name.
* @param files The files to add into this torrent.
* @param announce The announce URI that will be used for this torrent.
* @param createdBy The creator's name, or any string identifying the
* torrent's creator.
*/
public static TorrentMetadata create(File parent, List<File> files, URI announce,
String createdBy) throws InterruptedException, IOException {
return create(parent, files, announce, null, createdBy);
}
/**
* Create a {@link TorrentMetadata} object for a file.
*
* <p>
* Hash the given file to create the {@link TorrentMetadata} object representing
* the Torrent metainfo about this file, needed for announcing and/or
* sharing said file.
* </p>
*
* @param source The file to use in the torrent.
* @param announceList The announce URIs organized as tiers that will
* be used for this torrent
* @param createdBy The creator's name, or any string identifying the
* torrent's creator.
*/
public static TorrentMetadata create(File source, List<List<URI>> announceList,
String createdBy) throws InterruptedException, IOException {
return create(source, null, null, announceList, createdBy);
}
/**
* Create a {@link TorrentMetadata} object for a set of files.
*
* <p>
* Hash the given files to create the multi-file {@link TorrentMetadata} object
* representing the Torrent meta-info about them, needed for announcing
* and/or sharing these files. Since we created the torrent, we're
* considering we'll be a full initial seeder for it.
* </p>
*
* @param source The parent directory or location of the torrent files,
* also used as the torrent's name.
* @param files The files to add into this torrent.
* @param announceList The announce URIs organized as tiers that will
* be used for this torrent
* @param createdBy The creator's name, or any string identifying the
* torrent's creator.
*/
public static TorrentMetadata create(File source, List<File> files,
List<List<URI>> announceList, String createdBy)
throws InterruptedException, IOException {
return create(source, files, null, announceList, createdBy);
}
/**
* Helper method to create a {@link TorrentMetadata} object for a set of files.
*
* <p>
* Hash the given files to create the multi-file {@link TorrentMetadata} object
* representing the Torrent meta-info about them, needed for announcing
* and/or sharing these files. Since we created the torrent, we're
* considering we'll be a full initial seeder for it.
* </p>
*
* @param parent The parent directory or location of the torrent files,
* also used as the torrent's name.
* @param files The files to add into this torrent.
* @param announce The announce URI that will be used for this torrent.
* @param announceList The announce URIs organized as tiers that will
* be used for this torrent
* @param createdBy The creator's name, or any string identifying the
* torrent's creator.
*/
public static TorrentMetadata create(File parent, List<File> files, URI announce, List<List<URI>> announceList, String createdBy)
throws InterruptedException, IOException {
return create(parent, files, announce, announceList, createdBy, DEFAULT_PIECE_LENGTH);
}
public static TorrentMetadata create(File parent, List<File> files, URI announce,
List<List<URI>> announceList, String createdBy, final int pieceSize)
throws InterruptedException, IOException {
return create(parent, files, announce, announceList, createdBy, System.currentTimeMillis() / 1000, pieceSize);
}
//for tests
/*package local*/
static TorrentMetadata create(File parent, List<File> files, URI announce,
List<List<URI>> announceList, String createdBy, long creationTimeSecs, final int pieceSize)
throws InterruptedException, IOException {
Map<String, BEValue> torrent = new HashMap<String, BEValue>();
if (announce != null) {
torrent.put(ANNOUNCE, new BEValue(announce.toString()));
}
if (announceList != null) {
List<BEValue> tiers = new LinkedList<BEValue>();
for (List<URI> trackers : announceList) {
List<BEValue> tierInfo = new LinkedList<BEValue>();
for (URI trackerURI : trackers) {
tierInfo.add(new BEValue(trackerURI.toString()));
}
tiers.add(new BEValue(tierInfo));
}
torrent.put(ANNOUNCE_LIST, new BEValue(tiers));
}
torrent.put(CREATION_DATE_SEC, new BEValue(creationTimeSecs));
torrent.put(CREATED_BY, new BEValue(createdBy));
Map<String, BEValue> info = new TreeMap<String, BEValue>();
info.put(NAME, new BEValue(parent.getName()));
info.put(PIECE_LENGTH, new BEValue(pieceSize));
if (files == null || files.isEmpty()) {
info.put(FILE_LENGTH, new BEValue(parent.length()));
info.put(PIECES, new BEValue(hashFile(parent, pieceSize),
Constants.BYTE_ENCODING));
} else {
List<BEValue> fileInfo = new LinkedList<BEValue>();
for (File file : files) {
Map<String, BEValue> fileMap = new HashMap<String, BEValue>();
fileMap.put(FILE_LENGTH, new BEValue(file.length()));
LinkedList<BEValue> filePath = new LinkedList<BEValue>();
while (file != null) {
if (file.equals(parent)) {
break;
}
filePath.addFirst(new BEValue(file.getName()));
file = file.getParentFile();
}
fileMap.put(FILE_PATH, new BEValue(filePath));
fileInfo.add(new BEValue(fileMap));
}
info.put(FILES, new BEValue(fileInfo));
info.put(PIECES, new BEValue(hashFiles(files, pieceSize),
Constants.BYTE_ENCODING));
}
torrent.put(INFO_TABLE, new BEValue(info));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
BEncoder.bencode(new BEValue(torrent), baos);
return new TorrentParser().parse(baos.toByteArray());
}
/**
* Return the concatenation of the SHA-1 hashes of a file's pieces.
*
* <p>
* Hashes the given file piece by piece using the default Torrent piece
* length (see {@link #DEFAULT_PIECE_LENGTH}) and returns the concatenation of
* these hashes, as a string.
* </p>
*
* <p>
* This is used for creating Torrent meta-info structures from a file.
* </p>
*
* @param file The file to hash.
*/
private static String hashFile(final File file, final int pieceSize)
throws InterruptedException, IOException {
return hashFiles(Collections.singletonList(file), pieceSize);
}
private static String hashFiles(final List<File> files, final int pieceSize)
throws InterruptedException, IOException {
if (files.size() == 0) {
return "";
}
List<Future<String>> results = new LinkedList<Future<String>>();
long length = 0L;
final ByteBuffer buffer = ByteBuffer.allocate(pieceSize);
final AtomicInteger threadIdx = new AtomicInteger(0);
final String firstFileName = files.get(0).getName();
StringBuilder hashes = new StringBuilder();
long start = System.nanoTime();
for (File file : files) {
logger.debug("Analyzing local data for {} with {} threads...",
file.getName(), HASHING_THREADS_COUNT);
length += file.length();
FileInputStream fis = new FileInputStream(file);
FileChannel channel = fis.getChannel();
try {
while (channel.read(buffer) > 0) {
if (buffer.remaining() == 0) {
buffer.clear();
final ByteBuffer data = prepareDataFromBuffer(buffer);
results.add(HASHING_EXECUTOR.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.currentThread().setName(String.format("%s hasher #%d", firstFileName, threadIdx.incrementAndGet()));
return new CallableChunkHasher(data).call();
}
}));
}
if (results.size() >= HASHING_THREADS_COUNT) {
// process hashers, otherwise they will spend too much memory
waitForHashesToCalculate(results, hashes);
results.clear();
}
}
} finally {
channel.close();
fis.close();
}
}
// Hash the last bit, if any
if (buffer.position() > 0) {
buffer.limit(buffer.position());
buffer.position(0);
final ByteBuffer data = prepareDataFromBuffer(buffer);
results.add(HASHING_EXECUTOR.submit(new CallableChunkHasher(data)));
}
// here we have only a few hashes to wait for calculation
waitForHashesToCalculate(results, hashes);
long elapsed = System.nanoTime() - start;
int expectedPieces = (int) (Math.ceil(
(double) length / pieceSize));
logger.debug("Hashed {} file(s) ({} bytes) in {} pieces ({} expected) in {}ms.",
new Object[]{
files.size(),
length,
results.size(),
expectedPieces,
String.format("%.1f", elapsed / 1e6),
});
return hashes.toString();
}
private static ByteBuffer prepareDataFromBuffer(ByteBuffer buffer) {
final ByteBuffer data = ByteBuffer.allocate(buffer.remaining());
buffer.mark();
data.put(buffer);
data.clear();
buffer.reset();
return data;
}
private static void waitForHashesToCalculate(List<Future<String>> results, StringBuilder hashes) throws InterruptedException, IOException {
try {
for (Future<String> chunk : results) {
hashes.append(chunk.get(HASHING_TIMEOUT_SEC, TimeUnit.SECONDS));
}
} catch (ExecutionException ee) {
throw new IOException("Error while hashing the torrent data!", ee);
} catch (TimeoutException e) {
throw new RuntimeException(String.format("very slow hashing: took more than %d seconds to calculate several pieces. Cancelling", HASHING_TIMEOUT_SEC));
}
}
/**
* Sets max number of threads to use when hash for file is calculated.
*
* @param hashingThreadsCount number of concurrent threads for file hash calculation
*/
public static void setHashingThreadsCount(int hashingThreadsCount) {
HASHING_THREADS_COUNT = hashingThreadsCount;
}
/**
* A {@link Callable} to hash a data chunk.
*
* @author mpetazzoni
*/
private static class CallableChunkHasher implements Callable<String> {
private final ByteBuffer data;
CallableChunkHasher(final ByteBuffer data) {
this.data = data;
}
@Override
public String call() throws UnsupportedEncodingException {
byte[] sha1Hash = TorrentUtils.calculateSha1Hash(this.data.array());
return new String(sha1Hash, Constants.BYTE_ENCODING);
}
}
static {
String threads = System.getenv("TTORRENT_HASHING_THREADS");
if (threads != null) {
try {
int count = Integer.parseInt(threads);
if (count > 0) {
TorrentCreator.HASHING_THREADS_COUNT = count;
}
} catch (NumberFormatException nfe) {
// Pass
}
}
}
}
|
[
"\"TTORRENT_HASHING_THREADS\""
] |
[] |
[
"TTORRENT_HASHING_THREADS"
] |
[]
|
["TTORRENT_HASHING_THREADS"]
|
java
| 1 | 0 | |
pkgs/conda-manager-0.3.1-py27_0/lib/python2.7/site-packages/conda_manager/api/conda_api.py
|
# -*- coding: utf-8 -*-
"""
Updated `conda-api` to include additional methods, queued worker processes
calling `QProcess` instead of `subprocess.Popen`.
"""
# Standard library imports
from os.path import basename, isdir, join
from collections import deque
import json
import os
import platform
import re
import sys
import yaml
# Third party imports
from qtpy.QtCore import QByteArray, QObject, QProcess, QTimer, Signal
# Local imports
from conda_manager.utils.findpip import PIP_LIST_SCRIPT
from conda_manager.utils.logs import logger
__version__ = '1.3.0'
# --- Errors
# -----------------------------------------------------------------------------
class PipError(Exception):
"""General pip error."""
pass
class CondaError(Exception):
"""General Conda error."""
pass
class CondaProcessWorker(CondaError):
"""General Conda error."""
pass
class CondaEnvExistsError(CondaError):
"""Conda environment already exists."""
pass
# --- Helpers
# -----------------------------------------------------------------------------
PY2 = sys.version[0] == '2'
PY3 = sys.version[0] == '3'
DEBUG = False
def to_text_string(obj, encoding=None):
"""Convert `obj` to (unicode) text string."""
if PY2:
# Python 2
if encoding is None:
return unicode(obj)
else:
return unicode(obj, encoding)
else:
# Python 3
if encoding is None:
return str(obj)
elif isinstance(obj, str):
# In case this function is not used properly, this could happen
return obj
else:
return str(obj, encoding)
def handle_qbytearray(obj, encoding):
"""
Qt/Python3 compatibility helper.
"""
if isinstance(obj, QByteArray):
obj = obj.data()
return to_text_string(obj, encoding=encoding)
class ProcessWorker(QObject):
"""
"""
sig_finished = Signal(object, object, object)
sig_partial = Signal(object, object, object)
def __init__(self, cmd_list, parse=False, pip=False, callback=None,
extra_kwargs={}):
super(ProcessWorker, self).__init__()
self._result = None
self._cmd_list = cmd_list
self._parse = parse
self._pip = pip
self._conda = not pip
self._callback = callback
self._fired = False
self._communicate_first = False
self._partial_stdout = None
self._extra_kwargs = extra_kwargs
self._timer = QTimer()
self._process = QProcess()
self._timer.setInterval(50)
self._timer.timeout.connect(self._communicate)
self._process.finished.connect(self._communicate)
self._process.readyReadStandardOutput.connect(self._partial)
def _partial(self):
raw_stdout = self._process.readAllStandardOutput()
stdout = handle_qbytearray(raw_stdout, _CondaAPI.UTF8)
json_stdout = stdout.replace('\n\x00', '')
try:
json_stdout = json.loads(json_stdout)
except Exception:
json_stdout = stdout
if self._partial_stdout is None:
self._partial_stdout = stdout
else:
self._partial_stdout += stdout
self.sig_partial.emit(self, json_stdout, None)
def _communicate(self):
"""
"""
if not self._communicate_first:
if self._process.state() == QProcess.NotRunning:
self.communicate()
elif self._fired:
self._timer.stop()
def communicate(self):
"""
"""
self._communicate_first = True
self._process.waitForFinished()
if self._partial_stdout is None:
raw_stdout = self._process.readAllStandardOutput()
stdout = handle_qbytearray(raw_stdout, _CondaAPI.UTF8)
else:
stdout = self._partial_stdout
raw_stderr = self._process.readAllStandardError()
stderr = handle_qbytearray(raw_stderr, _CondaAPI.UTF8)
result = [stdout.encode(_CondaAPI.UTF8), stderr.encode(_CondaAPI.UTF8)]
# FIXME: Why does anaconda client print to stderr???
if PY2:
stderr = stderr.decode()
if 'using anaconda cloud api site' not in stderr.lower():
if stderr.strip() and self._conda:
raise Exception('{0}:\n'
'STDERR:\n{1}\nEND'
''.format(' '.join(self._cmd_list),
stderr))
# elif stderr.strip() and self._pip:
# raise PipError(self._cmd_list)
else:
result[-1] = ''
if self._parse and stdout:
try:
result = json.loads(stdout), result[-1]
except ValueError as error:
result = stdout, error
if 'error' in result[0]:
error = '{0}: {1}'.format(" ".join(self._cmd_list),
result[0]['error'])
result = result[0], error
if self._callback:
result = self._callback(result[0], result[-1],
**self._extra_kwargs), result[-1]
self._result = result
self.sig_finished.emit(self, result[0], result[-1])
if result[-1]:
logger.error(str(('error', result[-1])))
self._fired = True
return result
def close(self):
"""
"""
self._process.close()
def is_finished(self):
"""
"""
return self._process.state() == QProcess.NotRunning and self._fired
def start(self):
"""
"""
logger.debug(str(' '.join(self._cmd_list)))
if not self._fired:
self._partial_ouput = None
self._process.start(self._cmd_list[0], self._cmd_list[1:])
self._timer.start()
else:
raise CondaProcessWorker('A Conda ProcessWorker can only run once '
'per method call.')
# --- API
# -----------------------------------------------------------------------------
class _CondaAPI(QObject):
"""
"""
ROOT_PREFIX = None
ENCODING = 'ascii'
UTF8 = 'utf-8'
DEFAULT_CHANNELS = ['https://repo.continuum.io/pkgs/pro',
'https://repo.continuum.io/pkgs/free']
def __init__(self, parent=None):
super(_CondaAPI, self).__init__()
self._parent = parent
self._queue = deque()
self._timer = QTimer()
self._current_worker = None
self._workers = []
self._timer.setInterval(1000)
self._timer.timeout.connect(self._clean)
self.set_root_prefix()
def _clean(self):
"""
Periodically check for inactive workers and remove their references.
"""
if self._workers:
for w in self._workers:
if w.is_finished():
self._workers.remove(w)
else:
self._current_worker = None
self._timer.stop()
def _start(self):
"""
"""
if len(self._queue) == 1:
self._current_worker = self._queue.popleft()
self._workers.append(self._current_worker)
self._current_worker.start()
self._timer.start()
def is_active(self):
"""
Check if a worker is still active.
"""
return len(self._workers) == 0
def terminate_all_processes(self):
"""
Kill all working processes.
"""
for worker in self._workers:
worker.close()
# --- Conda api
# -------------------------------------------------------------------------
def _call_conda(self, extra_args, abspath=True, parse=False,
callback=None):
"""
Call conda with the list of extra arguments, and return the worker.
The result can be force by calling worker.communicate(), which returns
the tuple (stdout, stderr).
"""
if abspath:
if sys.platform == 'win32':
python = join(self.ROOT_PREFIX, 'python.exe')
conda = join(self.ROOT_PREFIX, 'Scripts',
'conda-script.py')
else:
python = join(self.ROOT_PREFIX, 'bin/python')
conda = join(self.ROOT_PREFIX, 'bin/conda')
cmd_list = [python, conda]
else:
# Just use whatever conda is on the path
cmd_list = ['conda']
cmd_list.extend(extra_args)
process_worker = ProcessWorker(cmd_list, parse=parse,
callback=callback)
process_worker.sig_finished.connect(self._start)
self._queue.append(process_worker)
self._start()
return process_worker
def _call_and_parse(self, extra_args, abspath=True, callback=None):
"""
"""
return self._call_conda(extra_args, abspath=abspath, parse=True,
callback=callback)
def _setup_install_commands_from_kwargs(self, kwargs, keys=tuple()):
cmd_list = []
if kwargs.get('override_channels', False) and 'channel' not in kwargs:
raise TypeError('conda search: override_channels requires channel')
if 'env' in kwargs:
cmd_list.extend(['--name', kwargs.pop('env')])
if 'prefix' in kwargs:
cmd_list.extend(['--prefix', kwargs.pop('prefix')])
if 'channel' in kwargs:
channel = kwargs.pop('channel')
if isinstance(channel, str):
cmd_list.extend(['--channel', channel])
else:
cmd_list.append('--channel')
cmd_list.extend(channel)
for key in keys:
if key in kwargs and kwargs[key]:
cmd_list.append('--' + key.replace('_', '-'))
return cmd_list
def set_root_prefix(self, prefix=None):
"""
Set the prefix to the root environment (default is /opt/anaconda).
This function should only be called once (right after importing
conda_api).
"""
if prefix:
self.ROOT_PREFIX = prefix
else:
# Find some conda instance, and then use info to get 'root_prefix'
worker = self._call_and_parse(['info', '--json'], abspath=False)
info = worker.communicate()[0]
self.ROOT_PREFIX = info['root_prefix']
def get_conda_version(self):
"""
Return the version of conda being used (invoked) as a string.
"""
return self._call_conda(['--version'],
callback=self._get_conda_version)
def _get_conda_version(self, stdout, stderr):
# argparse outputs version to stderr in Python < 3.4.
# http://bugs.python.org/issue18920
pat = re.compile(r'conda:?\s+(\d+\.\d\S+|unknown)')
m = pat.match(stderr.decode().strip())
if m is None:
m = pat.match(stdout.decode().strip())
if m is None:
raise Exception('output did not match: {0}'.format(stderr))
return m.group(1)
def get_envs(self):
"""
Return all of the (named) environment (this does not include the root
environment), as a list of absolute path to their prefixes.
"""
logger.debug('')
# return self._call_and_parse(['info', '--json'],
# callback=lambda o, e: o['envs'])
envs = os.listdir(os.sep.join([self.ROOT_PREFIX, 'envs']))
envs = [os.sep.join([self.ROOT_PREFIX, 'envs', i]) for i in envs]
valid_envs = [e for e in envs if os.path.isdir(e) and
self.environment_exists(prefix=e)]
return valid_envs
def get_prefix_envname(self, name):
"""
Given the name of an environment return its full prefix path, or None
if it cannot be found.
"""
prefix = None
if name == 'root':
prefix = self.ROOT_PREFIX
# envs, error = self.get_envs().communicate()
envs = self.get_envs()
for p in envs:
if basename(p) == name:
prefix = p
return prefix
def linked(self, prefix):
"""
Return the (set of canonical names) of linked packages in `prefix`.
"""
logger.debug(str(prefix))
if not isdir(prefix):
raise Exception('no such directory: {0}'.format(prefix))
meta_dir = join(prefix, 'conda-meta')
if not isdir(meta_dir):
# We might have nothing in linked (and no conda-meta directory)
return set()
return set(fn[:-5] for fn in os.listdir(meta_dir)
if fn.endswith('.json'))
def split_canonical_name(self, cname):
"""
Split a canonical package name into (name, version, build) strings.
"""
return tuple(cname.rsplit('-', 2))
def info(self, abspath=True):
"""
Return a dictionary with configuration information.
No guarantee is made about which keys exist. Therefore this function
should only be used for testing and debugging.
"""
logger.debug(str(''))
return self._call_and_parse(['info', '--json'], abspath=abspath)
def package_info(self, package, abspath=True):
"""
Return a dictionary with package information.
"""
return self._call_and_parse(['info', package, '--json'],
abspath=abspath)
def search(self, regex=None, spec=None, **kwargs):
"""
Search for packages.
"""
cmd_list = ['search', '--json']
if regex and spec:
raise TypeError('conda search: only one of regex or spec allowed')
if regex:
cmd_list.append(regex)
if spec:
cmd_list.extend(['--spec', spec])
if 'platform' in kwargs:
cmd_list.extend(['--platform', kwargs.pop('platform')])
cmd_list.extend(
self._setup_install_commands_from_kwargs(
kwargs,
('canonical', 'unknown', 'use_index_cache', 'outdated',
'override_channels')))
return self._call_and_parse(cmd_list,
abspath=kwargs.get('abspath', True))
def create(self, name=None, prefix=None, pkgs=None, channels=None):
"""
Create an environment either by name or path with a specified set of
packages.
"""
logger.debug(str((prefix, pkgs, channels)))
# TODO: Fix temporal hack
if not pkgs or not isinstance(pkgs, (list, tuple, str)):
raise TypeError('must specify a list of one or more packages to '
'install into new environment')
cmd_list = ['create', '--yes', '--quiet', '--json', '--mkdir']
if name:
ref = name
search = [os.path.join(d, name) for d in
self.info().communicate()[0]['envs_dirs']]
cmd_list.extend(['--name', name])
elif prefix:
ref = prefix
search = [prefix]
cmd_list.extend(['--prefix', prefix])
else:
raise TypeError('must specify either an environment name or a '
'path for new environment')
if any(os.path.exists(prefix) for prefix in search):
raise CondaEnvExistsError('Conda environment {0} already '
'exists'.format(ref))
# TODO: Fix temporal hack
if isinstance(pkgs, (list, tuple)):
cmd_list.extend(pkgs)
elif isinstance(pkgs, str):
cmd_list.extend(['--file', pkgs])
# TODO: Check if correct
if channels:
cmd_list.extend(['--override-channels'])
for channel in channels:
cmd_list.extend(['--channel'])
cmd_list.extend([channel])
return self._call_and_parse(cmd_list)
def parse_token_channel(self, channel, token):
"""
Adapt a channel to include the authentication token of the logged
user.
Ignore default channels
"""
if token and channel not in self.DEFAULT_CHANNELS:
url_parts = channel.split('/')
start = url_parts[:-1]
middle = 't/{0}'.format(token)
end = url_parts[-1]
token_channel = '{0}/{1}/{2}'.format('/'.join(start), middle, end)
return token_channel
else:
return channel
def install(self, name=None, prefix=None, pkgs=None, dep=True,
channels=None, token=None):
"""
Install packages into an environment either by name or path with a
specified set of packages.
If token is specified, the channels different from the defaults will
get the token appended.
"""
logger.debug(str((prefix, pkgs, channels)))
# TODO: Fix temporal hack
if not pkgs or not isinstance(pkgs, (list, tuple, str)):
raise TypeError('must specify a list of one or more packages to '
'install into existing environment')
cmd_list = ['install', '--yes', '--json', '--force-pscheck']
if name:
cmd_list.extend(['--name', name])
elif prefix:
cmd_list.extend(['--prefix', prefix])
else:
# Just install into the current environment, whatever that is
pass
# TODO: Check if correct
if channels:
cmd_list.extend(['--override-channels'])
for channel in channels:
cmd_list.extend(['--channel'])
channel = self.parse_token_channel(channel, token)
cmd_list.extend([channel])
# TODO: Fix temporal hack
if isinstance(pkgs, (list, tuple)):
cmd_list.extend(pkgs)
elif isinstance(pkgs, str):
cmd_list.extend(['--file', pkgs])
if not dep:
cmd_list.extend(['--no-deps'])
return self._call_and_parse(cmd_list)
def update(self, *pkgs, **kwargs):
"""
Update package(s) (in an environment) by name.
"""
cmd_list = ['update', '--json', '--quiet', '--yes']
if not pkgs and not kwargs.get('all'):
raise TypeError("Must specify at least one package to update, or "
"all=True.")
cmd_list.extend(
self._setup_install_commands_from_kwargs(
kwargs,
('dry_run', 'no_deps', 'override_channels',
'no_pin', 'force', 'all', 'use_index_cache', 'use_local',
'alt_hint')))
cmd_list.extend(pkgs)
return self._call_and_parse(cmd_list, abspath=kwargs.get('abspath',
True))
def remove(self, name=None, prefix=None, pkgs=None, all_=False):
"""
Remove a package (from an environment) by name.
Returns {
success: bool, (this is always true),
(other information)
}
"""
logger.debug(str((prefix, pkgs)))
cmd_list = ['remove', '--json', '--quiet', '--yes']
if not pkgs and not all_:
raise TypeError("Must specify at least one package to remove, or "
"all=True.")
if name:
cmd_list.extend(['--name', name])
elif prefix:
cmd_list.extend(['--prefix', prefix])
else:
raise TypeError('must specify either an environment name or a '
'path for package removal')
if all_:
cmd_list.extend(['--all'])
else:
cmd_list.extend(pkgs)
return self._call_and_parse(cmd_list)
def remove_environment(self, name=None, path=None, **kwargs):
"""
Remove an environment entirely.
See ``remove``.
"""
return self.remove(name=name, path=path, all=True, **kwargs)
def clone_environment(self, clone, name=None, prefix=None, **kwargs):
"""
Clone the environment `clone` into `name` or `prefix`.
"""
cmd_list = ['create', '--json', '--quiet']
if (name and prefix) or not (name or prefix):
raise TypeError("conda clone_environment: exactly one of `name` "
"or `path` required")
if name:
cmd_list.extend(['--name', name])
if prefix:
cmd_list.extend(['--prefix', prefix])
cmd_list.extend(['--clone', clone])
cmd_list.extend(
self._setup_install_commands_from_kwargs(
kwargs,
('dry_run', 'unknown', 'use_index_cache', 'use_local',
'no_pin', 'force', 'all', 'channel', 'override_channels',
'no_default_packages')))
return self._call_and_parse(cmd_list, abspath=kwargs.get('abspath',
True))
# FIXME:
def process(self, name=None, prefix=None, cmd=None):
"""
Create a Popen process for cmd using the specified args but in the
conda environment specified by name or prefix.
The returned object will need to be invoked with p.communicate() or
similar.
"""
if bool(name) == bool(prefix):
raise TypeError('exactly one of name or prefix must be specified')
if not cmd:
raise TypeError('cmd to execute must be specified')
if not args:
args = []
if name:
prefix = self.get_prefix_envname(name)
conda_env = dict(os.environ)
sep = os.pathsep
if sys.platform == 'win32':
conda_env['PATH'] = join(prefix,
'Scripts') + sep + conda_env['PATH']
else:
# Unix
conda_env['PATH'] = join(prefix, 'bin') + sep + conda_env['PATH']
conda_env['PATH'] = prefix + os.pathsep + conda_env['PATH']
cmd_list = [cmd]
cmd_list.extend(args)
# = self.subprocess.process(cmd_list, env=conda_env, stdin=stdin,
# stdout=stdout, stderr=stderr)
def _setup_config_from_kwargs(self, kwargs):
cmd_list = ['--json', '--force']
if 'file' in kwargs:
cmd_list.extend(['--file', kwargs['file']])
if 'system' in kwargs:
cmd_list.append('--system')
return cmd_list
def config_path(self, **kwargs):
"""
Get the path to the config file.
"""
cmd_list = ['config', '--get']
cmd_list.extend(self._setup_config_from_kwargs(kwargs))
return self._call_and_parse(cmd_list,
abspath=kwargs.get('abspath', True),
callback=lambda o, e: o['rc_path'])
def config_get(self, *keys, **kwargs):
"""
Get the values of configuration keys.
Returns a dictionary of values. Note, the key may not be in the
dictionary if the key wasn't set in the configuration file.
"""
cmd_list = ['config', '--get']
cmd_list.extend(keys)
cmd_list.extend(self._setup_config_from_kwargs(kwargs))
return self._call_and_parse(cmd_list,
abspath=kwargs.get('abspath', True),
callback=lambda o, e: o['get'])
def config_set(self, key, value, **kwargs):
"""
Set a key to a (bool) value.
Returns a list of warnings Conda may have emitted.
"""
cmd_list = ['config', '--set', key, str(value)]
cmd_list.extend(self._setup_config_from_kwargs(kwargs))
return self._call_and_parse(
cmd_list,
abspath=kwargs.get('abspath', True),
callback=lambda o, e: o.get('warnings', []))
def config_add(self, key, value, **kwargs):
"""
Add a value to a key.
Returns a list of warnings Conda may have emitted.
"""
cmd_list = ['config', '--add', key, value]
cmd_list.extend(self._setup_config_from_kwargs(kwargs))
return self._call_and_parse(
cmd_list,
abspath=kwargs.get('abspath', True),
callback=lambda o, e: o.get('warnings', []))
def config_remove(self, key, value, **kwargs):
"""
Remove a value from a key.
Returns a list of warnings Conda may have emitted.
"""
cmd_list = ['config', '--remove', key, value]
cmd_list.extend(self._setup_config_from_kwargs(kwargs))
return self._call_and_parse(
cmd_list,
abspath=kwargs.get('abspath', True),
callback=lambda o, e: o.get('warnings', []))
def config_delete(self, key, **kwargs):
"""
Remove a key entirely.
Returns a list of warnings Conda may have emitted.
"""
cmd_list = ['config', '--remove-key', key]
cmd_list.extend(self._setup_config_from_kwargs(kwargs))
return self._call_and_parse(
cmd_list,
abspath=kwargs.get('abspath', True),
callback=lambda o, e: o.get('warnings', []))
def run(self, command, abspath=True):
"""
Launch the specified app by name or full package name.
Returns a dictionary containing the key "fn", whose value is the full
package (ending in ``.tar.bz2``) of the app.
"""
cmd_list = ['run', '--json', command]
return self._call_and_parse(cmd_list, abspath=abspath)
# --- Additional methods
# -----------------------------------------------------------------------------
def dependencies(self, name=None, prefix=None, pkgs=None, channels=None,
dep=True):
"""
Get dependenciy list for packages to be installed into an environment
defined either by 'name' or 'prefix'.
"""
if not pkgs or not isinstance(pkgs, (list, tuple)):
raise TypeError('must specify a list of one or more packages to '
'install into existing environment')
cmd_list = ['install', '--dry-run', '--json', '--force-pscheck']
if not dep:
cmd_list.extend(['--no-deps'])
if name:
cmd_list.extend(['--name', name])
elif prefix:
cmd_list.extend(['--prefix', prefix])
else:
pass
cmd_list.extend(pkgs)
# TODO: Check if correct
if channels:
cmd_list.extend(['--override-channels'])
for channel in channels:
cmd_list.extend(['--channel'])
cmd_list.extend([channel])
return self._call_and_parse(cmd_list)
def environment_exists(self, name=None, prefix=None, abspath=True):
"""
Check if an environment exists by 'name' or by 'prefix'. If query is
by 'name' only the default conda environments directory is searched.
"""
logger.debug(str((name, prefix)))
if name and prefix:
raise TypeError("Exactly one of 'name' or 'prefix' is required.")
if name:
prefix = self.get_prefix_envname(name)
if prefix is None:
prefix = self.ROOT_PREFIX
return os.path.isdir(os.path.join(prefix, 'conda-meta'))
def clear_lock(self, abspath=True):
"""
Clean any conda lock in the system.
"""
cmd_list = ['clean', '--lock', '--json']
return self._call_and_parse(cmd_list, abspath=abspath)
def package_version(self, prefix=None, name=None, pkg=None):
"""
"""
package_versions = {}
if name and prefix:
raise TypeError("Exactly one of 'name' or 'prefix' is required.")
if name:
prefix = self.get_prefix_envname(name)
if self.environment_exists(prefix=prefix):
for package in self.linked(prefix):
if pkg in package:
n, v, b = self.split_canonical_name(package)
package_versions[n] = v
return package_versions.get(pkg, None)
def get_platform(self):
"""
Get platform of current system (system and bitness).
"""
_sys_map = {'linux2': 'linux', 'linux': 'linux',
'darwin': 'osx', 'win32': 'win', 'openbsd5': 'openbsd'}
non_x86_linux_machines = {'armv6l', 'armv7l', 'ppc64le'}
sys_platform = _sys_map.get(sys.platform, 'unknown')
bits = 8 * tuple.__itemsize__
if (sys_platform == 'linux' and
platform.machine() in non_x86_linux_machines):
arch_name = platform.machine()
subdir = 'linux-{0}'.format(arch_name)
else:
arch_name = {64: 'x86_64', 32: 'x86'}[bits]
subdir = '{0}-{1}'.format(sys_platform, bits)
return subdir
def get_condarc_channels(self):
"""
Returns all the channel urls defined in .condarc using the defined
`channel_alias`.
If no condarc file is found, use the default channels.
"""
# First get the location of condarc file and parse it to get
# the channel alias and the channels.
default_channel_alias = 'https://conda.anaconda.org'
default_urls = ['https://repo.continuum.io/pkgs/free',
'https://repo.continuum.io/pkgs/pro']
condarc_path = os.path.abspath(os.path.expanduser('~/.condarc'))
channels = default_urls[:]
if not os.path.isfile(condarc_path):
condarc = None
channel_alias = default_channel_alias
else:
with open(condarc_path, 'r') as f:
data = f.read()
condarc = yaml.load(data)
channels += condarc.get('channels', [])
channel_alias = condarc.get('channel_alias',
default_channel_alias)
if channel_alias[-1] == '/':
template = "{0}{1}"
else:
template = "{0}/{1}"
if 'defaults' in channels:
channels.remove('defaults')
channel_urls = []
for channel in channels:
if not channel.startswith('http'):
channel_url = template.format(channel_alias, channel)
else:
channel_url = channel
channel_urls.append(channel_url)
return channel_urls
# --- Pip commands
# -------------------------------------------------------------------------
def _call_pip(self, name=None, prefix=None, extra_args=None,
callback=None):
""" """
cmd_list = self._pip_cmd(name=name, prefix=prefix)
cmd_list.extend(extra_args)
process_worker = ProcessWorker(cmd_list, pip=True, callback=callback)
process_worker.sig_finished.connect(self._start)
self._queue.append(process_worker)
self._start()
return process_worker
def _pip_cmd(self, name=None, prefix=None):
"""
Get pip location based on environment `name` or `prefix`.
"""
if (name and prefix) or not (name or prefix):
raise TypeError("conda pip: exactly one of 'name' ""or 'prefix' "
"required.")
if name and self.environment_exists(name=name):
prefix = self.get_prefix_envname(name)
if sys.platform == 'win32':
python = join(prefix, 'python.exe') # FIXME:
pip = join(prefix, 'pip.exe') # FIXME:
else:
python = join(prefix, 'bin/python')
pip = join(prefix, 'bin/pip')
cmd_list = [python, pip]
return cmd_list
def pip_list(self, name=None, prefix=None, abspath=True):
"""
Get list of pip installed packages.
"""
if (name and prefix) or not (name or prefix):
raise TypeError("conda pip: exactly one of 'name' ""or 'prefix' "
"required.")
if name:
prefix = self.get_prefix_envname(name)
pip_command = os.sep.join([prefix, 'bin', 'python'])
cmd_list = [pip_command, PIP_LIST_SCRIPT]
process_worker = ProcessWorker(cmd_list, pip=True, parse=True,
callback=self._pip_list,
extra_kwargs={'prefix': prefix})
process_worker.sig_finished.connect(self._start)
self._queue.append(process_worker)
self._start()
return process_worker
# if name:
# cmd_list = ['list', '--name', name]
# if prefix:
# cmd_list = ['list', '--prefix', prefix]
# return self._call_conda(cmd_list, abspath=abspath,
# callback=self._pip_list)
def _pip_list(self, stdout, stderr, prefix=None):
"""
"""
result = stdout # A dict
linked = self.linked(prefix)
pip_only = []
linked_names = [self.split_canonical_name(l)[0] for l in linked]
for pkg in result:
name = self.split_canonical_name(pkg)[0]
if name not in linked_names:
pip_only.append(pkg)
# FIXME: NEED A MORE ROBUST WAY!
# if '<pip>' in line and '#' not in line:
# temp = line.split()[:-1] + ['pip']
# temp = '-'.join(temp)
# if '-(' in temp:
# start = temp.find('-(')
# end = temp.find(')')
# substring = temp[start:end+1]
# temp = temp.replace(substring, '')
# result.append(temp)
return pip_only
def pip_remove(self, name=None, prefix=None, pkgs=None):
"""
Remove a pip package in given environment by `name` or `prefix`.
"""
logger.debug(str((prefix, pkgs)))
if isinstance(pkgs, list) or isinstance(pkgs, tuple):
pkg = ' '.join(pkgs)
else:
pkg = pkgs
extra_args = ['uninstall', '--yes', pkg]
return self._call_pip(name=name, prefix=prefix, extra_args=extra_args)
def pip_search(self, search_string=None):
"""
Search for pip installable python packages in PyPI matching
`search_string`.
"""
extra_args = ['search', search_string]
return self._call_pip(name='root', extra_args=extra_args,
callback=self._pip_search)
# if stderr:
# raise PipError(stderr)
# You are using pip version 7.1.2, however version 8.0.2 is available.
# You should consider upgrading via the 'pip install --upgrade pip'
# command.
def _pip_search(self, stdout, stderr):
result = {}
lines = to_text_string(stdout).split('\n')
while '' in lines:
lines.remove('')
for line in lines:
if ' - ' in line:
parts = line.split(' - ')
name = parts[0].strip()
description = parts[1].strip()
result[name] = description
return result
CONDA_API = None
def CondaAPI():
global CONDA_API
if CONDA_API is None:
CONDA_API = _CondaAPI()
return CONDA_API
COUNTER = 0
def ready_print(worker, output, error):
global COUNTER
COUNTER += 1
print(COUNTER, output, error)
def test():
"""
"""
from conda_manager.utils.qthelpers import qapplication
app = qapplication()
conda_api = CondaAPI()
# print(conda_api.get_condarc_channels())
# worker = conda_api.info()
## worker.sig_finished.connect(ready_print)
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.info()
# worker = conda_api.pip_search('spyder')
# worker.sig_finished.connect(ready_print)
worker = conda_api.pip_list(name='py3')
worker.sig_finished.connect(ready_print)
# print(conda_api.package_version(name='root', pkg='spyder'))
app.exec_()
if __name__ == '__main__':
test()
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
test/e2e/app_management_test.go
|
package e2e
import (
"context"
"fmt"
"math/rand"
"os"
"path"
"reflect"
"regexp"
"strings"
"testing"
"time"
"github.com/argoproj/gitops-engine/pkg/diff"
"github.com/argoproj/gitops-engine/pkg/health"
. "github.com/argoproj/gitops-engine/pkg/sync/common"
. "github.com/argoproj/gitops-engine/pkg/utils/errors"
"github.com/argoproj/gitops-engine/pkg/utils/io"
"github.com/argoproj/gitops-engine/pkg/utils/kube"
"github.com/argoproj/pkg/errors"
log "github.com/sirupsen/logrus"
"github.com/stretchr/testify/assert"
v1 "k8s.io/api/core/v1"
networkingv1beta "k8s.io/api/networking/v1beta1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/utils/pointer"
"github.com/argoproj/argo-cd/common"
applicationpkg "github.com/argoproj/argo-cd/pkg/apiclient/application"
repositorypkg "github.com/argoproj/argo-cd/pkg/apiclient/repository"
. "github.com/argoproj/argo-cd/pkg/apis/application/v1alpha1"
. "github.com/argoproj/argo-cd/test/e2e/fixture"
. "github.com/argoproj/argo-cd/test/e2e/fixture/app"
. "github.com/argoproj/argo-cd/util/argo"
"github.com/argoproj/argo-cd/util/settings"
)
const (
guestbookPath = "guestbook"
guestbookPathLocal = "./testdata/guestbook_local"
globalWithNoNameSpace = "global-with-no-namesapce"
guestbookWithNamespace = "guestbook-with-namespace"
)
func TestSyncToUnsignedCommit(t *testing.T) {
Given(t).
Project("gpg").
Path(guestbookPath).
When().
IgnoreErrors().
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationError)).
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
Expect(HealthIs(health.HealthStatusMissing))
}
func TestSyncToSignedCommitWithoutKnownKey(t *testing.T) {
Given(t).
Project("gpg").
Path(guestbookPath).
When().
AddSignedFile("test.yaml", "null").
IgnoreErrors().
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationError)).
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
Expect(HealthIs(health.HealthStatusMissing))
}
func TestSyncToSignedCommitKeyWithKnownKey(t *testing.T) {
Given(t).
Project("gpg").
Path(guestbookPath).
GPGPublicKeyAdded().
Sleep(2).
When().
AddSignedFile("test.yaml", "null").
IgnoreErrors().
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(HealthIs(health.HealthStatusHealthy))
}
func TestAppCreation(t *testing.T) {
ctx := Given(t)
ctx.
Path(guestbookPath).
When().
Create().
Then().
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
And(func(app *Application) {
assert.Equal(t, Name(), app.Name)
assert.Equal(t, RepoURL(RepoURLTypeFile), app.Spec.Source.RepoURL)
assert.Equal(t, guestbookPath, app.Spec.Source.Path)
assert.Equal(t, DeploymentNamespace(), app.Spec.Destination.Namespace)
assert.Equal(t, common.KubernetesInternalAPIServerAddr, app.Spec.Destination.Server)
}).
Expect(Event(EventReasonResourceCreated, "create")).
And(func(_ *Application) {
// app should be listed
output, err := RunCli("app", "list")
assert.NoError(t, err)
assert.Contains(t, output, Name())
}).
When().
// ensure that create is idempotent
Create().
Then().
Given().
Revision("master").
When().
// ensure that update replaces spec and merge labels and annotations
And(func() {
FailOnErr(AppClientset.ArgoprojV1alpha1().Applications(ArgoCDNamespace).Patch(
ctx.GetName(), types.MergePatchType, []byte(`{"metadata": {"labels": { "test": "label" }, "annotations": { "test": "annotation" }}}`)))
}).
Create("--upsert").
Then().
And(func(app *Application) {
assert.Equal(t, "label", app.Labels["test"])
assert.Equal(t, "annotation", app.Annotations["test"])
assert.Equal(t, "master", app.Spec.Source.TargetRevision)
})
}
// demonstrate that we cannot use a standard sync when an immutable field is changed, we must use "force"
func TestImmutableChange(t *testing.T) {
text := FailOnErr(Run(".", "kubectl", "get", "service", "-n", "kube-system", "kube-dns", "-o", "jsonpath={.spec.clusterIP}")).(string)
parts := strings.Split(text, ".")
n := rand.Intn(254)
ip1 := fmt.Sprintf("%s.%s.%s.%d", parts[0], parts[1], parts[2], n)
ip2 := fmt.Sprintf("%s.%s.%s.%d", parts[0], parts[1], parts[2], n+1)
Given(t).
Path("service").
When().
Create().
PatchFile("service.yaml", fmt.Sprintf(`[{"op": "add", "path": "/spec/clusterIP", "value": "%s"}]`, ip1)).
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(HealthIs(health.HealthStatusHealthy)).
When().
PatchFile("service.yaml", fmt.Sprintf(`[{"op": "add", "path": "/spec/clusterIP", "value": "%s"}]`, ip2)).
IgnoreErrors().
Sync().
DoNotIgnoreErrors().
Then().
Expect(OperationPhaseIs(OperationFailed)).
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
Expect(ResourceResultNumbering(1)).
Expect(ResourceResultIs(ResourceResult{
Kind: "Service",
Version: "v1",
Namespace: DeploymentNamespace(),
Name: "my-service",
SyncPhase: "Sync",
Status: "SyncFailed",
HookPhase: "Failed",
Message: fmt.Sprintf(`Service "my-service" is invalid: spec.clusterIP: Invalid value: "%s": field is immutable`, ip2),
})).
// now we can do this will a force
Given().
Force().
When().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(HealthIs(health.HealthStatusHealthy))
}
func TestInvalidAppProject(t *testing.T) {
Given(t).
Path(guestbookPath).
Project("does-not-exist").
When().
IgnoreErrors().
Create().
Then().
Expect(Error("", "application references project does-not-exist which does not exist"))
}
func TestAppDeletion(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Then().
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
When().
Delete(true).
Then().
Expect(DoesNotExist()).
Expect(Event(EventReasonResourceDeleted, "delete"))
output, err := RunCli("app", "list")
assert.NoError(t, err)
assert.NotContains(t, output, Name())
}
func TestAppLabels(t *testing.T) {
Given(t).
Path("config-map").
When().
Create("-l", "foo=bar").
Then().
And(func(app *Application) {
assert.Contains(t, FailOnErr(RunCli("app", "list")), Name())
assert.Contains(t, FailOnErr(RunCli("app", "list", "-l", "foo=bar")), Name())
assert.NotContains(t, FailOnErr(RunCli("app", "list", "-l", "foo=rubbish")), Name())
}).
Given().
// remove both name and replace labels means nothing will sync
Name("").
When().
IgnoreErrors().
Sync("-l", "foo=rubbish").
DoNotIgnoreErrors().
Then().
Expect(Error("", "no apps match selector foo=rubbish")).
// check we can update the app and it is then sync'd
Given().
When().
Sync("-l", "foo=bar")
}
func TestTrackAppStateAndSyncApp(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(HealthIs(health.HealthStatusHealthy)).
Expect(Success(fmt.Sprintf("apps Deployment %s guestbook-ui OutOfSync Missing", DeploymentNamespace()))).
Expect(Success(fmt.Sprintf("Service %s guestbook-ui OutOfSync Missing", DeploymentNamespace()))).
Expect(Success(fmt.Sprintf("Service %s guestbook-ui Synced ", DeploymentNamespace()))).
Expect(Success(fmt.Sprintf("apps Deployment %s guestbook-ui Synced", DeploymentNamespace()))).
Expect(Event(EventReasonResourceUpdated, "sync")).
And(func(app *Application) {
assert.NotNil(t, app.Status.OperationState.SyncResult)
})
}
func TestAppRollbackSuccessful(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
assert.NotEmpty(t, app.Status.Sync.Revision)
}).
And(func(app *Application) {
appWithHistory := app.DeepCopy()
appWithHistory.Status.History = []RevisionHistory{{
ID: 1,
Revision: app.Status.Sync.Revision,
DeployedAt: metav1.Time{Time: metav1.Now().UTC().Add(-1 * time.Minute)},
Source: app.Spec.Source,
}, {
ID: 2,
Revision: "cdb",
DeployedAt: metav1.Time{Time: metav1.Now().UTC().Add(-2 * time.Minute)},
Source: app.Spec.Source,
}}
patch, _, err := diff.CreateTwoWayMergePatch(app, appWithHistory, &Application{})
assert.NoError(t, err)
app, err = AppClientset.ArgoprojV1alpha1().Applications(ArgoCDNamespace).Patch(app.Name, types.MergePatchType, patch)
assert.NoError(t, err)
// sync app and make sure it reaches InSync state
_, err = RunCli("app", "rollback", app.Name, "1")
assert.NoError(t, err)
}).
Expect(Event(EventReasonOperationStarted, "rollback")).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
assert.Equal(t, SyncStatusCodeSynced, app.Status.Sync.Status)
assert.NotNil(t, app.Status.OperationState.SyncResult)
assert.Equal(t, 2, len(app.Status.OperationState.SyncResult.Resources))
assert.Equal(t, OperationSucceeded, app.Status.OperationState.Phase)
assert.Equal(t, 3, len(app.Status.History))
})
}
func TestComparisonFailsIfClusterNotAdded(t *testing.T) {
Given(t).
Path(guestbookPath).
DestServer("https://not-registered-cluster/api").
When().
IgnoreErrors().
Create().
Then().
Expect(DoesNotExist())
}
func TestCannotSetInvalidPath(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
IgnoreErrors().
AppSet("--path", "garbage").
Then().
Expect(Error("", "app path does not exist"))
}
func TestManipulateApplicationResources(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
manifests, err := RunCli("app", "manifests", app.Name, "--source", "live")
assert.NoError(t, err)
resources, err := kube.SplitYAML(manifests)
assert.NoError(t, err)
index := -1
for i := range resources {
if resources[i].GetKind() == kube.DeploymentKind {
index = i
break
}
}
assert.True(t, index > -1)
deployment := resources[index]
closer, client, err := ArgoCDClientset.NewApplicationClient()
assert.NoError(t, err)
defer io.Close(closer)
_, err = client.DeleteResource(context.Background(), &applicationpkg.ApplicationResourceDeleteRequest{
Name: &app.Name,
Group: deployment.GroupVersionKind().Group,
Kind: deployment.GroupVersionKind().Kind,
Version: deployment.GroupVersionKind().Version,
Namespace: deployment.GetNamespace(),
ResourceName: deployment.GetName(),
})
assert.NoError(t, err)
}).
Expect(SyncStatusIs(SyncStatusCodeOutOfSync))
}
func assetSecretDataHidden(t *testing.T, manifest string) {
secret, err := UnmarshalToUnstructured(manifest)
assert.NoError(t, err)
_, hasStringData, err := unstructured.NestedMap(secret.Object, "stringData")
assert.NoError(t, err)
assert.False(t, hasStringData)
secretData, hasData, err := unstructured.NestedMap(secret.Object, "data")
assert.NoError(t, err)
assert.True(t, hasData)
for _, v := range secretData {
assert.Regexp(t, regexp.MustCompile(`[*]*`), v)
}
var lastAppliedConfigAnnotation string
annotations := secret.GetAnnotations()
if annotations != nil {
lastAppliedConfigAnnotation = annotations[v1.LastAppliedConfigAnnotation]
}
if lastAppliedConfigAnnotation != "" {
assetSecretDataHidden(t, lastAppliedConfigAnnotation)
}
}
func TestAppWithSecrets(t *testing.T) {
closer, client, err := ArgoCDClientset.NewApplicationClient()
assert.NoError(t, err)
defer io.Close(closer)
Given(t).
Path("secrets").
When().
Create().
Sync().
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
res := FailOnErr(client.GetResource(context.Background(), &applicationpkg.ApplicationResourceRequest{
Namespace: app.Spec.Destination.Namespace,
Kind: kube.SecretKind,
Group: "",
Name: &app.Name,
Version: "v1",
ResourceName: "test-secret",
})).(*applicationpkg.ApplicationResourceResponse)
assetSecretDataHidden(t, res.Manifest)
manifests, err := client.GetManifests(context.Background(), &applicationpkg.ApplicationManifestQuery{Name: &app.Name})
errors.CheckError(err)
for _, manifest := range manifests.Manifests {
assetSecretDataHidden(t, manifest)
}
diffOutput := FailOnErr(RunCli("app", "diff", app.Name)).(string)
assert.Empty(t, diffOutput)
// patch secret and make sure app is out of sync and diff detects the change
FailOnErr(KubeClientset.CoreV1().Secrets(DeploymentNamespace()).Patch(
"test-secret", types.JSONPatchType, []byte(`[
{"op": "remove", "path": "/data/username"},
{"op": "add", "path": "/stringData", "value": {"password": "foo"}}
]`)))
}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
And(func(app *Application) {
diffOutput, err := RunCli("app", "diff", app.Name)
assert.Error(t, err)
assert.Contains(t, diffOutput, "username: ++++++++")
assert.Contains(t, diffOutput, "password: ++++++++++++")
// local diff should ignore secrets
diffOutput = FailOnErr(RunCli("app", "diff", app.Name, "--local", "testdata/secrets")).(string)
assert.Empty(t, diffOutput)
// ignore missing field and make sure diff shows no difference
app.Spec.IgnoreDifferences = []ResourceIgnoreDifferences{{
Kind: kube.SecretKind, JSONPointers: []string{"/data"},
}}
FailOnErr(client.UpdateSpec(context.Background(), &applicationpkg.ApplicationUpdateSpecRequest{Name: &app.Name, Spec: app.Spec}))
}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
diffOutput := FailOnErr(RunCli("app", "diff", app.Name)).(string)
assert.Empty(t, diffOutput)
})
}
func TestResourceDiffing(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
// Patch deployment
_, err := KubeClientset.AppsV1().Deployments(DeploymentNamespace()).Patch(
"guestbook-ui", types.JSONPatchType, []byte(`[{ "op": "replace", "path": "/spec/template/spec/containers/0/image", "value": "test" }]`))
assert.NoError(t, err)
}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
And(func(app *Application) {
diffOutput, err := RunCli("app", "diff", app.Name, "--local", "testdata/guestbook")
assert.Error(t, err)
assert.Contains(t, diffOutput, fmt.Sprintf("===== apps/Deployment %s/guestbook-ui ======", DeploymentNamespace()))
}).
Given().
ResourceOverrides(map[string]ResourceOverride{"apps/Deployment": {
IgnoreDifferences: OverrideIgnoreDiff{JSONPointers: []string{"/spec/template/spec/containers/0/image"}},
}}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
diffOutput, err := RunCli("app", "diff", app.Name, "--local", "testdata/guestbook")
assert.NoError(t, err)
assert.Empty(t, diffOutput)
})
}
func TestCRDs(t *testing.T) {
testEdgeCasesApplicationResources(t, "crd-creation", health.HealthStatusHealthy)
}
func TestKnownTypesInCRDDiffing(t *testing.T) {
dummiesGVR := schema.GroupVersionResource{Group: "argoproj.io", Version: "v1alpha1", Resource: "dummies"}
Given(t).
Path("crd-creation").
When().Create().Sync().Then().
Expect(OperationPhaseIs(OperationSucceeded)).Expect(SyncStatusIs(SyncStatusCodeSynced)).
When().
And(func() {
dummyResIf := DynamicClientset.Resource(dummiesGVR).Namespace(DeploymentNamespace())
patchData := []byte(`{"spec":{"requests": {"cpu": "2"}}}`)
FailOnErr(dummyResIf.Patch("dummy-crd-instance", types.MergePatchType, patchData, metav1.PatchOptions{}))
}).Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
When().
And(func() {
SetResourceOverrides(map[string]ResourceOverride{
"argoproj.io/Dummy": {
KnownTypeFields: []KnownTypeField{{
Field: "spec.requests",
Type: "core/v1/ResourceList",
}},
},
})
}).
Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced))
}
func TestDuplicatedResources(t *testing.T) {
testEdgeCasesApplicationResources(t, "duplicated-resources", health.HealthStatusHealthy)
}
func TestConfigMap(t *testing.T) {
testEdgeCasesApplicationResources(t, "config-map", health.HealthStatusHealthy, "my-map Synced configmap/my-map created")
}
func TestFailedConversion(t *testing.T) {
defer func() {
FailOnErr(Run("", "kubectl", "delete", "apiservice", "v1beta1.metrics.k8s.io"))
}()
testEdgeCasesApplicationResources(t, "failed-conversion", health.HealthStatusProgressing)
}
func testEdgeCasesApplicationResources(t *testing.T, appPath string, statusCode health.HealthStatusCode, message ...string) {
expect := Given(t).
Path(appPath).
When().
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced))
for i := range message {
expect = expect.Expect(Success(message[i]))
}
expect.
Expect(HealthIs(statusCode)).
And(func(app *Application) {
diffOutput, err := RunCli("app", "diff", app.Name, "--local", path.Join("testdata", appPath))
assert.Empty(t, diffOutput)
assert.NoError(t, err)
})
}
func TestKsonnetApp(t *testing.T) {
Given(t).
Path("ksonnet").
Env("prod").
// Null out dest server to verify that destination is inferred from ksonnet app
Parameter("guestbook-ui=image=gcr.io/heptio-images/ks-guestbook-demo:0.1").
DestServer("").
When().
Create().
Sync().
Then().
And(func(app *Application) {
closer, client, err := ArgoCDClientset.NewRepoClient()
assert.NoError(t, err)
defer io.Close(closer)
details, err := client.GetAppDetails(context.Background(), &repositorypkg.RepoAppDetailsQuery{
Source: &app.Spec.Source,
})
assert.NoError(t, err)
serviceType := ""
for _, param := range details.Ksonnet.Parameters {
if param.Name == "type" && param.Component == "guestbook-ui" {
serviceType = param.Value
}
}
assert.Equal(t, serviceType, "LoadBalancer")
})
}
const actionsConfig = `discovery.lua: return { sample = {} }
definitions:
- name: sample
action.lua: |
obj.metadata.labels.sample = 'test'
return obj`
func TestResourceAction(t *testing.T) {
Given(t).
Path(guestbookPath).
ResourceOverrides(map[string]ResourceOverride{"apps/Deployment": {Actions: actionsConfig}}).
When().
Create().
Sync().
Then().
And(func(app *Application) {
closer, client, err := ArgoCDClientset.NewApplicationClient()
assert.NoError(t, err)
defer io.Close(closer)
actions, err := client.ListResourceActions(context.Background(), &applicationpkg.ApplicationResourceRequest{
Name: &app.Name,
Group: "apps",
Kind: "Deployment",
Version: "v1",
Namespace: DeploymentNamespace(),
ResourceName: "guestbook-ui",
})
assert.NoError(t, err)
assert.Equal(t, []ResourceAction{{Name: "sample", Disabled: false}}, actions.Actions)
_, err = client.RunResourceAction(context.Background(), &applicationpkg.ResourceActionRunRequest{Name: &app.Name,
Group: "apps",
Kind: "Deployment",
Version: "v1",
Namespace: DeploymentNamespace(),
ResourceName: "guestbook-ui",
Action: "sample",
})
assert.NoError(t, err)
deployment, err := KubeClientset.AppsV1().Deployments(DeploymentNamespace()).Get("guestbook-ui", metav1.GetOptions{})
assert.NoError(t, err)
assert.Equal(t, "test", deployment.Labels["sample"])
})
}
func TestSyncResourceByLabel(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
And(func(app *Application) {
_, _ = RunCli("app", "sync", app.Name, "--label", fmt.Sprintf("app.kubernetes.io/instance=%s", app.Name))
}).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
_, err := RunCli("app", "sync", app.Name, "--label", "this-label=does-not-exist")
assert.Error(t, err)
assert.Contains(t, err.Error(), "level=fatal")
})
}
func TestLocalManifestSync(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
And(func(app *Application) {
res, _ := RunCli("app", "manifests", app.Name)
assert.Contains(t, res, "containerPort: 80")
assert.Contains(t, res, "image: gcr.io/heptio-images/ks-guestbook-demo:0.2")
}).
Given().
LocalPath(guestbookPathLocal).
When().
Sync().
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
res, _ := RunCli("app", "manifests", app.Name)
assert.Contains(t, res, "containerPort: 81")
assert.Contains(t, res, "image: gcr.io/heptio-images/ks-guestbook-demo:0.3")
}).
Given().
LocalPath("").
When().
Sync().
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
res, _ := RunCli("app", "manifests", app.Name)
assert.Contains(t, res, "containerPort: 80")
assert.Contains(t, res, "image: gcr.io/heptio-images/ks-guestbook-demo:0.2")
})
}
func TestLocalSync(t *testing.T) {
Given(t).
// we've got to use Helm as this uses kubeVersion
Path("helm").
When().
Create().
Then().
And(func(app *Application) {
FailOnErr(RunCli("app", "sync", app.Name, "--local", "testdata/helm"))
})
}
func TestNoLocalSyncWithAutosyncEnabled(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
And(func(app *Application) {
_, err := RunCli("app", "set", app.Name, "--sync-policy", "automated")
assert.NoError(t, err)
_, err = RunCli("app", "sync", app.Name, "--local", guestbookPathLocal)
assert.Error(t, err)
})
}
func TestLocalSyncDryRunWithAutosyncEnabled(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
Create().
Sync().
Then().
And(func(app *Application) {
_, err := RunCli("app", "set", app.Name, "--sync-policy", "automated")
assert.NoError(t, err)
appBefore := app.DeepCopy()
_, err = RunCli("app", "sync", app.Name, "--dry-run", "--local", guestbookPathLocal)
assert.NoError(t, err)
appAfter := app.DeepCopy()
assert.True(t, reflect.DeepEqual(appBefore, appAfter))
})
}
func TestSyncAsync(t *testing.T) {
Given(t).
Path(guestbookPath).
Async(true).
When().
Create().
Sync().
Then().
Expect(Success("")).
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced))
}
func TestPermissions(t *testing.T) {
EnsureCleanState(t)
appName := Name()
_, err := RunCli("proj", "create", "test")
assert.NoError(t, err)
// make sure app cannot be created without permissions in project
_, err = RunCli("app", "create", appName, "--repo", RepoURL(RepoURLTypeFile),
"--path", guestbookPath, "--project", "test", "--dest-server", common.KubernetesInternalAPIServerAddr, "--dest-namespace", DeploymentNamespace())
assert.Error(t, err)
sourceError := fmt.Sprintf("application repo %s is not permitted in project 'test'", RepoURL(RepoURLTypeFile))
destinationError := fmt.Sprintf("application destination {%s %s} is not permitted in project 'test'", common.KubernetesInternalAPIServerAddr, DeploymentNamespace())
assert.Contains(t, err.Error(), sourceError)
assert.Contains(t, err.Error(), destinationError)
proj, err := AppClientset.ArgoprojV1alpha1().AppProjects(ArgoCDNamespace).Get("test", metav1.GetOptions{})
assert.NoError(t, err)
proj.Spec.Destinations = []ApplicationDestination{{Server: "*", Namespace: "*"}}
proj.Spec.SourceRepos = []string{"*"}
proj, err = AppClientset.ArgoprojV1alpha1().AppProjects(ArgoCDNamespace).Update(proj)
assert.NoError(t, err)
// make sure controller report permissions issues in conditions
_, err = RunCli("app", "create", appName, "--repo", RepoURL(RepoURLTypeFile),
"--path", guestbookPath, "--project", "test", "--dest-server", common.KubernetesInternalAPIServerAddr, "--dest-namespace", DeploymentNamespace())
assert.NoError(t, err)
defer func() {
err = AppClientset.ArgoprojV1alpha1().Applications(ArgoCDNamespace).Delete(appName, &metav1.DeleteOptions{})
assert.NoError(t, err)
}()
proj.Spec.Destinations = []ApplicationDestination{}
proj.Spec.SourceRepos = []string{}
_, err = AppClientset.ArgoprojV1alpha1().AppProjects(ArgoCDNamespace).Update(proj)
assert.NoError(t, err)
time.Sleep(1 * time.Second)
closer, client, err := ArgoCDClientset.NewApplicationClient()
assert.NoError(t, err)
defer io.Close(closer)
refresh := string(RefreshTypeNormal)
app, err := client.Get(context.Background(), &applicationpkg.ApplicationQuery{Name: &appName, Refresh: &refresh})
assert.NoError(t, err)
destinationErrorExist := false
sourceErrorExist := false
for i := range app.Status.Conditions {
if strings.Contains(app.Status.Conditions[i].Message, destinationError) {
destinationErrorExist = true
}
if strings.Contains(app.Status.Conditions[i].Message, sourceError) {
sourceErrorExist = true
}
}
assert.True(t, destinationErrorExist)
assert.True(t, sourceErrorExist)
}
// make sure that if we deleted a resource from the app, it is not pruned if annotated with Prune=false
func TestSyncOptionPruneFalse(t *testing.T) {
Given(t).
Path("two-nice-pods").
When().
PatchFile("pod-1.yaml", `[{"op": "add", "path": "/metadata/annotations", "value": {"argocd.argoproj.io/sync-options": "Prune=false"}}]`).
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
When().
DeleteFile("pod-1.yaml").
Refresh(RefreshTypeHard).
IgnoreErrors().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
Expect(ResourceSyncStatusIs("Pod", "pod-1", SyncStatusCodeOutOfSync))
}
// make sure that if we have an invalid manifest, we can add it if we disable validation, we get a server error rather than a client error
func TestSyncOptionValidateFalse(t *testing.T) {
// k3s does not validate at all, so this test does not work
if os.Getenv("ARGOCD_E2E_K3S") == "true" {
t.SkipNow()
}
Given(t).
Path("crd-validation").
When().
Create().
Then().
Expect(Success("")).
When().
IgnoreErrors().
Sync().
Then().
// client error
Expect(Error("error validating data", "")).
When().
PatchFile("deployment.yaml", `[{"op": "add", "path": "/metadata/annotations", "value": {"argocd.argoproj.io/sync-options": "Validate=false"}}]`).
Sync().
Then().
// server error
Expect(Error("Error from server", ""))
}
// make sure that, if we have a resource that needs pruning, but we're ignoring it, the app is in-sync
func TestCompareOptionIgnoreExtraneous(t *testing.T) {
Given(t).
Prune(false).
Path("two-nice-pods").
When().
PatchFile("pod-1.yaml", `[{"op": "add", "path": "/metadata/annotations", "value": {"argocd.argoproj.io/compare-options": "IgnoreExtraneous"}}]`).
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
When().
DeleteFile("pod-1.yaml").
Refresh(RefreshTypeHard).
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
assert.Len(t, app.Status.Resources, 2)
statusByName := map[string]SyncStatusCode{}
for _, r := range app.Status.Resources {
statusByName[r.Name] = r.Status
}
assert.Equal(t, SyncStatusCodeOutOfSync, statusByName["pod-1"])
assert.Equal(t, SyncStatusCodeSynced, statusByName["pod-2"])
}).
When().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced))
}
func TestSelfManagedApps(t *testing.T) {
Given(t).
Path("self-managed-app").
When().
PatchFile("resources.yaml", fmt.Sprintf(`[{"op": "replace", "path": "/spec/source/repoURL", "value": "%s"}]`, RepoURL(RepoURLTypeFile))).
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(a *Application) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
defer cancel()
reconciledCount := 0
var lastReconciledAt *metav1.Time
for event := range ArgoCDClientset.WatchApplicationWithRetry(ctx, a.Name, a.ResourceVersion) {
reconciledAt := event.Application.Status.ReconciledAt
if reconciledAt == nil {
reconciledAt = &metav1.Time{}
}
if lastReconciledAt != nil && !lastReconciledAt.Equal(reconciledAt) {
reconciledCount = reconciledCount + 1
}
lastReconciledAt = reconciledAt
}
assert.True(t, reconciledCount < 3, "Application was reconciled too many times")
})
}
func TestExcludedResource(t *testing.T) {
Given(t).
ResourceOverrides(map[string]ResourceOverride{"apps/Deployment": {Actions: actionsConfig}}).
Path(guestbookPath).
ResourceFilter(settings.ResourcesFilter{
ResourceExclusions: []settings.FilteredResource{{Kinds: []string{kube.DeploymentKind}}},
}).
When().
Create().
Sync().
Refresh(RefreshTypeNormal).
Then().
Expect(Condition(ApplicationConditionExcludedResourceWarning, "Resource apps/Deployment guestbook-ui is excluded in the settings"))
}
func TestRevisionHistoryLimit(t *testing.T) {
Given(t).
Path("config-map").
When().
Create().
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
assert.Len(t, app.Status.History, 1)
}).
When().
AppSet("--revision-history-limit", "1").
Sync().
Then().
Expect(OperationPhaseIs(OperationSucceeded)).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
assert.Len(t, app.Status.History, 1)
})
}
func TestOrphanedResource(t *testing.T) {
Given(t).
ProjectSpec(AppProjectSpec{
SourceRepos: []string{"*"},
Destinations: []ApplicationDestination{{Namespace: "*", Server: "*"}},
OrphanedResources: &OrphanedResourcesMonitorSettings{Warn: pointer.BoolPtr(true)},
}).
Path(guestbookPath).
When().
Create().
Sync().
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(NoConditions()).
When().
And(func() {
FailOnErr(KubeClientset.CoreV1().ConfigMaps(DeploymentNamespace()).Create(&v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: "orphaned-configmap",
},
}))
}).
Refresh(RefreshTypeNormal).
Then().
Expect(Condition(ApplicationConditionOrphanedResourceWarning, "Application has 1 orphaned resources")).
Given().
ProjectSpec(AppProjectSpec{
SourceRepos: []string{"*"},
Destinations: []ApplicationDestination{{Namespace: "*", Server: "*"}},
OrphanedResources: &OrphanedResourcesMonitorSettings{Warn: pointer.BoolPtr(true), Ignore: []OrphanedResourceKey{{Group: "Test", Kind: "ConfigMap"}}},
}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(Condition(ApplicationConditionOrphanedResourceWarning, "Application has 1 orphaned resources")).
Given().
ProjectSpec(AppProjectSpec{
SourceRepos: []string{"*"},
Destinations: []ApplicationDestination{{Namespace: "*", Server: "*"}},
OrphanedResources: &OrphanedResourcesMonitorSettings{Warn: pointer.BoolPtr(true), Ignore: []OrphanedResourceKey{{Kind: "ConfigMap"}}},
}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(NoConditions()).
Given().
ProjectSpec(AppProjectSpec{
SourceRepos: []string{"*"},
Destinations: []ApplicationDestination{{Namespace: "*", Server: "*"}},
OrphanedResources: &OrphanedResourcesMonitorSettings{Warn: pointer.BoolPtr(true), Ignore: []OrphanedResourceKey{{Kind: "ConfigMap", Name: "orphaned-configmap"}}},
}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(NoConditions()).
Given().
ProjectSpec(AppProjectSpec{
SourceRepos: []string{"*"},
Destinations: []ApplicationDestination{{Namespace: "*", Server: "*"}},
OrphanedResources: nil,
}).
When().
Refresh(RefreshTypeNormal).
Then().
Expect(SyncStatusIs(SyncStatusCodeSynced)).
Expect(NoConditions())
}
func TestNotPermittedResources(t *testing.T) {
ctx := Given(t)
ingress := &networkingv1beta.Ingress{
ObjectMeta: metav1.ObjectMeta{
Name: "sample-ingress",
Labels: map[string]string{
common.LabelKeyAppInstance: ctx.GetName(),
},
},
Spec: networkingv1beta.IngressSpec{
Rules: []networkingv1beta.IngressRule{{
IngressRuleValue: networkingv1beta.IngressRuleValue{
HTTP: &networkingv1beta.HTTPIngressRuleValue{
Paths: []networkingv1beta.HTTPIngressPath{{
Path: "/",
Backend: networkingv1beta.IngressBackend{
ServiceName: "guestbook-ui",
ServicePort: intstr.IntOrString{Type: intstr.Int, IntVal: 80},
},
}},
},
},
}},
},
}
defer func() {
log.Infof("Ingress 'sample-ingress' deleted from %s", ArgoCDNamespace)
CheckError(KubeClientset.NetworkingV1beta1().Ingresses(ArgoCDNamespace).Delete("sample-ingress", &metav1.DeleteOptions{}))
}()
svc := &v1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: "guestbook-ui",
Labels: map[string]string{
common.LabelKeyAppInstance: ctx.GetName(),
},
},
Spec: v1.ServiceSpec{
Ports: []v1.ServicePort{{
Port: 80,
TargetPort: intstr.IntOrString{Type: intstr.Int, IntVal: 80},
}},
Selector: map[string]string{
"app": "guestbook-ui",
},
},
}
ctx.ProjectSpec(AppProjectSpec{
SourceRepos: []string{"*"},
Destinations: []ApplicationDestination{{Namespace: DeploymentNamespace(), Server: "*"}},
NamespaceResourceBlacklist: []metav1.GroupKind{
{Group: "", Kind: "Service"},
}}).
And(func() {
FailOnErr(KubeClientset.NetworkingV1beta1().Ingresses(ArgoCDNamespace).Create(ingress))
FailOnErr(KubeClientset.CoreV1().Services(DeploymentNamespace()).Create(svc))
}).
Path(guestbookPath).
When().
Create().
Then().
Expect(SyncStatusIs(SyncStatusCodeOutOfSync)).
And(func(app *Application) {
statusByKind := make(map[string]ResourceStatus)
for _, res := range app.Status.Resources {
statusByKind[res.Kind] = res
}
_, hasIngress := statusByKind[kube.IngressKind]
assert.False(t, hasIngress, "Ingress is prohibited not managed object and should be even visible to user")
serviceStatus := statusByKind[kube.ServiceKind]
assert.Equal(t, serviceStatus.Status, SyncStatusCodeUnknown, "Service is prohibited managed resource so should be set to Unknown")
deploymentStatus := statusByKind[kube.DeploymentKind]
assert.Equal(t, deploymentStatus.Status, SyncStatusCodeOutOfSync)
}).
When().
Delete(true).
Then().
Expect(DoesNotExist())
// Make sure prohibited resources are not deleted during application deletion
FailOnErr(KubeClientset.NetworkingV1beta1().Ingresses(ArgoCDNamespace).Get("sample-ingress", metav1.GetOptions{}))
FailOnErr(KubeClientset.CoreV1().Services(DeploymentNamespace()).Get("guestbook-ui", metav1.GetOptions{}))
}
func TestSyncWithInfos(t *testing.T) {
expectedInfo := make([]*Info, 2)
expectedInfo[0] = &Info{Name: "name1", Value: "val1"}
expectedInfo[1] = &Info{Name: "name2", Value: "val2"}
Given(t).
Path(guestbookPath).
When().
Create().
Then().
And(func(app *Application) {
_, err := RunCli("app", "sync", app.Name,
"--info", fmt.Sprintf("%s=%s", expectedInfo[0].Name, expectedInfo[0].Value),
"--info", fmt.Sprintf("%s=%s", expectedInfo[1].Name, expectedInfo[1].Value))
assert.NoError(t, err)
}).
Expect(SyncStatusIs(SyncStatusCodeSynced)).
And(func(app *Application) {
assert.ElementsMatch(t, app.Status.OperationState.Operation.Info, expectedInfo)
})
}
//Given: argocd app create does not provide --dest-namespace
// Manifest contains resource console which does not require namespace
//Expect: no app.Status.Conditions
func TestCreateAppWithNoNameSpaceForGlobalResourse(t *testing.T) {
Given(t).
Path(globalWithNoNameSpace).
When().
CreateWithNoNameSpace().
Then().
And(func(app *Application) {
time.Sleep(500 * time.Millisecond)
app, err := AppClientset.ArgoprojV1alpha1().Applications(ArgoCDNamespace).Get(app.Name, metav1.GetOptions{})
assert.NoError(t, err)
assert.Len(t, app.Status.Conditions, 0)
})
}
//Given: argocd app create does not provide --dest-namespace
// Manifest contains resource deployment, and service which requires namespace
// Deployment and service do not have namespace in manifest
//Expect: app.Status.Conditions for deployment ans service which does not have namespace in manifest
func TestCreateAppWithNoNameSpaceWhenRequired(t *testing.T) {
Given(t).
Path(guestbookPath).
When().
CreateWithNoNameSpace().
Then().
And(func(app *Application) {
var updatedApp *Application
for i := 0; i < 3; i++ {
obj, err := AppClientset.ArgoprojV1alpha1().Applications(ArgoCDNamespace).Get(app.Name, metav1.GetOptions{})
assert.NoError(t, err)
updatedApp = obj
if len(updatedApp.Status.Conditions) > 0 {
break
}
time.Sleep(500 * time.Millisecond)
}
assert.Len(t, updatedApp.Status.Conditions, 2)
assert.Equal(t, updatedApp.Status.Conditions[0].Type, ApplicationConditionInvalidSpecError)
assert.Equal(t, updatedApp.Status.Conditions[1].Type, ApplicationConditionInvalidSpecError)
})
}
//Given: argocd app create does not provide --dest-namespace
// Manifest contains resource deployment, and service which requires namespace
// Some deployment and service has namespace in manifest
// Some deployment and service does not have namespace in manifest
//Expect: app.Status.Conditions for deployment and service which does not have namespace in manifest
func TestCreateAppWithNoNameSpaceWhenRequired2(t *testing.T) {
Given(t).
Path(guestbookWithNamespace).
When().
CreateWithNoNameSpace().
Then().
And(func(app *Application) {
var updatedApp *Application
for i := 0; i < 3; i++ {
obj, err := AppClientset.ArgoprojV1alpha1().Applications(ArgoCDNamespace).Get(app.Name, metav1.GetOptions{})
assert.NoError(t, err)
updatedApp = obj
if len(updatedApp.Status.Conditions) > 0 {
break
}
time.Sleep(500 * time.Millisecond)
}
assert.Len(t, updatedApp.Status.Conditions, 2)
assert.Equal(t, updatedApp.Status.Conditions[0].Type, ApplicationConditionInvalidSpecError)
assert.Equal(t, updatedApp.Status.Conditions[1].Type, ApplicationConditionInvalidSpecError)
})
}
|
[
"\"ARGOCD_E2E_K3S\""
] |
[] |
[
"ARGOCD_E2E_K3S"
] |
[]
|
["ARGOCD_E2E_K3S"]
|
go
| 1 | 0 | |
es4x/src/main/java/io/reactiverse/es4x/jul/ANSIFormatter.java
|
/*
* Copyright 2018 Red Hat, Inc.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Apache License v2.0 which accompanies this distribution.
*
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* The Apache License v2.0 is available at
* http://www.opensource.org/licenses/apache2.0.php
*
* You may elect to redistribute this code under either of these licenses.
*/
package io.reactiverse.es4x.jul;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.logging.*;
import static java.util.logging.Level.*;
public class ANSIFormatter extends Formatter {
// are ANSI colors allowed?
private static final boolean colors;
static {
if (Boolean.getBoolean("noTTY")) {
// in this case rely on the system property to DISABLE the colors.
colors = false;
} else {
String term = System.getenv("TERM");
if (term != null) {
term = term.toLowerCase();
colors =
// this is where the most common config will be on unices
term.equals("xterm-color")
// however as there are lots of terminal emulators, it seems
// safer to look up for the suffix "-256color" as it covers:
// vte, linux, tmux, screen, putty, rxvt, nsterm, ...
|| term.endsWith("-256color");
} else {
// there's no env variable (we're running either embedded (no shell)
// or on a OS that doesn't set the TERM variable (Windows maybe)
colors = false;
}
}
}
@Override
public synchronized String format(LogRecord record) {
Throwable thrown = record.getThrown();
String message = record.getMessage();
String thrownMessage = null;
String thrownTrace = null;
if (thrown != null) {
// collect the trace back to a string
try (StringWriter sw = new StringWriter()) {
PrintWriter pw = new PrintWriter(sw);
// print the thrown to String
thrown.printStackTrace(pw);
String sStackTrace = sw.toString(); // stack trace as a string
int idx = sStackTrace.indexOf("\n\tat");
if (idx != -1) {
thrownMessage = sStackTrace.substring(0, idx);
thrownTrace = sStackTrace.substring(idx);
} else {
thrownTrace = sStackTrace;
}
} catch (IOException e) {
// ignore...
}
}
StringBuilder sb = new StringBuilder();
if (colors) {
sb.append(prefix(record.getLevel()));
}
sb.append(message);
if (thrownMessage != null) {
sb.append(" caused by ");
sb.append(thrownMessage);
}
if (colors) {
sb.append(suffix(record.getLevel()));
}
if (thrownTrace != null) {
sb.append(thrownTrace);
} else {
sb.append(System.lineSeparator());
}
return sb.toString();
}
private static String prefix(Level l) {
if (SEVERE.equals(l)) {
return "\u001B[1m\u001B[31m";
}
if (WARNING.equals(l)) {
return "\u001B[1m\u001B[33m";
}
if (INFO.equals(l)) {
return "";
}
if (CONFIG.equals(l)) {
return "\u001B[1m\u001B[34m";
}
if (FINE.equals(l)) {
return "\u001B[1m\u001B[32m";
}
if (FINER.equals(l)) {
return "\u001B[1m\u001B[94m";
}
if (FINEST.equals(l)) {
return "\u001B[94m";
}
return "[" + l.getName().toUpperCase() + "] ";
}
private static String suffix(Level l) {
if (SEVERE.equals(l)) {
return "\u001B[0m";
}
if (WARNING.equals(l)) {
return "\u001B[0m";
}
if (INFO.equals(l)) {
return "";
}
if (CONFIG.equals(l)) {
return "\u001B[0m";
}
if (FINE.equals(l)) {
return "\u001B[0m";
}
if (FINER.equals(l)) {
return "\u001B[0m";
}
if (FINEST.equals(l)) {
return "\u001B[0m";
}
return "";
}
}
|
[
"\"TERM\""
] |
[] |
[
"TERM"
] |
[]
|
["TERM"]
|
java
| 1 | 0 | |
Backend/AndroidBackend/views.py
|
import json
from django.http import HttpResponse
import urllib2
# Create your views here.
def list_of_exchange_rates(request, iso_code):
data = {}
try:
jsonRequest = urllib2.urlopen("http://api.fixer.io/latest?base=" + iso_code)
content = jsonRequest.read()
tmpData = json.loads(content.decode("utf8"))
data['date'] = tmpData['date']
data['base'] = {'currency': RateConverter.get_rate_name(tmpData['base']), 'country': RateConverter.get_rate_country_name(tmpData['base'])}
mmr = tmpData['rates']
rate_recs = []
for key, value in mmr.iteritems():
rate_recs.append({'currency': RateConverter.get_rate_name(key), 'country': RateConverter.get_rate_country_name(key), 'rate': value})
data['rates'] = rate_recs
except Exception as detail:
data = {"date" : "2015-04-02",
"base" : {
"currency" : "Dollar",
"country" : "United States"
},
"rates" : [{
"currency" : "Rupiah",
"rate" : 13001.44,
"country" : "Indonesia"
}, {
"currency" : "Lev",
"rate" : 1.8059,
"country" : "Bulgaria"
}, {
"currency" : "Shekel",
"rate" : 3.9485,
"country" : "Israel"
}, {
"currency" : "Pound",
"rate" : 0.6755,
"country" : "United Kingdom"
}, {
"currency" : "Krone",
"rate" : 6.8982,
"country" : "Denmark"
}, {
"currency" : "Dollar",
"rate" : 1.2644,
"country" : "Canada"
}, {
"currency" : "Yen",
"rate" : 119.66,
"country" : "Japan"
}, {
"currency" : "Forint",
"rate" : 276.62,
"country" : "Hungary"
}, {
"currency" : "New Leu",
"rate" : 4.0783,
"country" : "Romania"
}, {
"currency" : "Ringgit",
"rate" : 3.6602,
"country" : "Malaysia"
}, {
"currency" : "Krona",
"rate" : 8.6283,
"country" : "Sweden"
}, {
"currency" : "Dollar",
"rate" : 1.3591,
"country" : "Singapore"
}, {
"currency" : "Dollar",
"rate" : 7.7524,
"country" : "Hong Kong"
}, {
"currency" : "Dollar",
"rate" : 1.3244,
"country" : "Australia"
}, {
"currency" : "Franc",
"rate" : 0.9603,
"country" : "Switzerland"
}, {
"currency" : "Won",
"rate" : 1092.62,
"country" : "Korea (South)"
}, {
"currency" : "Yuan Renminbi",
"rate" : 6.1962,
"country" : "China"
}, {
"currency" : "Lira",
"rate" : 2.5988,
"country" : "Turkey"
}, {
"currency" : "Kuna",
"rate" : 7.0455,
"country" : "Croatia"
}, {
"currency" : "Dollar",
"rate" : 1.3388,
"country" : "New Zealand"
}, {
"currency" : "Baht",
"rate" : 32.49,
"country" : "Thailand"
}, {
"currency" : "Euro",
"rate" : 0.9234,
"country" : "Euro Member"
}, {
"currency" : "Krone",
"rate" : 7.9876,
"country" : "Norway"
}, {
"currency" : "Ruble",
"rate" : 57.09,
"country" : "Russia"
}, {
"currency" : "Rupee",
"rate" : 62.182,
"country" : "India"
}, {
"currency" : "Peso",
"rate" : 15.112,
"country" : "Mexico"
}, {
"currency" : "Koruna",
"rate" : 25.457,
"country" : "Czech Republic"
}, {
"currency" : "Real",
"rate" : 3.1678,
"country" : "Brazil"
}, {
"currency" : "Zloty",
"rate" : 3.7532,
"country" : "Poland"
}, {
"currency" : "Peso",
"rate" : 44.406,
"country" : "Philippines"
}, {
"currency" : "Rand",
"rate" : 11.999,
"country" : "South Africa"
}
],
"error": "Something went wrong, You got a predefined exchange rates"}
return HttpResponse(json.dumps(data), content_type="application/json")
class CurrencyRate():
currency = ''
country = ''
def __init__(self, currency, country):
self.currency = currency
self.country = country
class RateConverter():
rates = {
'IDR': CurrencyRate('Rupiah','Indonesia'),
'BGN': CurrencyRate('Lev','Bulgaria'),
'ILS': CurrencyRate('Shekel','Israel'),
'GBP': CurrencyRate('Pound','United Kingdom'),
'DKK': CurrencyRate('Krone','Denmark'),
'CAD': CurrencyRate('Dollar','Canada'),
'JPY': CurrencyRate('Yen','Japan'),
'HUF': CurrencyRate('Forint','Hungary'),
'RON': CurrencyRate('New Leu','Romania'),
'MYR': CurrencyRate('Ringgit','Malaysia'),
'SEK': CurrencyRate('Krona','Sweden'),
'SGD': CurrencyRate('Dollar','Singapore'),
'HKD': CurrencyRate('Dollar','Hong Kong'),
'AUD': CurrencyRate('Dollar','Australia'),
'CHF': CurrencyRate('Franc','Switzerland'),
'KRW': CurrencyRate('Won','Korea (South)'),
'CNY': CurrencyRate('Yuan Renminbi','China'),
'TRY': CurrencyRate('Lira','Turkey'),
'HRK': CurrencyRate('Kuna','Croatia'),
'NZD': CurrencyRate('Dollar','New Zealand'),
'THB': CurrencyRate('Baht','Thailand'),
'EUR': CurrencyRate('Euro','Euro Member'),
'NOK': CurrencyRate('Krone','Norway'),
'RUB': CurrencyRate('Ruble','Russia'),
'INR': CurrencyRate('Rupee','India'),
'MXN': CurrencyRate('Peso','Mexico'),
'CZK': CurrencyRate('Koruna','Czech Republic'),
'BRL': CurrencyRate('Real','Brazil'),
'PLN': CurrencyRate('Zloty','Poland'),
'PHP': CurrencyRate('Peso','Philippines'),
'ZAR': CurrencyRate('Rand','South Africa'),
'USD': CurrencyRate('Dollar','United States')
};
@staticmethod
def get_rate_name(rate):
return RateConverter.rates.get(rate, CurrencyRate('','')).currency
@staticmethod
def get_rate_country_name(rate):
return RateConverter.rates.get(rate, CurrencyRate('','')).country
|
[] |
[] |
[] |
[]
|
[]
|
python
| null | null | null |
tsuru_autoscale/datasource/tests.py
|
from django.test import TestCase
from django.core.urlresolvers import reverse
from tsuru_autoscale.datasource.forms import DataSourceForm
from tsuru_autoscale.datasource import client
import httpretty
import mock
import os
class RemoveTestCase(TestCase):
@mock.patch("tsuru_autoscale.datasource.client.list")
@mock.patch("tsuru_autoscale.datasource.client.remove")
def test_remove(self, remove_mock, list_mock):
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-remove", args=["name"]))
response = self.client.delete(url)
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-list"))
self.assertRedirects(response, url)
remove_mock.assert_called_with("name", "bla")
class NewTestCase(TestCase):
def test_new(self):
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-new"))
response = self.client.get(url)
self.assertTemplateUsed(response, "datasource/new.html")
self.assertIsInstance(response.context['form'], DataSourceForm)
self.assertFalse(response.context['form'].is_bound)
def test_new_invalid_post(self):
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-new"))
response = self.client.post(url, {})
self.assertFalse(response.context['form'].is_valid())
@mock.patch("tsuru_autoscale.datasource.client.list")
@mock.patch("tsuru_autoscale.datasource.client.new")
def test_new_post(self, new_mock, list_mock):
data = {
'url': u'someurl',
'body': u'',
'headers': u'',
'name': u'name',
'method': u'GET',
}
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-new"))
response = self.client.post(url, data)
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-list"))
self.assertRedirects(response, url)
new_mock.assert_called_with(data, "bla")
class DataSourceListTest(TestCase):
@mock.patch("tsuru_autoscale.datasource.client.list")
def test_list(self, list_mock):
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-list"))
response = self.client.get(url)
self.assertTemplateUsed(response, "datasource/list.html")
self.assertIn('list', response.context)
list_mock.assert_called_with("bla")
class GetTest(TestCase):
@mock.patch("tsuru_autoscale.datasource.client.get")
def test_get(self, get_mock):
result_mock = mock.Mock()
result_mock.json.return_value = {"Name": "ble"}
get_mock.return_value = result_mock
url = "{}?TSURU_TOKEN=bla".format(reverse("datasource-get", args=["ble"]))
response = self.client.get(url)
self.assertTemplateUsed(response, "datasource/get.html")
self.assertIn('item', response.context)
get_mock.assert_called_with("ble", "bla")
class DataSourceFormTestCase(TestCase):
def test_required_fields(self):
fields = {
"url": True,
"method": True,
"name": True,
"body": False,
"headers": False,
}
form = DataSourceForm()
for field, required in fields.items():
self.assertEqual(form.fields[field].required, required)
class ClientTestCase(TestCase):
def setUp(self):
httpretty.enable()
def tearDown(self):
httpretty.disable()
httpretty.reset()
def test_new(self):
os.environ["AUTOSCALE_HOST"] = "http://autoscalehost.com"
httpretty.register_uri(
httpretty.POST,
"http://autoscalehost.com/datasource",
)
client.new({}, "token")
def test_list(self):
os.environ["AUTOSCALE_HOST"] = "http://autoscalehost.com"
httpretty.register_uri(
httpretty.GET,
"http://autoscalehost.com/datasource",
)
client.list("token")
self.assertDictEqual(httpretty.last_request().querystring, {"public": ["true"]})
def test_remove(self):
os.environ["AUTOSCALE_HOST"] = "http://autoscalehost.com"
httpretty.register_uri(
httpretty.DELETE,
"http://autoscalehost.com/datasource/name",
)
client.remove("name", "token")
def test_get(self):
os.environ["AUTOSCALE_HOST"] = "http://autoscalehost.com"
httpretty.register_uri(
httpretty.GET,
"http://autoscalehost.com/datasource/name",
"result",
)
result = client.get("name", "token")
self.assertEqual(result.text, "result")
|
[] |
[] |
[
"AUTOSCALE_HOST"
] |
[]
|
["AUTOSCALE_HOST"]
|
python
| 1 | 0 | |
code_examples/Java/skeleton_syncservice/src/main/java/no/sintef/skeleton_syncservice/SyncExample.java
|
// Important: To use this as a template for your own service, please follow the
// instructions given in the comments. The instructions are assuming you do this
// from within the Netbeans IDE.
// Change the package name to something fitting to your application
// The easiest way to do this is to do navigate in the project pane (to the left)
// syncServiceSkeleton -> Source Packages. Here you should see the current package name.
// Right click on it and choose refactor->rename.
// Also change "no.sintef" appropriately
package no.sintef.skeleton_syncservice;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.jws.WebService;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.xml.ws.Holder;
// Change the serviceName and the Java class name. The service name will be part
// of the endpoint url to your service
@WebService(serviceName = "SyncExample")
public class SyncExample {
// The namespace should match the package name in the first non-commented
// line of this file.
// If package name is a.b.c, the namespace should be "http://c.b.a/" (case sensitive)
// WFM will have an easier time recognizing your web service if this is fulfilled
private final String namespace = "http://skeleton_syncservice.sintef.no/";
// Also rename your Java project:
// Right click on the project in the left pane, choose "Properties" and rename
// group id, artifact id and name.
// Container configuration is accessed via environment variables
private final static String config_value = System.getenv("MY_CONFIG_VALUE");
// Name your service here, and add your required input and output parameters.
// Note that output parameters should be Holder objects.
@WebMethod(operationName = "basicIO")
public void basicIO(
@WebParam(name = "serviceID",
targetNamespace = namespace,
mode = WebParam.Mode.IN) String serviceID,
@WebParam(name = "sessionToken",
targetNamespace = namespace,
mode = WebParam.Mode.IN) String sessionToken,
@WebParam(name = "input1",
targetNamespace = namespace,
mode = WebParam.Mode.IN) String input1,
@WebParam(name = "input2",
targetNamespace = namespace,
mode = WebParam.Mode.IN) String input2,
@WebParam(name = "myOut",
targetNamespace = namespace,
mode = WebParam.Mode.OUT) Holder<String> myOut)
{
// Edit the input and output parameters above to fit your need, and program the method body according to your wishes.
log("basicIO was called!");
// Output parameters are set like this:
myOut.value = "Config was: " + config_value + "; input was: " + input1
+ " " + input2;
}
/*
* Utility function for less verbose logging
*/
private void log(String message) {
Logger.getLogger(this.getClass().getName()).log(Level.INFO, message);
}
/*
* Utility function for less verbose error message in log
*/
private void error(String message) {
Logger.getLogger(this.getClass().getName()).log(Level.SEVERE, message);
}
/*
* Utility function for less verbose error message in log
*/
private void error(IOException ex) {
Logger.getLogger(SyncExample.class.getName()).log(Level.SEVERE, null, ex);
}
}
|
[
"\"MY_CONFIG_VALUE\""
] |
[] |
[
"MY_CONFIG_VALUE"
] |
[]
|
["MY_CONFIG_VALUE"]
|
java
| 1 | 0 | |
python/pyspark/pandas/groupby.py
|
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""
A wrapper for GroupedData to behave similar to pandas GroupBy.
"""
from abc import ABCMeta, abstractmethod
import inspect
from collections import defaultdict, namedtuple
from distutils.version import LooseVersion
from functools import partial
from itertools import product
from typing import (
Any,
Callable,
Dict,
Generic,
Iterator,
Mapping,
List,
Optional,
Sequence,
Set,
Tuple,
Type,
Union,
cast,
TYPE_CHECKING,
)
import warnings
import pandas as pd
from pandas.api.types import is_hashable, is_list_like # type: ignore[attr-defined]
if LooseVersion(pd.__version__) >= LooseVersion("1.3.0"):
from pandas.core.common import _builtin_table # type: ignore[attr-defined]
else:
from pandas.core.base import SelectionMixin
_builtin_table = SelectionMixin._builtin_table # type: ignore[attr-defined]
from pyspark import SparkContext
from pyspark.sql import Column, DataFrame as SparkDataFrame, Window, functions as F
from pyspark.sql.types import (
BooleanType,
DataType,
NumericType,
StructField,
StructType,
StringType,
)
from pyspark import pandas as ps # For running doctests and reference resolution in PyCharm.
from pyspark.pandas._typing import Axis, FrameLike, Label, Name
from pyspark.pandas.typedef import infer_return_type, DataFrameType, ScalarType, SeriesType
from pyspark.pandas.frame import DataFrame
from pyspark.pandas.internal import (
InternalField,
InternalFrame,
HIDDEN_COLUMNS,
NATURAL_ORDER_COLUMN_NAME,
SPARK_INDEX_NAME_FORMAT,
SPARK_DEFAULT_SERIES_NAME,
SPARK_INDEX_NAME_PATTERN,
)
from pyspark.pandas.missing.groupby import (
MissingPandasLikeDataFrameGroupBy,
MissingPandasLikeSeriesGroupBy,
)
from pyspark.pandas.series import Series, first_series
from pyspark.pandas.spark import functions as SF
from pyspark.pandas.config import get_option
from pyspark.pandas.utils import (
align_diff_frames,
is_name_like_tuple,
is_name_like_value,
name_like_string,
same_anchor,
scol_for,
verify_temp_column_name,
log_advice,
)
from pyspark.pandas.spark.utils import as_nullable_spark_type, force_decimal_precision_scale
from pyspark.pandas.exceptions import DataError
if TYPE_CHECKING:
from pyspark.pandas.window import RollingGroupby, ExpandingGroupby, ExponentialMovingGroupby
# to keep it the same as pandas
NamedAgg = namedtuple("NamedAgg", ["column", "aggfunc"])
class GroupBy(Generic[FrameLike], metaclass=ABCMeta):
"""
:ivar _psdf: The parent dataframe that is used to perform the groupby
:type _psdf: DataFrame
:ivar _groupkeys: The list of keys that will be used to perform the grouping
:type _groupkeys: List[Series]
"""
def __init__(
self,
psdf: DataFrame,
groupkeys: List[Series],
as_index: bool,
dropna: bool,
column_labels_to_exclude: Set[Label],
agg_columns_selected: bool,
agg_columns: List[Series],
):
self._psdf = psdf
self._groupkeys = groupkeys
self._as_index = as_index
self._dropna = dropna
self._column_labels_to_exclude = column_labels_to_exclude
self._agg_columns_selected = agg_columns_selected
self._agg_columns = agg_columns
@property
def _groupkeys_scols(self) -> List[Column]:
return [s.spark.column for s in self._groupkeys]
@property
def _agg_columns_scols(self) -> List[Column]:
return [s.spark.column for s in self._agg_columns]
@abstractmethod
def _apply_series_op(
self,
op: Callable[["SeriesGroupBy"], Series],
should_resolve: bool = False,
numeric_only: bool = False,
) -> FrameLike:
pass
@abstractmethod
def _cleanup_and_return(self, psdf: DataFrame) -> FrameLike:
pass
# TODO: Series support is not implemented yet.
# TODO: not all arguments are implemented comparing to pandas' for now.
def aggregate(
self,
func_or_funcs: Optional[Union[str, List[str], Dict[Name, Union[str, List[str]]]]] = None,
*args: Any,
**kwargs: Any,
) -> DataFrame:
"""Aggregate using one or more operations over the specified axis.
Parameters
----------
func_or_funcs : dict, str or list
a dict mapping from column name (string) to
aggregate functions (string or list of strings).
Returns
-------
Series or DataFrame
The return can be:
* Series : when DataFrame.agg is called with a single function
* DataFrame : when DataFrame.agg is called with several functions
Return Series or DataFrame.
Notes
-----
`agg` is an alias for `aggregate`. Use the alias.
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'A': [1, 1, 2, 2],
... 'B': [1, 2, 3, 4],
... 'C': [0.362, 0.227, 1.267, -0.562]},
... columns=['A', 'B', 'C'])
>>> df
A B C
0 1 1 0.362
1 1 2 0.227
2 2 3 1.267
3 2 4 -0.562
Different aggregations per column
>>> aggregated = df.groupby('A').agg({'B': 'min', 'C': 'sum'})
>>> aggregated[['B', 'C']].sort_index() # doctest: +NORMALIZE_WHITESPACE
B C
A
1 1 0.589
2 3 0.705
>>> aggregated = df.groupby('A').agg({'B': ['min', 'max']})
>>> aggregated.sort_index() # doctest: +NORMALIZE_WHITESPACE
B
min max
A
1 1 2
2 3 4
>>> aggregated = df.groupby('A').agg('min')
>>> aggregated.sort_index() # doctest: +NORMALIZE_WHITESPACE
B C
A
1 1 0.227
2 3 -0.562
>>> aggregated = df.groupby('A').agg(['min', 'max'])
>>> aggregated.sort_index() # doctest: +NORMALIZE_WHITESPACE
B C
min max min max
A
1 1 2 0.227 0.362
2 3 4 -0.562 1.267
To control the output names with different aggregations per column, pandas-on-Spark
also supports 'named aggregation' or nested renaming in .agg. It can also be
used when applying multiple aggregation functions to specific columns.
>>> aggregated = df.groupby('A').agg(b_max=ps.NamedAgg(column='B', aggfunc='max'))
>>> aggregated.sort_index() # doctest: +NORMALIZE_WHITESPACE
b_max
A
1 2
2 4
>>> aggregated = df.groupby('A').agg(b_max=('B', 'max'), b_min=('B', 'min'))
>>> aggregated.sort_index() # doctest: +NORMALIZE_WHITESPACE
b_max b_min
A
1 2 1
2 4 3
>>> aggregated = df.groupby('A').agg(b_max=('B', 'max'), c_min=('C', 'min'))
>>> aggregated.sort_index() # doctest: +NORMALIZE_WHITESPACE
b_max c_min
A
1 2 0.227
2 4 -0.562
"""
# I think current implementation of func and arguments in pandas-on-Spark for aggregate
# is different than pandas, later once arguments are added, this could be removed.
if func_or_funcs is None and kwargs is None:
raise ValueError("No aggregation argument or function specified.")
relabeling = func_or_funcs is None and is_multi_agg_with_relabel(**kwargs)
if relabeling:
(
func_or_funcs,
columns,
order,
) = normalize_keyword_aggregation( # type: ignore[assignment]
kwargs
)
if not isinstance(func_or_funcs, (str, list)):
if not isinstance(func_or_funcs, dict) or not all(
is_name_like_value(key)
and (
isinstance(value, str)
or isinstance(value, list)
and all(isinstance(v, str) for v in value)
)
for key, value in func_or_funcs.items()
):
raise ValueError(
"aggs must be a dict mapping from column name "
"to aggregate functions (string or list of strings)."
)
else:
agg_cols = [col.name for col in self._agg_columns]
func_or_funcs = {col: func_or_funcs for col in agg_cols}
psdf: DataFrame = DataFrame(
GroupBy._spark_groupby(self._psdf, func_or_funcs, self._groupkeys)
)
if self._dropna:
psdf = DataFrame(
psdf._internal.with_new_sdf(
psdf._internal.spark_frame.dropna(
subset=psdf._internal.index_spark_column_names
)
)
)
if not self._as_index:
should_drop_index = set(
i for i, gkey in enumerate(self._groupkeys) if gkey._psdf is not self._psdf
)
if len(should_drop_index) > 0:
psdf = psdf.reset_index(level=should_drop_index, drop=True)
if len(should_drop_index) < len(self._groupkeys):
psdf = psdf.reset_index()
if relabeling:
psdf = psdf[order]
psdf.columns = columns # type: ignore[assignment]
return psdf
agg = aggregate
@staticmethod
def _spark_groupby(
psdf: DataFrame,
func: Mapping[Name, Union[str, List[str]]],
groupkeys: Sequence[Series] = (),
) -> InternalFrame:
groupkey_names = [SPARK_INDEX_NAME_FORMAT(i) for i in range(len(groupkeys))]
groupkey_scols = [s.spark.column.alias(name) for s, name in zip(groupkeys, groupkey_names)]
multi_aggs = any(isinstance(v, list) for v in func.values())
reordered = []
data_columns = []
column_labels = []
for key, value in func.items():
label = key if is_name_like_tuple(key) else (key,)
if len(label) != psdf._internal.column_labels_level:
raise TypeError("The length of the key must be the same as the column label level.")
for aggfunc in [value] if isinstance(value, str) else value:
column_label = tuple(list(label) + [aggfunc]) if multi_aggs else label
column_labels.append(column_label)
data_col = name_like_string(column_label)
data_columns.append(data_col)
col_name = psdf._internal.spark_column_name_for(label)
if aggfunc == "nunique":
reordered.append(
F.expr("count(DISTINCT `{0}`) as `{1}`".format(col_name, data_col))
)
# Implement "quartiles" aggregate function for ``describe``.
elif aggfunc == "quartiles":
reordered.append(
F.expr(
"percentile_approx(`{0}`, array(0.25, 0.5, 0.75)) as `{1}`".format(
col_name, data_col
)
)
)
else:
reordered.append(
F.expr("{1}(`{0}`) as `{2}`".format(col_name, aggfunc, data_col))
)
sdf = psdf._internal.spark_frame.select(groupkey_scols + psdf._internal.data_spark_columns)
sdf = sdf.groupby(*groupkey_names).agg(*reordered)
return InternalFrame(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in groupkey_names],
index_names=[psser._column_label for psser in groupkeys],
index_fields=[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(groupkeys, groupkey_names)
],
column_labels=column_labels,
data_spark_columns=[scol_for(sdf, col) for col in data_columns],
)
def count(self) -> FrameLike:
"""
Compute count of group, excluding missing values.
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'A': [1, 1, 2, 1, 2],
... 'B': [np.nan, 2, 3, 4, 5],
... 'C': [1, 2, 1, 1, 2]}, columns=['A', 'B', 'C'])
>>> df.groupby('A').count().sort_index() # doctest: +NORMALIZE_WHITESPACE
B C
A
1 2 3
2 2 2
"""
return self._reduce_for_stat_function(F.count)
# TODO: We should fix See Also when Series implementation is finished.
def first(self, numeric_only: Optional[bool] = False) -> FrameLike:
"""
Compute first of group values.
Parameters
----------
numeric_only : bool, default False
Include only float, int, boolean columns. If None, will attempt to use
everything, then use only numeric data.
.. versionadded:: 3.4.0
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 2], "B": [True, False, False, True],
... "C": [3, 3, 4, 4], "D": ["a", "b", "b", "a"]})
>>> df
A B C D
0 1 True 3 a
1 2 False 3 b
2 1 False 4 b
3 2 True 4 a
>>> df.groupby("A").first().sort_index()
B C D
A
1 True 3 a
2 False 3 b
Include only float, int, boolean columns when set numeric_only True.
>>> df.groupby("A").first(numeric_only=True).sort_index()
B C
A
1 True 3
2 False 3
"""
return self._reduce_for_stat_function(
F.first, accepted_spark_types=(NumericType, BooleanType) if numeric_only else None
)
def last(self, numeric_only: Optional[bool] = False) -> FrameLike:
"""
Compute last of group values.
Parameters
----------
numeric_only : bool, default False
Include only float, int, boolean columns. If None, will attempt to use
everything, then use only numeric data.
.. versionadded:: 3.4.0
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 2], "B": [True, False, False, True],
... "C": [3, 3, 4, 4], "D": ["a", "b", "b", "a"]})
>>> df
A B C D
0 1 True 3 a
1 2 False 3 b
2 1 False 4 b
3 2 True 4 a
>>> df.groupby("A").last().sort_index()
B C D
A
1 False 4 b
2 True 4 a
Include only float, int, boolean columns when set numeric_only True.
>>> df.groupby("A").last(numeric_only=True).sort_index()
B C
A
1 False 4
2 True 4
"""
return self._reduce_for_stat_function(
lambda col: F.last(col, ignorenulls=True),
accepted_spark_types=(NumericType, BooleanType) if numeric_only else None,
)
def max(self, numeric_only: Optional[bool] = False) -> FrameLike:
"""
Compute max of group values.
Parameters
----------
numeric_only : bool, default False
Include only float, int, boolean columns. If None, will attempt to use
everything, then use only numeric data.
.. versionadded:: 3.4.0
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 2], "B": [True, False, False, True],
... "C": [3, 4, 3, 4], "D": ["a", "b", "b", "a"]})
>>> df.groupby("A").max().sort_index()
B C D
A
1 True 3 b
2 True 4 b
Include only float, int, boolean columns when set numeric_only True.
>>> df.groupby("A").max(numeric_only=True).sort_index()
B C
A
1 True 3
2 True 4
"""
return self._reduce_for_stat_function(
F.max, accepted_spark_types=(NumericType, BooleanType) if numeric_only else None
)
def mean(self, numeric_only: Optional[bool] = True) -> FrameLike:
"""
Compute mean of groups, excluding missing values.
Parameters
----------
numeric_only : bool, default False
Include only float, int, boolean columns. If None, will attempt to use
everything, then use only numeric data.
.. versionadded:: 3.4.0
Returns
-------
pyspark.pandas.Series or pyspark.pandas.DataFrame
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'A': [1, 1, 2, 1, 2],
... 'B': [np.nan, 2, 3, 4, 5],
... 'C': [1, 2, 1, 1, 2],
... 'D': [True, False, True, False, True]})
Groupby one column and return the mean of the remaining columns in
each group.
>>> df.groupby('A').mean().sort_index() # doctest: +NORMALIZE_WHITESPACE
B C D
A
1 3.0 1.333333 0.333333
2 4.0 1.500000 1.000000
"""
self._validate_agg_columns(numeric_only=numeric_only, function_name="median")
return self._reduce_for_stat_function(
F.mean, accepted_spark_types=(NumericType,), bool_to_numeric=True
)
def min(self, numeric_only: Optional[bool] = False) -> FrameLike:
"""
Compute min of group values.
Parameters
----------
numeric_only : bool, default False
Include only float, int, boolean columns. If None, will attempt to use
everything, then use only numeric data.
.. versionadded:: 3.4.0
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 2], "B": [True, False, False, True],
... "C": [3, 4, 3, 4], "D": ["a", "b", "b", "a"]})
>>> df.groupby("A").min().sort_index()
B C D
A
1 False 3 a
2 False 4 a
Include only float, int, boolean columns when set numeric_only True.
>>> df.groupby("A").min(numeric_only=True).sort_index()
B C
A
1 False 3
2 False 4
"""
return self._reduce_for_stat_function(
F.min, accepted_spark_types=(NumericType, BooleanType) if numeric_only else None
)
# TODO: sync the doc.
def std(self, ddof: int = 1) -> FrameLike:
"""
Compute standard deviation of groups, excluding missing values.
Parameters
----------
ddof : int, default 1
Delta Degrees of Freedom. The divisor used in calculations is N - ddof,
where N represents the number of elements.
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 2], "B": [True, False, False, True],
... "C": [3, 4, 3, 4], "D": ["a", "b", "b", "a"]})
>>> df.groupby("A").std()
B C
A
1 0.707107 0.0
2 0.707107 0.0
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
"""
assert ddof in (0, 1)
# Raise the TypeError when all aggregation columns are of unaccepted data types
all_unaccepted = True
for _agg_col in self._agg_columns:
if isinstance(_agg_col.spark.data_type, (NumericType, BooleanType)):
all_unaccepted = False
break
if all_unaccepted:
raise TypeError(
"Unaccepted data types of aggregation columns; numeric or bool expected."
)
return self._reduce_for_stat_function(
F.stddev_pop if ddof == 0 else F.stddev_samp,
accepted_spark_types=(NumericType,),
bool_to_numeric=True,
)
def sum(self) -> FrameLike:
"""
Compute sum of group values
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 2], "B": [True, False, False, True],
... "C": [3, 4, 3, 4], "D": ["a", "b", "b", "a"]})
>>> df.groupby("A").sum()
B C
A
1 1 6
2 1 8
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
"""
return self._reduce_for_stat_function(
F.sum, accepted_spark_types=(NumericType,), bool_to_numeric=True
)
# TODO: sync the doc.
def var(self, ddof: int = 1) -> FrameLike:
"""
Compute variance of groups, excluding missing values.
Parameters
----------
ddof : int, default 1
Delta Degrees of Freedom. The divisor used in calculations is N - ddof,
where N represents the number of elements.
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 2], "B": [True, False, False, True],
... "C": [3, 4, 3, 4], "D": ["a", "b", "b", "a"]})
>>> df.groupby("A").var()
B C
A
1 0.5 0.0
2 0.5 0.0
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
"""
assert ddof in (0, 1)
return self._reduce_for_stat_function(
F.var_pop if ddof == 0 else F.var_samp,
accepted_spark_types=(NumericType,),
bool_to_numeric=True,
)
def skew(self) -> FrameLike:
"""
Compute skewness of groups, excluding missing values.
.. versionadded:: 3.4.0
Examples
--------
>>> df = ps.DataFrame({"A": [1, 2, 1, 1], "B": [True, False, False, True],
... "C": [3, 4, 3, 4], "D": ["a", "b", "b", "a"]})
>>> df.groupby("A").skew()
B C
A
1 -1.732051 1.732051
2 NaN NaN
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
"""
def skew(scol: Column) -> Column:
sql_utils = SparkContext._active_spark_context._jvm.PythonSQLUtils
return Column(sql_utils.pandasSkewness(scol._jc))
return self._reduce_for_stat_function(
skew,
accepted_spark_types=(NumericType,),
bool_to_numeric=True,
)
# TODO: skipna should be implemented.
def all(self) -> FrameLike:
"""
Returns True if all values in the group are truthful, else False.
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'A': [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
... 'B': [True, True, True, False, False,
... False, None, True, None, False]},
... columns=['A', 'B'])
>>> df
A B
0 1 True
1 1 True
2 2 True
3 2 False
4 3 False
5 3 False
6 4 None
7 4 True
8 5 None
9 5 False
>>> df.groupby('A').all().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
1 True
2 False
3 False
4 True
5 False
"""
return self._reduce_for_stat_function(
lambda col: F.min(F.coalesce(col.cast("boolean"), SF.lit(True)))
)
# TODO: skipna should be implemented.
def any(self) -> FrameLike:
"""
Returns True if any value in the group is truthful, else False.
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'A': [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
... 'B': [True, True, True, False, False,
... False, None, True, None, False]},
... columns=['A', 'B'])
>>> df
A B
0 1 True
1 1 True
2 2 True
3 2 False
4 3 False
5 3 False
6 4 None
7 4 True
8 5 None
9 5 False
>>> df.groupby('A').any().sort_index() # doctest: +NORMALIZE_WHITESPACE
B
A
1 True
2 True
3 False
4 True
5 False
"""
return self._reduce_for_stat_function(
lambda col: F.max(F.coalesce(col.cast("boolean"), SF.lit(False)))
)
# TODO: groupby multiply columns should be implemented.
def size(self) -> Series:
"""
Compute group sizes.
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'A': [1, 2, 2, 3, 3, 3],
... 'B': [1, 1, 2, 3, 3, 3]},
... columns=['A', 'B'])
>>> df
A B
0 1 1
1 2 1
2 2 2
3 3 3
4 3 3
5 3 3
>>> df.groupby('A').size().sort_index()
A
1 1
2 2
3 3
dtype: int64
>>> df.groupby(['A', 'B']).size().sort_index()
A B
1 1 1
2 1 1
2 1
3 3 3
dtype: int64
For Series,
>>> df.B.groupby(df.A).size().sort_index()
A
1 1
2 2
3 3
Name: B, dtype: int64
>>> df.groupby(df.A).B.size().sort_index()
A
1 1
2 2
3 3
Name: B, dtype: int64
"""
groupkeys = self._groupkeys
groupkey_names = [SPARK_INDEX_NAME_FORMAT(i) for i in range(len(groupkeys))]
groupkey_scols = [s.spark.column.alias(name) for s, name in zip(groupkeys, groupkey_names)]
sdf = self._psdf._internal.spark_frame.select(
groupkey_scols + self._psdf._internal.data_spark_columns
)
sdf = sdf.groupby(*groupkey_names).count()
internal = InternalFrame(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in groupkey_names],
index_names=[psser._column_label for psser in groupkeys],
index_fields=[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(groupkeys, groupkey_names)
],
column_labels=[None],
data_spark_columns=[scol_for(sdf, "count")],
)
return first_series(DataFrame(internal))
def diff(self, periods: int = 1) -> FrameLike:
"""
First discrete difference of element.
Calculates the difference of a DataFrame element compared with another element in the
DataFrame group (default is the element in the same column of the previous row).
Parameters
----------
periods : int, default 1
Periods to shift for calculating difference, accepts negative values.
Returns
-------
diffed : DataFrame or Series
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'a': [1, 2, 3, 4, 5, 6],
... 'b': [1, 1, 2, 3, 5, 8],
... 'c': [1, 4, 9, 16, 25, 36]}, columns=['a', 'b', 'c'])
>>> df
a b c
0 1 1 1
1 2 1 4
2 3 2 9
3 4 3 16
4 5 5 25
5 6 8 36
>>> df.groupby(['b']).diff().sort_index()
a c
0 NaN NaN
1 1.0 3.0
2 NaN NaN
3 NaN NaN
4 NaN NaN
5 NaN NaN
Difference with previous column in a group.
>>> df.groupby(['b'])['a'].diff().sort_index()
0 NaN
1 1.0
2 NaN
3 NaN
4 NaN
5 NaN
Name: a, dtype: float64
"""
return self._apply_series_op(
lambda sg: sg._psser._diff(periods, part_cols=sg._groupkeys_scols), should_resolve=True
)
def cumcount(self, ascending: bool = True) -> Series:
"""
Number each item in each group from 0 to the length of that group - 1.
Essentially this is equivalent to
.. code-block:: python
self.apply(lambda x: pd.Series(np.arange(len(x)), x.index))
Parameters
----------
ascending : bool, default True
If False, number in reverse, from length of group - 1 to 0.
Returns
-------
Series
Sequence number of each element within each group.
Examples
--------
>>> df = ps.DataFrame([['a'], ['a'], ['a'], ['b'], ['b'], ['a']],
... columns=['A'])
>>> df
A
0 a
1 a
2 a
3 b
4 b
5 a
>>> df.groupby('A').cumcount().sort_index()
0 0
1 1
2 2
3 0
4 1
5 3
dtype: int64
>>> df.groupby('A').cumcount(ascending=False).sort_index()
0 3
1 2
2 1
3 1
4 0
5 0
dtype: int64
"""
ret = (
self._groupkeys[0]
.rename()
.spark.transform(lambda _: SF.lit(0))
._cum(F.count, True, part_cols=self._groupkeys_scols, ascending=ascending)
- 1
)
internal = ret._internal.resolved_copy
return first_series(DataFrame(internal))
def cummax(self) -> FrameLike:
"""
Cumulative max for each group.
Returns
-------
Series or DataFrame
See Also
--------
Series.cummax
DataFrame.cummax
Examples
--------
>>> df = ps.DataFrame(
... [[1, None, 4], [1, 0.1, 3], [1, 20.0, 2], [4, 10.0, 1]],
... columns=list('ABC'))
>>> df
A B C
0 1 NaN 4
1 1 0.1 3
2 1 20.0 2
3 4 10.0 1
By default, iterates over rows and finds the sum in each column.
>>> df.groupby("A").cummax().sort_index()
B C
0 NaN 4
1 0.1 4
2 20.0 4
3 10.0 1
It works as below in Series.
>>> df.C.groupby(df.A).cummax().sort_index()
0 4
1 4
2 4
3 1
Name: C, dtype: int64
"""
return self._apply_series_op(
lambda sg: sg._psser._cum(F.max, True, part_cols=sg._groupkeys_scols),
should_resolve=True,
numeric_only=True,
)
def cummin(self) -> FrameLike:
"""
Cumulative min for each group.
Returns
-------
Series or DataFrame
See Also
--------
Series.cummin
DataFrame.cummin
Examples
--------
>>> df = ps.DataFrame(
... [[1, None, 4], [1, 0.1, 3], [1, 20.0, 2], [4, 10.0, 1]],
... columns=list('ABC'))
>>> df
A B C
0 1 NaN 4
1 1 0.1 3
2 1 20.0 2
3 4 10.0 1
By default, iterates over rows and finds the sum in each column.
>>> df.groupby("A").cummin().sort_index()
B C
0 NaN 4
1 0.1 3
2 0.1 2
3 10.0 1
It works as below in Series.
>>> df.B.groupby(df.A).cummin().sort_index()
0 NaN
1 0.1
2 0.1
3 10.0
Name: B, dtype: float64
"""
return self._apply_series_op(
lambda sg: sg._psser._cum(F.min, True, part_cols=sg._groupkeys_scols),
should_resolve=True,
numeric_only=True,
)
def cumprod(self) -> FrameLike:
"""
Cumulative product for each group.
Returns
-------
Series or DataFrame
See Also
--------
Series.cumprod
DataFrame.cumprod
Examples
--------
>>> df = ps.DataFrame(
... [[1, None, 4], [1, 0.1, 3], [1, 20.0, 2], [4, 10.0, 1]],
... columns=list('ABC'))
>>> df
A B C
0 1 NaN 4
1 1 0.1 3
2 1 20.0 2
3 4 10.0 1
By default, iterates over rows and finds the sum in each column.
>>> df.groupby("A").cumprod().sort_index()
B C
0 NaN 4
1 0.1 12
2 2.0 24
3 10.0 1
It works as below in Series.
>>> df.B.groupby(df.A).cumprod().sort_index()
0 NaN
1 0.1
2 2.0
3 10.0
Name: B, dtype: float64
"""
return self._apply_series_op(
lambda sg: sg._psser._cumprod(True, part_cols=sg._groupkeys_scols),
should_resolve=True,
numeric_only=True,
)
def cumsum(self) -> FrameLike:
"""
Cumulative sum for each group.
Returns
-------
Series or DataFrame
See Also
--------
Series.cumsum
DataFrame.cumsum
Examples
--------
>>> df = ps.DataFrame(
... [[1, None, 4], [1, 0.1, 3], [1, 20.0, 2], [4, 10.0, 1]],
... columns=list('ABC'))
>>> df
A B C
0 1 NaN 4
1 1 0.1 3
2 1 20.0 2
3 4 10.0 1
By default, iterates over rows and finds the sum in each column.
>>> df.groupby("A").cumsum().sort_index()
B C
0 NaN 4
1 0.1 7
2 20.1 9
3 10.0 1
It works as below in Series.
>>> df.B.groupby(df.A).cumsum().sort_index()
0 NaN
1 0.1
2 20.1
3 10.0
Name: B, dtype: float64
"""
return self._apply_series_op(
lambda sg: sg._psser._cumsum(True, part_cols=sg._groupkeys_scols),
should_resolve=True,
numeric_only=True,
)
def apply(self, func: Callable, *args: Any, **kwargs: Any) -> Union[DataFrame, Series]:
"""
Apply function `func` group-wise and combine the results together.
The function passed to `apply` must take a DataFrame as its first
argument and return a DataFrame. `apply` will
then take care of combining the results back together into a single
dataframe. `apply` is therefore a highly flexible
grouping method.
While `apply` is a very flexible method, its downside is that
using it can be quite a bit slower than using more specific methods
like `agg` or `transform`. pandas-on-Spark offers a wide range of method that will
be much faster than using `apply` for their specific purposes, so try to
use them before reaching for `apply`.
.. note:: this API executes the function once to infer the type which is
potentially expensive, for instance, when the dataset is created after
aggregations or sorting.
To avoid this, specify return type in ``func``, for instance, as below:
>>> def pandas_div(x) -> ps.DataFrame[int, [float, float]]:
... return x[['B', 'C']] / x[['B', 'C']]
If the return type is specified, the output column names become
`c0, c1, c2 ... cn`. These names are positionally mapped to the returned
DataFrame in ``func``.
To specify the column names, you can assign them in a NumPy compound type style
as below:
>>> def pandas_div(x) -> ps.DataFrame[("index", int), [("a", float), ("b", float)]]:
... return x[['B', 'C']] / x[['B', 'C']]
>>> pdf = pd.DataFrame({'B': [1.], 'C': [3.]})
>>> def plus_one(x) -> ps.DataFrame[
... (pdf.index.name, pdf.index.dtype), zip(pdf.columns, pdf.dtypes)]:
... return x[['B', 'C']] / x[['B', 'C']]
.. note:: the dataframe within ``func`` is actually a pandas dataframe. Therefore,
any pandas API within this function is allowed.
Parameters
----------
func : callable
A callable that takes a DataFrame as its first argument, and
returns a dataframe.
*args
Positional arguments to pass to func.
**kwargs
Keyword arguments to pass to func.
Returns
-------
applied : DataFrame or Series
See Also
--------
aggregate : Apply aggregate function to the GroupBy object.
DataFrame.apply : Apply a function to a DataFrame.
Series.apply : Apply a function to a Series.
Examples
--------
>>> df = ps.DataFrame({'A': 'a a b'.split(),
... 'B': [1, 2, 3],
... 'C': [4, 6, 5]}, columns=['A', 'B', 'C'])
>>> g = df.groupby('A')
Notice that ``g`` has two groups, ``a`` and ``b``.
Calling `apply` in various ways, we can get different grouping results:
Below the functions passed to `apply` takes a DataFrame as
its argument and returns a DataFrame. `apply` combines the result for
each group together into a new DataFrame:
>>> def plus_min(x):
... return x + x.min()
>>> g.apply(plus_min).sort_index() # doctest: +NORMALIZE_WHITESPACE
A B C
0 aa 2 8
1 aa 3 10
2 bb 6 10
>>> g.apply(sum).sort_index() # doctest: +NORMALIZE_WHITESPACE
A B C
A
a aa 3 10
b b 3 5
>>> g.apply(len).sort_index() # doctest: +NORMALIZE_WHITESPACE
A
a 2
b 1
dtype: int64
You can specify the type hint and prevent schema inference for better performance.
>>> def pandas_div(x) -> ps.DataFrame[int, [float, float]]:
... return x[['B', 'C']] / x[['B', 'C']]
>>> g.apply(pandas_div).sort_index() # doctest: +NORMALIZE_WHITESPACE
c0 c1
0 1.0 1.0
1 1.0 1.0
2 1.0 1.0
>>> def pandas_div(x) -> ps.DataFrame[("index", int), [("f1", float), ("f2", float)]]:
... return x[['B', 'C']] / x[['B', 'C']]
>>> g.apply(pandas_div).sort_index() # doctest: +NORMALIZE_WHITESPACE
f1 f2
index
0 1.0 1.0
1 1.0 1.0
2 1.0 1.0
In case of Series, it works as below.
>>> def plus_max(x) -> ps.Series[np.int]:
... return x + x.max()
>>> df.B.groupby(df.A).apply(plus_max).sort_index() # doctest: +SKIP
0 6
1 3
2 4
Name: B, dtype: int64
>>> def plus_min(x):
... return x + x.min()
>>> df.B.groupby(df.A).apply(plus_min).sort_index()
0 2
1 3
2 6
Name: B, dtype: int64
You can also return a scalar value as a aggregated value of the group:
>>> def plus_length(x) -> np.int:
... return len(x)
>>> df.B.groupby(df.A).apply(plus_length).sort_index() # doctest: +SKIP
0 1
1 2
Name: B, dtype: int64
The extra arguments to the function can be passed as below.
>>> def calculation(x, y, z) -> np.int:
... return len(x) + y * z
>>> df.B.groupby(df.A).apply(calculation, 5, z=10).sort_index() # doctest: +SKIP
0 51
1 52
Name: B, dtype: int64
"""
if not callable(func):
raise TypeError("%s object is not callable" % type(func).__name__)
spec = inspect.getfullargspec(func)
return_sig = spec.annotations.get("return", None)
should_infer_schema = return_sig is None
should_retain_index = should_infer_schema
is_series_groupby = isinstance(self, SeriesGroupBy)
psdf = self._psdf
if self._agg_columns_selected:
agg_columns = self._agg_columns
else:
agg_columns = [
psdf._psser_for(label)
for label in psdf._internal.column_labels
if label not in self._column_labels_to_exclude
]
psdf, groupkey_labels, groupkey_names = GroupBy._prepare_group_map_apply(
psdf, self._groupkeys, agg_columns
)
if is_series_groupby:
name = psdf.columns[-1]
pandas_apply = _builtin_table.get(func, func)
else:
f = _builtin_table.get(func, func)
def pandas_apply(pdf: pd.DataFrame, *a: Any, **k: Any) -> Any:
return f(pdf.drop(groupkey_names, axis=1), *a, **k)
should_return_series = False
if should_infer_schema:
# Here we execute with the first 1000 to get the return type.
log_advice(
"If the type hints is not specified for `grouby.apply`, "
"it is expensive to infer the data type internally."
)
limit = get_option("compute.shortcut_limit")
# Ensure sampling rows >= 2 to make sure apply's infer schema is accurate
# See related: https://github.com/pandas-dev/pandas/issues/46893
sample_limit = limit + 1 if limit else 2
pdf = psdf.head(sample_limit)._to_internal_pandas()
groupkeys = [
pdf[groupkey_name].rename(psser.name)
for groupkey_name, psser in zip(groupkey_names, self._groupkeys)
]
grouped = pdf.groupby(groupkeys)
if is_series_groupby:
pser_or_pdf = grouped[name].apply(pandas_apply, *args, **kwargs)
else:
pser_or_pdf = grouped.apply(pandas_apply, *args, **kwargs)
psser_or_psdf = ps.from_pandas(pser_or_pdf)
if len(pdf) <= limit:
if isinstance(psser_or_psdf, ps.Series) and is_series_groupby:
psser_or_psdf = psser_or_psdf.rename(cast(SeriesGroupBy, self)._psser.name)
return cast(Union[Series, DataFrame], psser_or_psdf)
if len(grouped) <= 1:
with warnings.catch_warnings():
warnings.simplefilter("always")
warnings.warn(
"The amount of data for return type inference might not be large enough. "
"Consider increasing an option `compute.shortcut_limit`."
)
if isinstance(psser_or_psdf, Series):
should_return_series = True
psdf_from_pandas = psser_or_psdf._psdf
else:
psdf_from_pandas = cast(DataFrame, psser_or_psdf)
index_fields = [
field.normalize_spark_type() for field in psdf_from_pandas._internal.index_fields
]
data_fields = [
field.normalize_spark_type() for field in psdf_from_pandas._internal.data_fields
]
return_schema = StructType([field.struct_field for field in index_fields + data_fields])
else:
return_type = infer_return_type(func)
if not is_series_groupby and isinstance(return_type, SeriesType):
raise TypeError(
"Series as a return type hint at frame groupby is not supported "
"currently; however got [%s]. Use DataFrame type hint instead." % return_sig
)
if isinstance(return_type, DataFrameType):
data_fields = return_type.data_fields
return_schema = return_type.spark_type
index_fields = return_type.index_fields
should_retain_index = len(index_fields) > 0
psdf_from_pandas = None
else:
should_return_series = True
dtype = cast(Union[SeriesType, ScalarType], return_type).dtype
spark_type = cast(Union[SeriesType, ScalarType], return_type).spark_type
if is_series_groupby:
data_fields = [
InternalField(
dtype=dtype, struct_field=StructField(name=name, dataType=spark_type)
)
]
else:
data_fields = [
InternalField(
dtype=dtype,
struct_field=StructField(
name=SPARK_DEFAULT_SERIES_NAME, dataType=spark_type
),
)
]
return_schema = StructType([field.struct_field for field in data_fields])
def pandas_groupby_apply(pdf: pd.DataFrame) -> pd.DataFrame:
if is_series_groupby:
pdf_or_ser = pdf.groupby(groupkey_names)[name].apply(pandas_apply, *args, **kwargs)
else:
pdf_or_ser = pdf.groupby(groupkey_names).apply(pandas_apply, *args, **kwargs)
if should_return_series and isinstance(pdf_or_ser, pd.DataFrame):
pdf_or_ser = pdf_or_ser.stack()
if not isinstance(pdf_or_ser, pd.DataFrame):
return pd.DataFrame(pdf_or_ser)
else:
return pdf_or_ser
sdf = GroupBy._spark_group_map_apply(
psdf,
pandas_groupby_apply,
[psdf._internal.spark_column_for(label) for label in groupkey_labels],
return_schema,
retain_index=should_retain_index,
)
if should_retain_index:
# If schema is inferred, we can restore indexes too.
if psdf_from_pandas is not None:
internal = psdf_from_pandas._internal.with_new_sdf(
spark_frame=sdf, index_fields=index_fields, data_fields=data_fields
)
else:
index_names: Optional[List[Optional[Tuple[Any, ...]]]] = None
index_spark_columns = [
scol_for(sdf, index_field.struct_field.name) for index_field in index_fields
]
if not any(
[
SPARK_INDEX_NAME_PATTERN.match(index_field.struct_field.name)
for index_field in index_fields
]
):
index_names = [(index_field.struct_field.name,) for index_field in index_fields]
internal = InternalFrame(
spark_frame=sdf,
index_names=index_names,
index_spark_columns=index_spark_columns,
index_fields=index_fields,
data_fields=data_fields,
)
else:
# Otherwise, it loses index.
internal = InternalFrame(
spark_frame=sdf, index_spark_columns=None, data_fields=data_fields
)
if should_return_series:
psser = first_series(DataFrame(internal))
if is_series_groupby:
psser = psser.rename(cast(SeriesGroupBy, self)._psser.name)
return psser
else:
return DataFrame(internal)
# TODO: implement 'dropna' parameter
def filter(self, func: Callable[[FrameLike], FrameLike]) -> FrameLike:
"""
Return a copy of a DataFrame excluding elements from groups that
do not satisfy the boolean criterion specified by func.
Parameters
----------
f : function
Function to apply to each subframe. Should return True or False.
dropna : Drop groups that do not pass the filter. True by default;
if False, groups that evaluate False are filled with NaNs.
Returns
-------
filtered : DataFrame or Series
Notes
-----
Each subframe is endowed the attribute 'name' in case you need to know
which group you are working on.
Examples
--------
>>> df = ps.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
... 'foo', 'bar'],
... 'B' : [1, 2, 3, 4, 5, 6],
... 'C' : [2.0, 5., 8., 1., 2., 9.]}, columns=['A', 'B', 'C'])
>>> grouped = df.groupby('A')
>>> grouped.filter(lambda x: x['B'].mean() > 3.)
A B C
1 bar 2 5.0
3 bar 4 1.0
5 bar 6 9.0
>>> df.B.groupby(df.A).filter(lambda x: x.mean() > 3.)
1 2
3 4
5 6
Name: B, dtype: int64
"""
if not callable(func):
raise TypeError("%s object is not callable" % type(func).__name__)
is_series_groupby = isinstance(self, SeriesGroupBy)
psdf = self._psdf
if self._agg_columns_selected:
agg_columns = self._agg_columns
else:
agg_columns = [
psdf._psser_for(label)
for label in psdf._internal.column_labels
if label not in self._column_labels_to_exclude
]
data_schema = (
psdf[agg_columns]._internal.resolved_copy.spark_frame.drop(*HIDDEN_COLUMNS).schema
)
psdf, groupkey_labels, groupkey_names = GroupBy._prepare_group_map_apply(
psdf, self._groupkeys, agg_columns
)
if is_series_groupby:
def pandas_filter(pdf: pd.DataFrame) -> pd.DataFrame:
return pd.DataFrame(pdf.groupby(groupkey_names)[pdf.columns[-1]].filter(func))
else:
f = _builtin_table.get(func, func)
def wrapped_func(pdf: pd.DataFrame) -> pd.DataFrame:
return f(pdf.drop(groupkey_names, axis=1))
def pandas_filter(pdf: pd.DataFrame) -> pd.DataFrame:
return pdf.groupby(groupkey_names).filter(wrapped_func).drop(groupkey_names, axis=1)
sdf = GroupBy._spark_group_map_apply(
psdf,
pandas_filter,
[psdf._internal.spark_column_for(label) for label in groupkey_labels],
data_schema,
retain_index=True,
)
psdf = DataFrame(self._psdf[agg_columns]._internal.with_new_sdf(sdf))
if is_series_groupby:
return cast(FrameLike, first_series(psdf))
else:
return cast(FrameLike, psdf)
@staticmethod
def _prepare_group_map_apply(
psdf: DataFrame, groupkeys: List[Series], agg_columns: List[Series]
) -> Tuple[DataFrame, List[Label], List[str]]:
groupkey_labels: List[Label] = [
verify_temp_column_name(psdf, "__groupkey_{}__".format(i))
for i in range(len(groupkeys))
]
psdf = psdf[[s.rename(label) for s, label in zip(groupkeys, groupkey_labels)] + agg_columns]
groupkey_names = [label if len(label) > 1 else label[0] for label in groupkey_labels]
return DataFrame(psdf._internal.resolved_copy), groupkey_labels, groupkey_names
@staticmethod
def _spark_group_map_apply(
psdf: DataFrame,
func: Callable[[pd.DataFrame], pd.DataFrame],
groupkeys_scols: List[Column],
return_schema: StructType,
retain_index: bool,
) -> SparkDataFrame:
output_func = GroupBy._make_pandas_df_builder_func(psdf, func, return_schema, retain_index)
sdf = psdf._internal.spark_frame.drop(*HIDDEN_COLUMNS)
return sdf.groupby(*groupkeys_scols).applyInPandas(output_func, return_schema)
@staticmethod
def _make_pandas_df_builder_func(
psdf: DataFrame,
func: Callable[[pd.DataFrame], pd.DataFrame],
return_schema: StructType,
retain_index: bool,
) -> Callable[[pd.DataFrame], pd.DataFrame]:
"""
Creates a function that can be used inside the pandas UDF. This function can construct
the same pandas DataFrame as if the pandas-on-Spark DataFrame is collected to driver side.
The index, column labels, etc. are re-constructed within the function.
"""
from pyspark.sql.utils import is_timestamp_ntz_preferred
arguments_for_restore_index = psdf._internal.arguments_for_restore_index
prefer_timestamp_ntz = is_timestamp_ntz_preferred()
def rename_output(pdf: pd.DataFrame) -> pd.DataFrame:
pdf = InternalFrame.restore_index(pdf.copy(), **arguments_for_restore_index)
pdf = func(pdf)
# If schema should be inferred, we don't restore index. pandas seems restoring
# the index in some cases.
# When Spark output type is specified, without executing it, we don't know
# if we should restore the index or not. For instance, see the example in
# https://github.com/pyspark.pandas/issues/628.
pdf, _, _, _, _ = InternalFrame.prepare_pandas_frame(
pdf, retain_index=retain_index, prefer_timestamp_ntz=prefer_timestamp_ntz
)
# Just positionally map the column names to given schema's.
pdf.columns = return_schema.names
return pdf
return rename_output
def rank(self, method: str = "average", ascending: bool = True) -> FrameLike:
"""
Provide the rank of values within each group.
Parameters
----------
method : {'average', 'min', 'max', 'first', 'dense'}, default 'average'
* average: average rank of group
* min: lowest rank in group
* max: highest rank in group
* first: ranks assigned in order they appear in the array
* dense: like 'min', but rank always increases by 1 between groups
ascending : boolean, default True
False for ranks by high (1) to low (N)
Returns
-------
DataFrame with ranking of values within each group
Examples
--------
>>> df = ps.DataFrame({
... 'a': [1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'b': [1, 2, 2, 2, 3, 3, 3, 4, 4]}, columns=['a', 'b'])
>>> df
a b
0 1 1
1 1 2
2 1 2
3 2 2
4 2 3
5 2 3
6 3 3
7 3 4
8 3 4
>>> df.groupby("a").rank().sort_index()
b
0 1.0
1 2.5
2 2.5
3 1.0
4 2.5
5 2.5
6 1.0
7 2.5
8 2.5
>>> df.b.groupby(df.a).rank(method='max').sort_index()
0 1.0
1 3.0
2 3.0
3 1.0
4 3.0
5 3.0
6 1.0
7 3.0
8 3.0
Name: b, dtype: float64
"""
return self._apply_series_op(
lambda sg: sg._psser._rank(method, ascending, part_cols=sg._groupkeys_scols),
should_resolve=True,
)
# TODO: add axis parameter
def idxmax(self, skipna: bool = True) -> FrameLike:
"""
Return index of first occurrence of maximum over requested axis in group.
NA/null values are excluded.
Parameters
----------
skipna : boolean, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
See Also
--------
Series.idxmax
DataFrame.idxmax
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 2, 2, 3],
... 'b': [1, 2, 3, 4, 5],
... 'c': [5, 4, 3, 2, 1]}, columns=['a', 'b', 'c'])
>>> df.groupby(['a'])['b'].idxmax().sort_index() # doctest: +NORMALIZE_WHITESPACE
a
1 1
2 3
3 4
Name: b, dtype: int64
>>> df.groupby(['a']).idxmax().sort_index() # doctest: +NORMALIZE_WHITESPACE
b c
a
1 1 0
2 3 2
3 4 4
"""
if self._psdf._internal.index_level != 1:
raise ValueError("idxmax only support one-level index now")
groupkey_names = ["__groupkey_{}__".format(i) for i in range(len(self._groupkeys))]
sdf = self._psdf._internal.spark_frame
for s, name in zip(self._groupkeys, groupkey_names):
sdf = sdf.withColumn(name, s.spark.column)
index = self._psdf._internal.index_spark_column_names[0]
stat_exprs = []
for psser, scol in zip(self._agg_columns, self._agg_columns_scols):
name = psser._internal.data_spark_column_names[0]
if skipna:
order_column = scol.desc_nulls_last()
else:
order_column = scol.desc_nulls_first()
window = Window.partitionBy(*groupkey_names).orderBy(
order_column, NATURAL_ORDER_COLUMN_NAME
)
sdf = sdf.withColumn(
name, F.when(F.row_number().over(window) == 1, scol_for(sdf, index)).otherwise(None)
)
stat_exprs.append(F.max(scol_for(sdf, name)).alias(name))
sdf = sdf.groupby(*groupkey_names).agg(*stat_exprs)
internal = InternalFrame(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in groupkey_names],
index_names=[psser._column_label for psser in self._groupkeys],
index_fields=[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(self._groupkeys, groupkey_names)
],
column_labels=[psser._column_label for psser in self._agg_columns],
data_spark_columns=[
scol_for(sdf, psser._internal.data_spark_column_names[0])
for psser in self._agg_columns
],
)
return self._cleanup_and_return(DataFrame(internal))
# TODO: add axis parameter
def idxmin(self, skipna: bool = True) -> FrameLike:
"""
Return index of first occurrence of minimum over requested axis in group.
NA/null values are excluded.
Parameters
----------
skipna : boolean, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
See Also
--------
Series.idxmin
DataFrame.idxmin
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 2, 2, 3],
... 'b': [1, 2, 3, 4, 5],
... 'c': [5, 4, 3, 2, 1]}, columns=['a', 'b', 'c'])
>>> df.groupby(['a'])['b'].idxmin().sort_index() # doctest: +NORMALIZE_WHITESPACE
a
1 0
2 2
3 4
Name: b, dtype: int64
>>> df.groupby(['a']).idxmin().sort_index() # doctest: +NORMALIZE_WHITESPACE
b c
a
1 0 1
2 2 3
3 4 4
"""
if self._psdf._internal.index_level != 1:
raise ValueError("idxmin only support one-level index now")
groupkey_names = ["__groupkey_{}__".format(i) for i in range(len(self._groupkeys))]
sdf = self._psdf._internal.spark_frame
for s, name in zip(self._groupkeys, groupkey_names):
sdf = sdf.withColumn(name, s.spark.column)
index = self._psdf._internal.index_spark_column_names[0]
stat_exprs = []
for psser, scol in zip(self._agg_columns, self._agg_columns_scols):
name = psser._internal.data_spark_column_names[0]
if skipna:
order_column = scol.asc_nulls_last()
else:
order_column = scol.asc_nulls_first()
window = Window.partitionBy(*groupkey_names).orderBy(
order_column, NATURAL_ORDER_COLUMN_NAME
)
sdf = sdf.withColumn(
name, F.when(F.row_number().over(window) == 1, scol_for(sdf, index)).otherwise(None)
)
stat_exprs.append(F.max(scol_for(sdf, name)).alias(name))
sdf = sdf.groupby(*groupkey_names).agg(*stat_exprs)
internal = InternalFrame(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in groupkey_names],
index_names=[psser._column_label for psser in self._groupkeys],
index_fields=[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(self._groupkeys, groupkey_names)
],
column_labels=[psser._column_label for psser in self._agg_columns],
data_spark_columns=[
scol_for(sdf, psser._internal.data_spark_column_names[0])
for psser in self._agg_columns
],
)
return self._cleanup_and_return(DataFrame(internal))
def fillna(
self,
value: Optional[Any] = None,
method: Optional[str] = None,
axis: Optional[Axis] = None,
inplace: bool = False,
limit: Optional[int] = None,
) -> FrameLike:
"""Fill NA/NaN values in group.
Parameters
----------
value : scalar, dict, Series
Value to use to fill holes. alternately a dict/Series of values
specifying which value to use for each column.
DataFrame is not supported.
method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
Method to use for filling holes in reindexed Series pad / ffill: propagate last valid
observation forward to next valid backfill / bfill:
use NEXT valid observation to fill gap
axis : {0 or `index`}
1 and `columns` are not supported.
inplace : boolean, default False
Fill in place (do not create a new object)
limit : int, default None
If method is specified, this is the maximum number of consecutive NaN values to
forward/backward fill. In other words, if there is a gap with more than this number of
consecutive NaNs, it will only be partially filled. If method is not specified,
this is the maximum number of entries along the entire axis where NaNs will be filled.
Must be greater than 0 if not None
Returns
-------
DataFrame
DataFrame with NA entries filled.
Examples
--------
>>> df = ps.DataFrame({
... 'A': [1, 1, 2, 2],
... 'B': [2, 4, None, 3],
... 'C': [None, None, None, 1],
... 'D': [0, 1, 5, 4]
... },
... columns=['A', 'B', 'C', 'D'])
>>> df
A B C D
0 1 2.0 NaN 0
1 1 4.0 NaN 1
2 2 NaN NaN 5
3 2 3.0 1.0 4
We can also propagate non-null values forward or backward in group.
>>> df.groupby(['A'])['B'].fillna(method='ffill').sort_index()
0 2.0
1 4.0
2 NaN
3 3.0
Name: B, dtype: float64
>>> df.groupby(['A']).fillna(method='bfill').sort_index()
B C D
0 2.0 NaN 0
1 4.0 NaN 1
2 3.0 1.0 5
3 3.0 1.0 4
"""
return self._apply_series_op(
lambda sg: sg._psser._fillna(
value=value, method=method, axis=axis, limit=limit, part_cols=sg._groupkeys_scols
),
should_resolve=(method is not None),
)
def bfill(self, limit: Optional[int] = None) -> FrameLike:
"""
Synonym for `DataFrame.fillna()` with ``method=`bfill```.
Parameters
----------
axis : {0 or `index`}
1 and `columns` are not supported.
inplace : boolean, default False
Fill in place (do not create a new object)
limit : int, default None
If method is specified, this is the maximum number of consecutive NaN values to
forward/backward fill. In other words, if there is a gap with more than this number of
consecutive NaNs, it will only be partially filled. If method is not specified,
this is the maximum number of entries along the entire axis where NaNs will be filled.
Must be greater than 0 if not None
Returns
-------
DataFrame
DataFrame with NA entries filled.
Examples
--------
>>> df = ps.DataFrame({
... 'A': [1, 1, 2, 2],
... 'B': [2, 4, None, 3],
... 'C': [None, None, None, 1],
... 'D': [0, 1, 5, 4]
... },
... columns=['A', 'B', 'C', 'D'])
>>> df
A B C D
0 1 2.0 NaN 0
1 1 4.0 NaN 1
2 2 NaN NaN 5
3 2 3.0 1.0 4
Propagate non-null values backward.
>>> df.groupby(['A']).bfill().sort_index()
B C D
0 2.0 NaN 0
1 4.0 NaN 1
2 3.0 1.0 5
3 3.0 1.0 4
"""
return self.fillna(method="bfill", limit=limit)
backfill = bfill
def ffill(self, limit: Optional[int] = None) -> FrameLike:
"""
Synonym for `DataFrame.fillna()` with ``method=`ffill```.
Parameters
----------
axis : {0 or `index`}
1 and `columns` are not supported.
inplace : boolean, default False
Fill in place (do not create a new object)
limit : int, default None
If method is specified, this is the maximum number of consecutive NaN values to
forward/backward fill. In other words, if there is a gap with more than this number of
consecutive NaNs, it will only be partially filled. If method is not specified,
this is the maximum number of entries along the entire axis where NaNs will be filled.
Must be greater than 0 if not None
Returns
-------
DataFrame
DataFrame with NA entries filled.
Examples
--------
>>> df = ps.DataFrame({
... 'A': [1, 1, 2, 2],
... 'B': [2, 4, None, 3],
... 'C': [None, None, None, 1],
... 'D': [0, 1, 5, 4]
... },
... columns=['A', 'B', 'C', 'D'])
>>> df
A B C D
0 1 2.0 NaN 0
1 1 4.0 NaN 1
2 2 NaN NaN 5
3 2 3.0 1.0 4
Propagate non-null values forward.
>>> df.groupby(['A']).ffill().sort_index()
B C D
0 2.0 NaN 0
1 4.0 NaN 1
2 NaN NaN 5
3 3.0 1.0 4
"""
return self.fillna(method="ffill", limit=limit)
pad = ffill
def _limit(self, n: int, asc: bool) -> FrameLike:
"""
Private function for tail and head.
"""
psdf = self._psdf
if self._agg_columns_selected:
agg_columns = self._agg_columns
else:
agg_columns = [
psdf._psser_for(label)
for label in psdf._internal.column_labels
if label not in self._column_labels_to_exclude
]
psdf, groupkey_labels, _ = GroupBy._prepare_group_map_apply(
psdf,
self._groupkeys,
agg_columns,
)
groupkey_scols = [psdf._internal.spark_column_for(label) for label in groupkey_labels]
sdf = psdf._internal.spark_frame
window = Window.partitionBy(*groupkey_scols)
# This part is handled differently depending on whether it is a tail or a head.
ordered_window = (
window.orderBy(F.col(NATURAL_ORDER_COLUMN_NAME).asc())
if asc
else window.orderBy(F.col(NATURAL_ORDER_COLUMN_NAME).desc())
)
if n >= 0 or LooseVersion(pd.__version__) < LooseVersion("1.4.0"):
tmp_row_num_col = verify_temp_column_name(sdf, "__row_number__")
sdf = (
sdf.withColumn(tmp_row_num_col, F.row_number().over(ordered_window))
.filter(F.col(tmp_row_num_col) <= n)
.drop(tmp_row_num_col)
)
else:
# Pandas supports Groupby positional indexing since v1.4.0
# https://pandas.pydata.org/docs/whatsnew/v1.4.0.html#groupby-positional-indexing
#
# To support groupby positional indexing, we need add a `__tmp_lag__` column to help
# us filtering rows before the specified offset row.
#
# For example for the dataframe:
# >>> df = ps.DataFrame([["g", "g0"],
# ... ["g", "g1"],
# ... ["g", "g2"],
# ... ["g", "g3"],
# ... ["h", "h0"],
# ... ["h", "h1"]], columns=["A", "B"])
# >>> df.groupby("A").head(-1)
#
# Below is a result to show the `__tmp_lag__` column for above df, the limit n is
# `-1`, the `__tmp_lag__` will be set to `0` in rows[:-1], and left will be set to
# `null`:
#
# >>> sdf.withColumn(tmp_lag_col, F.lag(F.lit(0), -1).over(ordered_window))
# +-----------------+--------------+---+---+-----------------+-----------+
# |__index_level_0__|__groupkey_0__| A| B|__natural_order__|__tmp_lag__|
# +-----------------+--------------+---+---+-----------------+-----------+
# | 0| g| g| g0| 0| 0|
# | 1| g| g| g1| 8589934592| 0|
# | 2| g| g| g2| 17179869184| 0|
# | 3| g| g| g3| 25769803776| null|
# | 4| h| h| h0| 34359738368| 0|
# | 5| h| h| h1| 42949672960| null|
# +-----------------+--------------+---+---+-----------------+-----------+
#
tmp_lag_col = verify_temp_column_name(sdf, "__tmp_lag__")
sdf = (
sdf.withColumn(tmp_lag_col, F.lag(F.lit(0), n).over(ordered_window))
.where(~F.isnull(F.col(tmp_lag_col)))
.drop(tmp_lag_col)
)
internal = psdf._internal.with_new_sdf(sdf)
return self._cleanup_and_return(DataFrame(internal).drop(groupkey_labels, axis=1))
def head(self, n: int = 5) -> FrameLike:
"""
Return first n rows of each group.
Returns
-------
DataFrame or Series
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'b': [2, 3, 1, 4, 6, 9, 8, 10, 7, 5],
... 'c': [3, 5, 2, 5, 1, 2, 6, 4, 3, 6]},
... columns=['a', 'b', 'c'],
... index=[7, 2, 4, 1, 3, 4, 9, 10, 5, 6])
>>> df
a b c
7 1 2 3
2 1 3 5
4 1 1 2
1 1 4 5
3 2 6 1
4 2 9 2
9 2 8 6
10 3 10 4
5 3 7 3
6 3 5 6
>>> df.groupby('a').head(2).sort_index()
a b c
2 1 3 5
3 2 6 1
4 2 9 2
5 3 7 3
7 1 2 3
10 3 10 4
>>> df.groupby('a')['b'].head(2).sort_index()
2 3
3 6
4 9
5 7
7 2
10 10
Name: b, dtype: int64
Supports Groupby positional indexing Since pandas on Spark 3.4 (with pandas 1.4+):
>>> df = ps.DataFrame([["g", "g0"],
... ["g", "g1"],
... ["g", "g2"],
... ["g", "g3"],
... ["h", "h0"],
... ["h", "h1"]], columns=["A", "B"])
>>> df.groupby("A").head(-1) # doctest: +SKIP
A B
0 g g0
1 g g1
2 g g2
4 h h0
"""
return self._limit(n, asc=True)
def tail(self, n: int = 5) -> FrameLike:
"""
Return last n rows of each group.
Similar to `.apply(lambda x: x.tail(n))`, but it returns a subset of rows from
the original DataFrame with original index and order preserved (`as_index` flag is ignored).
Does not work for negative values of n.
Returns
-------
DataFrame or Series
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'b': [2, 3, 1, 4, 6, 9, 8, 10, 7, 5],
... 'c': [3, 5, 2, 5, 1, 2, 6, 4, 3, 6]},
... columns=['a', 'b', 'c'],
... index=[7, 2, 3, 1, 3, 4, 9, 10, 5, 6])
>>> df
a b c
7 1 2 3
2 1 3 5
3 1 1 2
1 1 4 5
3 2 6 1
4 2 9 2
9 2 8 6
10 3 10 4
5 3 7 3
6 3 5 6
>>> df.groupby('a').tail(2).sort_index()
a b c
1 1 4 5
3 1 1 2
4 2 9 2
5 3 7 3
6 3 5 6
9 2 8 6
>>> df.groupby('a')['b'].tail(2).sort_index()
1 4
3 1
4 9
5 7
6 5
9 8
Name: b, dtype: int64
Supports Groupby positional indexing Since pandas on Spark 3.4 (with pandas 1.4+):
>>> df = ps.DataFrame([["g", "g0"],
... ["g", "g1"],
... ["g", "g2"],
... ["g", "g3"],
... ["h", "h0"],
... ["h", "h1"]], columns=["A", "B"])
>>> df.groupby("A").tail(-1) # doctest: +SKIP
A B
3 g g3
2 g g2
1 g g1
5 h h1
"""
return self._limit(n, asc=False)
def shift(self, periods: int = 1, fill_value: Optional[Any] = None) -> FrameLike:
"""
Shift each group by periods observations.
Parameters
----------
periods : integer, default 1
number of periods to shift
fill_value : optional
Returns
-------
Series or DataFrame
Object shifted within each group.
Examples
--------
>>> df = ps.DataFrame({
... 'a': [1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'b': [1, 2, 2, 2, 3, 3, 3, 4, 4]}, columns=['a', 'b'])
>>> df
a b
0 1 1
1 1 2
2 1 2
3 2 2
4 2 3
5 2 3
6 3 3
7 3 4
8 3 4
>>> df.groupby('a').shift().sort_index() # doctest: +SKIP
b
0 NaN
1 1.0
2 2.0
3 NaN
4 2.0
5 3.0
6 NaN
7 3.0
8 4.0
>>> df.groupby('a').shift(periods=-1, fill_value=0).sort_index() # doctest: +SKIP
b
0 2
1 2
2 0
3 3
4 3
5 0
6 4
7 4
8 0
"""
return self._apply_series_op(
lambda sg: sg._psser._shift(periods, fill_value, part_cols=sg._groupkeys_scols),
should_resolve=True,
)
def transform(self, func: Callable[..., pd.Series], *args: Any, **kwargs: Any) -> FrameLike:
"""
Apply function column-by-column to the GroupBy object.
The function passed to `transform` must take a Series as its first
argument and return a Series. The given function is executed for
each series in each grouped data.
While `transform` is a very flexible method, its downside is that
using it can be quite a bit slower than using more specific methods
like `agg` or `transform`. pandas-on-Spark offers a wide range of method that will
be much faster than using `transform` for their specific purposes, so try to
use them before reaching for `transform`.
.. note:: this API executes the function once to infer the type which is
potentially expensive, for instance, when the dataset is created after
aggregations or sorting.
To avoid this, specify return type in ``func``, for instance, as below:
>>> def convert_to_string(x) -> ps.Series[str]:
... return x.apply("a string {}".format)
When the given function has the return type annotated, the original index of the
GroupBy object will be lost and a default index will be attached to the result.
Please be careful about configuring the default index. See also `Default Index Type
<https://koalas.readthedocs.io/en/latest/user_guide/options.html#default-index-type>`_.
.. note:: the series within ``func`` is actually a pandas series. Therefore,
any pandas API within this function is allowed.
Parameters
----------
func : callable
A callable that takes a Series as its first argument, and
returns a Series.
*args
Positional arguments to pass to func.
**kwargs
Keyword arguments to pass to func.
Returns
-------
applied : DataFrame
See Also
--------
aggregate : Apply aggregate function to the GroupBy object.
Series.apply : Apply a function to a Series.
Examples
--------
>>> df = ps.DataFrame({'A': [0, 0, 1],
... 'B': [1, 2, 3],
... 'C': [4, 6, 5]}, columns=['A', 'B', 'C'])
>>> g = df.groupby('A')
Notice that ``g`` has two groups, ``0`` and ``1``.
Calling `transform` in various ways, we can get different grouping results:
Below the functions passed to `transform` takes a Series as
its argument and returns a Series. `transform` applies the function on each series
in each grouped data, and combine them into a new DataFrame:
>>> def convert_to_string(x) -> ps.Series[str]:
... return x.apply("a string {}".format)
>>> g.transform(convert_to_string) # doctest: +NORMALIZE_WHITESPACE
B C
0 a string 1 a string 4
1 a string 2 a string 6
2 a string 3 a string 5
>>> def plus_max(x) -> ps.Series[np.int]:
... return x + x.max()
>>> g.transform(plus_max) # doctest: +NORMALIZE_WHITESPACE
B C
0 3 10
1 4 12
2 6 10
You can omit the type hint and let pandas-on-Spark infer its type.
>>> def plus_min(x):
... return x + x.min()
>>> g.transform(plus_min) # doctest: +NORMALIZE_WHITESPACE
B C
0 2 8
1 3 10
2 6 10
In case of Series, it works as below.
>>> df.B.groupby(df.A).transform(plus_max)
0 3
1 4
2 6
Name: B, dtype: int64
>>> (df * -1).B.groupby(df.A).transform(abs)
0 1
1 2
2 3
Name: B, dtype: int64
You can also specify extra arguments to pass to the function.
>>> def calculation(x, y, z) -> ps.Series[np.int]:
... return x + x.min() + y + z
>>> g.transform(calculation, 5, z=20) # doctest: +NORMALIZE_WHITESPACE
B C
0 27 33
1 28 35
2 31 35
"""
if not callable(func):
raise TypeError("%s object is not callable" % type(func).__name__)
spec = inspect.getfullargspec(func)
return_sig = spec.annotations.get("return", None)
psdf, groupkey_labels, groupkey_names = GroupBy._prepare_group_map_apply(
self._psdf, self._groupkeys, agg_columns=self._agg_columns
)
def pandas_transform(pdf: pd.DataFrame) -> pd.DataFrame:
return pdf.groupby(groupkey_names).transform(func, *args, **kwargs)
should_infer_schema = return_sig is None
if should_infer_schema:
# Here we execute with the first 1000 to get the return type.
# If the records were less than 1000, it uses pandas API directly for a shortcut.
log_advice(
"If the type hints is not specified for `grouby.transform`, "
"it is expensive to infer the data type internally."
)
limit = get_option("compute.shortcut_limit")
pdf = psdf.head(limit + 1)._to_internal_pandas()
pdf = pdf.groupby(groupkey_names).transform(func, *args, **kwargs)
psdf_from_pandas: DataFrame = DataFrame(pdf)
return_schema = force_decimal_precision_scale(
as_nullable_spark_type(
psdf_from_pandas._internal.spark_frame.drop(*HIDDEN_COLUMNS).schema
)
)
if len(pdf) <= limit:
return self._cleanup_and_return(psdf_from_pandas)
sdf = GroupBy._spark_group_map_apply(
psdf,
pandas_transform,
[psdf._internal.spark_column_for(label) for label in groupkey_labels],
return_schema,
retain_index=True,
)
# If schema is inferred, we can restore indexes too.
internal = psdf_from_pandas._internal.with_new_sdf(
sdf,
index_fields=[
field.copy(nullable=True) for field in psdf_from_pandas._internal.index_fields
],
data_fields=[
field.copy(nullable=True) for field in psdf_from_pandas._internal.data_fields
],
)
else:
return_type = infer_return_type(func)
if not isinstance(return_type, SeriesType):
raise TypeError(
"Expected the return type of this function to be of Series type, "
"but found type {}".format(return_type)
)
dtype = return_type.dtype
spark_type = return_type.spark_type
data_fields = [
InternalField(dtype=dtype, struct_field=StructField(name=c, dataType=spark_type))
for c in psdf._internal.data_spark_column_names
if c not in groupkey_names
]
return_schema = StructType([field.struct_field for field in data_fields])
sdf = GroupBy._spark_group_map_apply(
psdf,
pandas_transform,
[psdf._internal.spark_column_for(label) for label in groupkey_labels],
return_schema,
retain_index=False,
)
# Otherwise, it loses index.
internal = InternalFrame(
spark_frame=sdf, index_spark_columns=None, data_fields=data_fields
)
return self._cleanup_and_return(DataFrame(internal))
def nunique(self, dropna: bool = True) -> FrameLike:
"""
Return DataFrame with number of distinct observations per group for each column.
Parameters
----------
dropna : boolean, default True
Don’t include NaN in the counts.
Returns
-------
nunique : DataFrame or Series
Examples
--------
>>> df = ps.DataFrame({'id': ['spam', 'egg', 'egg', 'spam',
... 'ham', 'ham'],
... 'value1': [1, 5, 5, 2, 5, 5],
... 'value2': list('abbaxy')}, columns=['id', 'value1', 'value2'])
>>> df
id value1 value2
0 spam 1 a
1 egg 5 b
2 egg 5 b
3 spam 2 a
4 ham 5 x
5 ham 5 y
>>> df.groupby('id').nunique().sort_index() # doctest: +SKIP
value1 value2
id
egg 1 1
ham 1 2
spam 2 1
>>> df.groupby('id')['value1'].nunique().sort_index() # doctest: +NORMALIZE_WHITESPACE
id
egg 1
ham 1
spam 2
Name: value1, dtype: int64
"""
if dropna:
def stat_function(col: Column) -> Column:
return F.countDistinct(col)
else:
def stat_function(col: Column) -> Column:
return F.countDistinct(col) + F.when(
F.count(F.when(col.isNull(), 1).otherwise(None)) >= 1, 1
).otherwise(0)
return self._reduce_for_stat_function(stat_function)
def rolling(
self, window: int, min_periods: Optional[int] = None
) -> "RollingGroupby[FrameLike]":
"""
Return an rolling grouper, providing rolling
functionality per group.
.. note:: 'min_periods' in pandas-on-Spark works as a fixed window size unlike pandas.
Unlike pandas, NA is also counted as the period. This might be changed
in the near future.
Parameters
----------
window : int, or offset
Size of the moving window.
This is the number of observations used for calculating the statistic.
Each window will be a fixed size.
min_periods : int, default 1
Minimum number of observations in window required to have a value
(otherwise result is NA).
See Also
--------
Series.groupby
DataFrame.groupby
"""
from pyspark.pandas.window import RollingGroupby
return RollingGroupby(self, window, min_periods=min_periods)
def expanding(self, min_periods: int = 1) -> "ExpandingGroupby[FrameLike]":
"""
Return an expanding grouper, providing expanding
functionality per group.
.. note:: 'min_periods' in pandas-on-Spark works as a fixed window size unlike pandas.
Unlike pandas, NA is also counted as the period. This might be changed
in the near future.
Parameters
----------
min_periods : int, default 1
Minimum number of observations in window required to have a value
(otherwise result is NA).
See Also
--------
Series.groupby
DataFrame.groupby
"""
from pyspark.pandas.window import ExpandingGroupby
return ExpandingGroupby(self, min_periods=min_periods)
# TODO: 'adjust', 'axis', 'method' parameter should be implemented.
def ewm(
self,
com: Optional[float] = None,
span: Optional[float] = None,
halflife: Optional[float] = None,
alpha: Optional[float] = None,
min_periods: Optional[int] = None,
ignore_na: bool = False,
) -> "ExponentialMovingGroupby[FrameLike]":
"""
Return an ewm grouper, providing ewm functionality per group.
.. note:: 'min_periods' in pandas-on-Spark works as a fixed window size unlike pandas.
Unlike pandas, NA is also counted as the period. This might be changed
in the near future.
.. versionadded:: 3.4.0
Parameters
----------
com : float, optional
Specify decay in terms of center of mass.
alpha = 1 / (1 + com), for com >= 0.
span : float, optional
Specify decay in terms of span.
alpha = 2 / (span + 1), for span >= 1.
halflife : float, optional
Specify decay in terms of half-life.
alpha = 1 - exp(-ln(2) / halflife), for halflife > 0.
alpha : float, optional
Specify smoothing factor alpha directly.
0 < alpha <= 1.
min_periods : int, default None
Minimum number of observations in window required to have a value
(otherwise result is NA).
ignore_na : bool, default False
Ignore missing values when calculating weights.
- When ``ignore_na=False`` (default), weights are based on absolute positions.
For example, the weights of :math:`x_0` and :math:`x_2` used in calculating
the final weighted average of [:math:`x_0`, None, :math:`x_2`] are
:math:`(1-\alpha)^2` and :math:`1` if ``adjust=True``, and
:math:`(1-\alpha)^2` and :math:`\alpha` if ``adjust=False``.
- When ``ignore_na=True``, weights are based
on relative positions. For example, the weights of :math:`x_0` and :math:`x_2`
used in calculating the final weighted average of
[:math:`x_0`, None, :math:`x_2`] are :math:`1-\alpha` and :math:`1` if
``adjust=True``, and :math:`1-\alpha` and :math:`\alpha` if ``adjust=False``.
"""
from pyspark.pandas.window import ExponentialMovingGroupby
return ExponentialMovingGroupby(
self,
com=com,
span=span,
halflife=halflife,
alpha=alpha,
min_periods=min_periods,
ignore_na=ignore_na,
)
def get_group(self, name: Union[Name, List[Name]]) -> FrameLike:
"""
Construct DataFrame from group with provided name.
Parameters
----------
name : object
The name of the group to get as a DataFrame.
Returns
-------
group : same type as obj
Examples
--------
>>> psdf = ps.DataFrame([('falcon', 'bird', 389.0),
... ('parrot', 'bird', 24.0),
... ('lion', 'mammal', 80.5),
... ('monkey', 'mammal', np.nan)],
... columns=['name', 'class', 'max_speed'],
... index=[0, 2, 3, 1])
>>> psdf
name class max_speed
0 falcon bird 389.0
2 parrot bird 24.0
3 lion mammal 80.5
1 monkey mammal NaN
>>> psdf.groupby("class").get_group("bird").sort_index()
name class max_speed
0 falcon bird 389.0
2 parrot bird 24.0
>>> psdf.groupby("class").get_group("mammal").sort_index()
name class max_speed
1 monkey mammal NaN
3 lion mammal 80.5
"""
groupkeys = self._groupkeys
if not is_hashable(name):
raise TypeError("unhashable type: '{}'".format(type(name).__name__))
elif len(groupkeys) > 1:
if not isinstance(name, tuple):
raise ValueError("must supply a tuple to get_group with multiple grouping keys")
if len(groupkeys) != len(name):
raise ValueError(
"must supply a same-length tuple to get_group with multiple grouping keys"
)
if not is_list_like(name):
name = [name]
cond = SF.lit(True)
for groupkey, item in zip(groupkeys, name):
scol = groupkey.spark.column
cond = cond & (scol == item)
if self._agg_columns_selected:
internal = self._psdf._internal
spark_frame = internal.spark_frame.select(
internal.index_spark_columns + self._agg_columns_scols
).filter(cond)
internal = internal.copy(
spark_frame=spark_frame,
index_spark_columns=[
scol_for(spark_frame, col) for col in internal.index_spark_column_names
],
column_labels=[s._column_label for s in self._agg_columns],
data_spark_columns=[
scol_for(spark_frame, s._internal.data_spark_column_names[0])
for s in self._agg_columns
],
data_fields=[s._internal.data_fields[0] for s in self._agg_columns],
)
else:
internal = self._psdf._internal.with_filter(cond)
if internal.spark_frame.head() is None:
raise KeyError(name)
return self._cleanup_and_return(DataFrame(internal))
def median(self, numeric_only: Optional[bool] = True, accuracy: int = 10000) -> FrameLike:
"""
Compute median of groups, excluding missing values.
For multiple groupings, the result index will be a MultiIndex
.. note:: Unlike pandas', the median in pandas-on-Spark is an approximated median based upon
approximate percentile computation because computing median across a large dataset
is extremely expensive.
Parameters
----------
numeric_only : bool, default False
Include only float, int, boolean columns. If None, will attempt to use
everything, then use only numeric data.
.. versionadded:: 3.4.0
Returns
-------
Series or DataFrame
Median of values within each group.
Examples
--------
>>> psdf = ps.DataFrame({'a': [1., 1., 1., 1., 2., 2., 2., 3., 3., 3.],
... 'b': [2., 3., 1., 4., 6., 9., 8., 10., 7., 5.],
... 'c': [3., 5., 2., 5., 1., 2., 6., 4., 3., 6.]},
... columns=['a', 'b', 'c'],
... index=[7, 2, 4, 1, 3, 4, 9, 10, 5, 6])
>>> psdf
a b c
7 1.0 2.0 3.0
2 1.0 3.0 5.0
4 1.0 1.0 2.0
1 1.0 4.0 5.0
3 2.0 6.0 1.0
4 2.0 9.0 2.0
9 2.0 8.0 6.0
10 3.0 10.0 4.0
5 3.0 7.0 3.0
6 3.0 5.0 6.0
DataFrameGroupBy
>>> psdf.groupby('a').median().sort_index() # doctest: +NORMALIZE_WHITESPACE
b c
a
1.0 2.0 3.0
2.0 8.0 2.0
3.0 7.0 4.0
SeriesGroupBy
>>> psdf.groupby('a')['b'].median().sort_index()
a
1.0 2.0
2.0 8.0
3.0 7.0
Name: b, dtype: float64
"""
if not isinstance(accuracy, int):
raise TypeError(
"accuracy must be an integer; however, got [%s]" % type(accuracy).__name__
)
self._validate_agg_columns(numeric_only=numeric_only, function_name="median")
def stat_function(col: Column) -> Column:
return F.percentile_approx(col, 0.5, accuracy)
return self._reduce_for_stat_function(
stat_function,
accepted_spark_types=(NumericType,),
bool_to_numeric=True,
)
def _validate_agg_columns(self, numeric_only: Optional[bool], function_name: str) -> None:
"""Validate aggregation columns and raise an error or a warning following pandas."""
has_non_numeric = False
for _agg_col in self._agg_columns:
if not isinstance(_agg_col.spark.data_type, (NumericType, BooleanType)):
has_non_numeric = True
break
if has_non_numeric:
if isinstance(self, SeriesGroupBy):
raise TypeError("Only numeric aggregation column is accepted.")
if not numeric_only:
if has_non_numeric:
warnings.warn(
"Dropping invalid columns in DataFrameGroupBy.mean is deprecated. "
"In a future version, a TypeError will be raised. "
"Before calling .%s, select only columns which should be "
"valid for the function." % function_name,
FutureWarning,
)
def _reduce_for_stat_function(
self,
sfun: Callable[[Column], Column],
accepted_spark_types: Optional[Tuple[Type[DataType], ...]] = None,
bool_to_numeric: bool = False,
) -> FrameLike:
"""Apply an aggregate function `sfun` per column and reduce to a FrameLike.
Parameters
----------
sfun : The aggregate function to apply per column.
accepted_spark_types: Accepted spark types of columns to be aggregated;
default None means all spark types are accepted.
bool_to_numeric: If True, boolean columns are converted to numeric columns, which
are accepted for all statistical functions regardless of
`accepted_spark_types`.
"""
groupkey_names = [SPARK_INDEX_NAME_FORMAT(i) for i in range(len(self._groupkeys))]
groupkey_scols = [s.alias(name) for s, name in zip(self._groupkeys_scols, groupkey_names)]
agg_columns = []
for psser in self._agg_columns:
if bool_to_numeric and isinstance(psser.spark.data_type, BooleanType):
agg_columns.append(psser.astype(int))
elif (accepted_spark_types is None) or isinstance(
psser.spark.data_type, accepted_spark_types
):
agg_columns.append(psser)
sdf = self._psdf._internal.spark_frame.select(
*groupkey_scols, *[psser.spark.column for psser in agg_columns]
)
internal = InternalFrame(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in groupkey_names],
index_names=[psser._column_label for psser in self._groupkeys],
index_fields=[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(self._groupkeys, groupkey_names)
],
data_spark_columns=[
scol_for(sdf, psser._internal.data_spark_column_names[0]) for psser in agg_columns
],
column_labels=[psser._column_label for psser in agg_columns],
data_fields=[psser._internal.data_fields[0] for psser in agg_columns],
column_label_names=self._psdf._internal.column_label_names,
)
psdf: DataFrame = DataFrame(internal)
if len(psdf._internal.column_labels) > 0:
stat_exprs = []
for label in psdf._internal.column_labels:
psser = psdf._psser_for(label)
stat_exprs.append(
sfun(psser._dtype_op.nan_to_null(psser).spark.column).alias(
psser._internal.data_spark_column_names[0]
)
)
sdf = sdf.groupby(*groupkey_names).agg(*stat_exprs)
else:
sdf = sdf.select(*groupkey_names).distinct()
internal = internal.copy(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in groupkey_names],
data_spark_columns=[scol_for(sdf, col) for col in internal.data_spark_column_names],
data_fields=None,
)
psdf = DataFrame(internal)
if self._dropna:
psdf = DataFrame(
psdf._internal.with_new_sdf(
psdf._internal.spark_frame.dropna(
subset=psdf._internal.index_spark_column_names
)
)
)
if not self._as_index:
should_drop_index = set(
i for i, gkey in enumerate(self._groupkeys) if gkey._psdf is not self._psdf
)
if len(should_drop_index) > 0:
psdf = psdf.reset_index(level=should_drop_index, drop=True)
if len(should_drop_index) < len(self._groupkeys):
psdf = psdf.reset_index()
return self._cleanup_and_return(psdf)
@staticmethod
def _resolve_grouping_from_diff_dataframes(
psdf: DataFrame, by: List[Union[Series, Label]]
) -> Tuple[DataFrame, List[Series], Set[Label]]:
column_labels_level = psdf._internal.column_labels_level
column_labels = []
additional_pssers = []
additional_column_labels = []
tmp_column_labels = set()
for i, col_or_s in enumerate(by):
if isinstance(col_or_s, Series):
if col_or_s._psdf is psdf:
column_labels.append(col_or_s._column_label)
elif same_anchor(col_or_s, psdf):
temp_label = verify_temp_column_name(psdf, "__tmp_groupkey_{}__".format(i))
column_labels.append(temp_label)
additional_pssers.append(col_or_s.rename(temp_label))
additional_column_labels.append(temp_label)
else:
temp_label = verify_temp_column_name(
psdf,
tuple(
([""] * (column_labels_level - 1)) + ["__tmp_groupkey_{}__".format(i)]
),
)
column_labels.append(temp_label)
tmp_column_labels.add(temp_label)
elif isinstance(col_or_s, tuple):
psser = psdf[col_or_s]
if not isinstance(psser, Series):
raise ValueError(name_like_string(col_or_s))
column_labels.append(col_or_s)
else:
raise ValueError(col_or_s)
psdf = DataFrame(
psdf._internal.with_new_columns(
[psdf._psser_for(label) for label in psdf._internal.column_labels]
+ additional_pssers
)
)
def assign_columns(
psdf: DataFrame, this_column_labels: List[Label], that_column_labels: List[Label]
) -> Iterator[Tuple[Series, Label]]:
raise NotImplementedError(
"Duplicated labels with groupby() and "
"'compute.ops_on_diff_frames' option are not supported currently "
"Please use unique labels in series and frames."
)
for col_or_s, label in zip(by, column_labels):
if label in tmp_column_labels:
psser = col_or_s
psdf = align_diff_frames(
assign_columns,
psdf,
psser.rename(label),
fillna=False,
how="inner",
preserve_order_column=True,
)
tmp_column_labels |= set(additional_column_labels)
new_by_series = []
for col_or_s, label in zip(by, column_labels):
if label in tmp_column_labels:
psser = col_or_s
new_by_series.append(psdf._psser_for(label).rename(psser.name))
else:
new_by_series.append(psdf._psser_for(label))
return psdf, new_by_series, tmp_column_labels
@staticmethod
def _resolve_grouping(psdf: DataFrame, by: List[Union[Series, Label]]) -> List[Series]:
new_by_series = []
for col_or_s in by:
if isinstance(col_or_s, Series):
new_by_series.append(col_or_s)
elif isinstance(col_or_s, tuple):
psser = psdf[col_or_s]
if not isinstance(psser, Series):
raise ValueError(name_like_string(col_or_s))
new_by_series.append(psser)
else:
raise ValueError(col_or_s)
return new_by_series
class DataFrameGroupBy(GroupBy[DataFrame]):
@staticmethod
def _build(
psdf: DataFrame, by: List[Union[Series, Label]], as_index: bool, dropna: bool
) -> "DataFrameGroupBy":
if any(isinstance(col_or_s, Series) and not same_anchor(psdf, col_or_s) for col_or_s in by):
(
psdf,
new_by_series,
column_labels_to_exclude,
) = GroupBy._resolve_grouping_from_diff_dataframes(psdf, by)
else:
new_by_series = GroupBy._resolve_grouping(psdf, by)
column_labels_to_exclude = set()
return DataFrameGroupBy(
psdf,
new_by_series,
as_index=as_index,
dropna=dropna,
column_labels_to_exclude=column_labels_to_exclude,
)
def __init__(
self,
psdf: DataFrame,
by: List[Series],
as_index: bool,
dropna: bool,
column_labels_to_exclude: Set[Label],
agg_columns: List[Label] = None,
):
agg_columns_selected = agg_columns is not None
if agg_columns_selected:
for label in agg_columns:
if label in column_labels_to_exclude:
raise KeyError(label)
else:
agg_columns = [
label
for label in psdf._internal.column_labels
if not any(label == key._column_label and key._psdf is psdf for key in by)
and label not in column_labels_to_exclude
]
super().__init__(
psdf=psdf,
groupkeys=by,
as_index=as_index,
dropna=dropna,
column_labels_to_exclude=column_labels_to_exclude,
agg_columns_selected=agg_columns_selected,
agg_columns=[psdf[label] for label in agg_columns],
)
def __getattr__(self, item: str) -> Any:
if hasattr(MissingPandasLikeDataFrameGroupBy, item):
property_or_func = getattr(MissingPandasLikeDataFrameGroupBy, item)
if isinstance(property_or_func, property):
return property_or_func.fget(self)
else:
return partial(property_or_func, self)
return self.__getitem__(item)
def __getitem__(self, item: Any) -> GroupBy:
if self._as_index and is_name_like_value(item):
return SeriesGroupBy(
self._psdf._psser_for(item if is_name_like_tuple(item) else (item,)),
self._groupkeys,
dropna=self._dropna,
)
else:
if is_name_like_tuple(item):
item = [item]
elif is_name_like_value(item):
item = [(item,)]
else:
item = [i if is_name_like_tuple(i) else (i,) for i in item]
if not self._as_index:
groupkey_names = set(key._column_label for key in self._groupkeys)
for name in item:
if name in groupkey_names:
raise ValueError(
"cannot insert {}, already exists".format(name_like_string(name))
)
return DataFrameGroupBy(
self._psdf,
self._groupkeys,
as_index=self._as_index,
dropna=self._dropna,
column_labels_to_exclude=self._column_labels_to_exclude,
agg_columns=item,
)
def _apply_series_op(
self,
op: Callable[["SeriesGroupBy"], Series],
should_resolve: bool = False,
numeric_only: bool = False,
) -> DataFrame:
applied = []
for column in self._agg_columns:
applied.append(op(column.groupby(self._groupkeys)))
if numeric_only:
applied = [col for col in applied if isinstance(col.spark.data_type, NumericType)]
if not applied:
raise DataError("No numeric types to aggregate")
internal = self._psdf._internal.with_new_columns(applied, keep_order=False)
if should_resolve:
internal = internal.resolved_copy
return DataFrame(internal)
def _cleanup_and_return(self, psdf: DataFrame) -> DataFrame:
return psdf
# TODO: Implement 'percentiles', 'include', and 'exclude' arguments.
# TODO: Add ``DataFrame.select_dtypes`` to See Also when 'include'
# and 'exclude' arguments are implemented.
def describe(self) -> DataFrame:
"""
Generate descriptive statistics that summarize the central tendency,
dispersion and shape of a dataset's distribution, excluding
``NaN`` values.
Analyzes both numeric and object series, as well
as ``DataFrame`` column sets of mixed data types. The output
will vary depending on what is provided. Refer to the notes
below for more detail.
.. note:: Unlike pandas, the percentiles in pandas-on-Spark are based upon
approximate percentile computation because computing percentiles
across a large dataset is extremely expensive.
Returns
-------
DataFrame
Summary statistics of the DataFrame provided.
See Also
--------
DataFrame.count
DataFrame.max
DataFrame.min
DataFrame.mean
DataFrame.std
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]})
>>> df
a b c
0 1 4 7
1 1 5 8
2 3 6 9
Describing a ``DataFrame``. By default only numeric fields
are returned.
>>> described = df.groupby('a').describe()
>>> described.sort_index() # doctest: +NORMALIZE_WHITESPACE
b c
count mean std min 25% 50% 75% max count mean std min 25% 50% 75% max
a
1 2.0 4.5 0.707107 4.0 4.0 4.0 5.0 5.0 2.0 7.5 0.707107 7.0 7.0 7.0 8.0 8.0
3 1.0 6.0 NaN 6.0 6.0 6.0 6.0 6.0 1.0 9.0 NaN 9.0 9.0 9.0 9.0 9.0
"""
for col in self._agg_columns:
if isinstance(col.spark.data_type, StringType):
raise NotImplementedError(
"DataFrameGroupBy.describe() doesn't support for string type for now"
)
psdf = self.aggregate(["count", "mean", "std", "min", "quartiles", "max"])
sdf = psdf._internal.spark_frame
agg_column_labels = [col._column_label for col in self._agg_columns]
formatted_percentiles = ["25%", "50%", "75%"]
# Split "quartiles" columns into first, second, and third quartiles.
for label in agg_column_labels:
quartiles_col = name_like_string(tuple(list(label) + ["quartiles"]))
for i, percentile in enumerate(formatted_percentiles):
sdf = sdf.withColumn(
name_like_string(tuple(list(label) + [percentile])),
scol_for(sdf, quartiles_col)[i],
)
sdf = sdf.drop(quartiles_col)
# Reorder columns lexicographically by agg column followed by stats.
stats = ["count", "mean", "std", "min"] + formatted_percentiles + ["max"]
column_labels = [tuple(list(label) + [s]) for label, s in product(agg_column_labels, stats)]
data_columns = map(name_like_string, column_labels)
# Reindex the DataFrame to reflect initial grouping and agg columns.
internal = psdf._internal.copy(
spark_frame=sdf,
column_labels=column_labels,
data_spark_columns=[scol_for(sdf, col) for col in data_columns],
data_fields=None,
)
# Cast columns to ``"float64"`` to match `pandas.DataFrame.groupby`.
return DataFrame(internal).astype("float64")
class SeriesGroupBy(GroupBy[Series]):
@staticmethod
def _build(
psser: Series, by: List[Union[Series, Label]], as_index: bool, dropna: bool
) -> "SeriesGroupBy":
if any(
isinstance(col_or_s, Series) and not same_anchor(psser, col_or_s) for col_or_s in by
):
psdf, new_by_series, _ = GroupBy._resolve_grouping_from_diff_dataframes(
psser.to_frame(), by
)
return SeriesGroupBy(
first_series(psdf).rename(psser.name),
new_by_series,
as_index=as_index,
dropna=dropna,
)
else:
new_by_series = GroupBy._resolve_grouping(psser._psdf, by)
return SeriesGroupBy(psser, new_by_series, as_index=as_index, dropna=dropna)
def __init__(self, psser: Series, by: List[Series], as_index: bool = True, dropna: bool = True):
if not as_index:
raise TypeError("as_index=False only valid with DataFrame")
super().__init__(
psdf=psser._psdf,
groupkeys=by,
as_index=True,
dropna=dropna,
column_labels_to_exclude=set(),
agg_columns_selected=True,
agg_columns=[psser],
)
self._psser = psser
def __getattr__(self, item: str) -> Any:
if hasattr(MissingPandasLikeSeriesGroupBy, item):
property_or_func = getattr(MissingPandasLikeSeriesGroupBy, item)
if isinstance(property_or_func, property):
return property_or_func.fget(self)
else:
return partial(property_or_func, self)
raise AttributeError(item)
def _apply_series_op(
self,
op: Callable[["SeriesGroupBy"], Series],
should_resolve: bool = False,
numeric_only: bool = False,
) -> Series:
if numeric_only and not isinstance(self._agg_columns[0].spark.data_type, NumericType):
raise DataError("No numeric types to aggregate")
psser = op(self)
if should_resolve:
internal = psser._internal.resolved_copy
return first_series(DataFrame(internal))
else:
return psser.copy()
def _cleanup_and_return(self, psdf: DataFrame) -> Series:
return first_series(psdf).rename().rename(self._psser.name)
def agg(self, *args: Any, **kwargs: Any) -> None:
return MissingPandasLikeSeriesGroupBy.agg(self, *args, **kwargs)
def aggregate(self, *args: Any, **kwargs: Any) -> None:
return MissingPandasLikeSeriesGroupBy.aggregate(self, *args, **kwargs)
def size(self) -> Series:
return super().size().rename(self._psser.name)
size.__doc__ = GroupBy.size.__doc__
# TODO: add keep parameter
def nsmallest(self, n: int = 5) -> Series:
"""
Return the smallest `n` elements.
Parameters
----------
n : int
Number of items to retrieve.
See Also
--------
pyspark.pandas.Series.nsmallest
pyspark.pandas.DataFrame.nsmallest
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'b': [1, 2, 2, 2, 3, 3, 3, 4, 4]}, columns=['a', 'b'])
>>> df.groupby(['a'])['b'].nsmallest(1).sort_index() # doctest: +NORMALIZE_WHITESPACE
a
1 0 1
2 3 2
3 6 3
Name: b, dtype: int64
"""
if self._psser._internal.index_level > 1:
raise ValueError("nsmallest do not support multi-index now")
groupkey_col_names = [SPARK_INDEX_NAME_FORMAT(i) for i in range(len(self._groupkeys))]
sdf = self._psser._internal.spark_frame.select(
*[scol.alias(name) for scol, name in zip(self._groupkeys_scols, groupkey_col_names)],
*[
scol.alias(SPARK_INDEX_NAME_FORMAT(i + len(self._groupkeys)))
for i, scol in enumerate(self._psser._internal.index_spark_columns)
],
self._psser.spark.column,
NATURAL_ORDER_COLUMN_NAME,
)
window = Window.partitionBy(*groupkey_col_names).orderBy(
scol_for(sdf, self._psser._internal.data_spark_column_names[0]).asc(),
NATURAL_ORDER_COLUMN_NAME,
)
temp_rank_column = verify_temp_column_name(sdf, "__rank__")
sdf = (
sdf.withColumn(temp_rank_column, F.row_number().over(window))
.filter(F.col(temp_rank_column) <= n)
.drop(temp_rank_column)
).drop(NATURAL_ORDER_COLUMN_NAME)
internal = InternalFrame(
spark_frame=sdf,
index_spark_columns=(
[scol_for(sdf, col) for col in groupkey_col_names]
+ [
scol_for(sdf, SPARK_INDEX_NAME_FORMAT(i + len(self._groupkeys)))
for i in range(self._psdf._internal.index_level)
]
),
index_names=(
[psser._column_label for psser in self._groupkeys]
+ self._psdf._internal.index_names
),
index_fields=(
[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(self._groupkeys, groupkey_col_names)
]
+ [
field.copy(name=SPARK_INDEX_NAME_FORMAT(i + len(self._groupkeys)))
for i, field in enumerate(self._psdf._internal.index_fields)
]
),
column_labels=[self._psser._column_label],
data_spark_columns=[scol_for(sdf, self._psser._internal.data_spark_column_names[0])],
data_fields=[self._psser._internal.data_fields[0]],
)
return first_series(DataFrame(internal))
# TODO: add keep parameter
def nlargest(self, n: int = 5) -> Series:
"""
Return the first n rows ordered by columns in descending order in group.
Return the first n rows with the smallest values in columns, in descending order.
The columns that are not specified are returned as well, but not used for ordering.
Parameters
----------
n : int
Number of items to retrieve.
See Also
--------
pyspark.pandas.Series.nlargest
pyspark.pandas.DataFrame.nlargest
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'b': [1, 2, 2, 2, 3, 3, 3, 4, 4]}, columns=['a', 'b'])
>>> df.groupby(['a'])['b'].nlargest(1).sort_index() # doctest: +NORMALIZE_WHITESPACE
a
1 1 2
2 4 3
3 7 4
Name: b, dtype: int64
"""
if self._psser._internal.index_level > 1:
raise ValueError("nlargest do not support multi-index now")
groupkey_col_names = [SPARK_INDEX_NAME_FORMAT(i) for i in range(len(self._groupkeys))]
sdf = self._psser._internal.spark_frame.select(
*[scol.alias(name) for scol, name in zip(self._groupkeys_scols, groupkey_col_names)],
*[
scol.alias(SPARK_INDEX_NAME_FORMAT(i + len(self._groupkeys)))
for i, scol in enumerate(self._psser._internal.index_spark_columns)
],
self._psser.spark.column,
NATURAL_ORDER_COLUMN_NAME,
)
window = Window.partitionBy(*groupkey_col_names).orderBy(
scol_for(sdf, self._psser._internal.data_spark_column_names[0]).desc(),
NATURAL_ORDER_COLUMN_NAME,
)
temp_rank_column = verify_temp_column_name(sdf, "__rank__")
sdf = (
sdf.withColumn(temp_rank_column, F.row_number().over(window))
.filter(F.col(temp_rank_column) <= n)
.drop(temp_rank_column)
).drop(NATURAL_ORDER_COLUMN_NAME)
internal = InternalFrame(
spark_frame=sdf,
index_spark_columns=(
[scol_for(sdf, col) for col in groupkey_col_names]
+ [
scol_for(sdf, SPARK_INDEX_NAME_FORMAT(i + len(self._groupkeys)))
for i in range(self._psdf._internal.index_level)
]
),
index_names=(
[psser._column_label for psser in self._groupkeys]
+ self._psdf._internal.index_names
),
index_fields=(
[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(self._groupkeys, groupkey_col_names)
]
+ [
field.copy(name=SPARK_INDEX_NAME_FORMAT(i + len(self._groupkeys)))
for i, field in enumerate(self._psdf._internal.index_fields)
]
),
column_labels=[self._psser._column_label],
data_spark_columns=[scol_for(sdf, self._psser._internal.data_spark_column_names[0])],
data_fields=[self._psser._internal.data_fields[0]],
)
return first_series(DataFrame(internal))
# TODO: add bins, normalize parameter
def value_counts(
self, sort: Optional[bool] = None, ascending: Optional[bool] = None, dropna: bool = True
) -> Series:
"""
Compute group sizes.
Parameters
----------
sort : boolean, default None
Sort by frequencies.
ascending : boolean, default False
Sort in ascending order.
dropna : boolean, default True
Don't include counts of NaN.
See Also
--------
pyspark.pandas.Series.groupby
pyspark.pandas.DataFrame.groupby
Examples
--------
>>> df = ps.DataFrame({'A': [1, 2, 2, 3, 3, 3],
... 'B': [1, 1, 2, 3, 3, np.nan]},
... columns=['A', 'B'])
>>> df
A B
0 1 1.0
1 2 1.0
2 2 2.0
3 3 3.0
4 3 3.0
5 3 NaN
>>> df.groupby('A')['B'].value_counts().sort_index() # doctest: +NORMALIZE_WHITESPACE
A B
1 1.0 1
2 1.0 1
2.0 1
3 3.0 2
Name: B, dtype: int64
Don't include counts of NaN when dropna is False.
>>> df.groupby('A')['B'].value_counts(
... dropna=False).sort_index() # doctest: +NORMALIZE_WHITESPACE
A B
1 1.0 1
2 1.0 1
2.0 1
3 3.0 2
NaN 1
Name: B, dtype: int64
"""
groupkeys = self._groupkeys + self._agg_columns
groupkey_names = [SPARK_INDEX_NAME_FORMAT(i) for i in range(len(groupkeys))]
groupkey_cols = [s.spark.column.alias(name) for s, name in zip(groupkeys, groupkey_names)]
sdf = self._psdf._internal.spark_frame
agg_column = self._agg_columns[0]._internal.data_spark_column_names[0]
sdf = sdf.groupby(*groupkey_cols).count().withColumnRenamed("count", agg_column)
if self._dropna:
_groupkey_column_names = groupkey_names[: len(self._groupkeys)]
sdf = sdf.dropna(subset=_groupkey_column_names)
if dropna:
_agg_columns_names = groupkey_names[len(self._groupkeys) :]
sdf = sdf.dropna(subset=_agg_columns_names)
if sort:
if ascending:
sdf = sdf.orderBy(scol_for(sdf, agg_column).asc())
else:
sdf = sdf.orderBy(scol_for(sdf, agg_column).desc())
internal = InternalFrame(
spark_frame=sdf,
index_spark_columns=[scol_for(sdf, col) for col in groupkey_names],
index_names=[psser._column_label for psser in groupkeys],
index_fields=[
psser._internal.data_fields[0].copy(name=name)
for psser, name in zip(groupkeys, groupkey_names)
],
column_labels=[self._agg_columns[0]._column_label],
data_spark_columns=[scol_for(sdf, agg_column)],
)
return first_series(DataFrame(internal))
def unique(self) -> Series:
"""
Return unique values in group.
Uniques are returned in order of unknown. It does NOT sort.
See Also
--------
pyspark.pandas.Series.unique
pyspark.pandas.Index.unique
Examples
--------
>>> df = ps.DataFrame({'a': [1, 1, 1, 2, 2, 2, 3, 3, 3],
... 'b': [1, 2, 2, 2, 3, 3, 3, 4, 4]}, columns=['a', 'b'])
>>> df.groupby(['a'])['b'].unique().sort_index() # doctest: +SKIP
a
1 [1, 2]
2 [2, 3]
3 [3, 4]
Name: b, dtype: object
"""
return self._reduce_for_stat_function(F.collect_set)
def is_multi_agg_with_relabel(**kwargs: Any) -> bool:
"""
Check whether the kwargs pass to .agg look like multi-agg with relabling.
Parameters
----------
**kwargs : dict
Returns
-------
bool
Examples
--------
>>> is_multi_agg_with_relabel(a='max')
False
>>> is_multi_agg_with_relabel(a_max=('a', 'max'),
... a_min=('a', 'min'))
True
>>> is_multi_agg_with_relabel()
False
"""
if not kwargs:
return False
return all(isinstance(v, tuple) and len(v) == 2 for v in kwargs.values())
def normalize_keyword_aggregation(
kwargs: Dict[str, Tuple[Name, str]],
) -> Tuple[Dict[Name, List[str]], List[str], List[Tuple]]:
"""
Normalize user-provided kwargs.
Transforms from the new ``Dict[str, NamedAgg]`` style kwargs
to the old defaultdict[str, List[scalar]].
Parameters
----------
kwargs : dict
Returns
-------
aggspec : dict
The transformed kwargs.
columns : List[str]
The user-provided keys.
order : List[Tuple[str, str]]
Pairs of the input and output column names.
Examples
--------
>>> normalize_keyword_aggregation({'output': ('input', 'sum')})
(defaultdict(<class 'list'>, {'input': ['sum']}), ['output'], [('input', 'sum')])
"""
aggspec: Dict[Union[Any, Tuple], List[str]] = defaultdict(list)
order: List[Tuple] = []
columns, pairs = zip(*kwargs.items())
for column, aggfunc in pairs:
if column in aggspec:
aggspec[column].append(aggfunc)
else:
aggspec[column] = [aggfunc]
order.append((column, aggfunc))
# For MultiIndex, we need to flatten the tuple, e.g. (('y', 'A'), 'max') needs to be
# flattened to ('y', 'A', 'max'), it won't do anything on normal Index.
if isinstance(order[0][0], tuple):
order = [(*levs, method) for levs, method in order]
return aggspec, list(columns), order
def _test() -> None:
import os
import doctest
import sys
import numpy
from pyspark.sql import SparkSession
import pyspark.pandas.groupby
os.chdir(os.environ["SPARK_HOME"])
globs = pyspark.pandas.groupby.__dict__.copy()
globs["np"] = numpy
globs["ps"] = pyspark.pandas
spark = (
SparkSession.builder.master("local[4]")
.appName("pyspark.pandas.groupby tests")
.getOrCreate()
)
(failure_count, test_count) = doctest.testmod(
pyspark.pandas.groupby,
globs=globs,
optionflags=doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE,
)
spark.stop()
if failure_count:
sys.exit(-1)
if __name__ == "__main__":
_test()
|
[] |
[] |
[
"SPARK_HOME"
] |
[]
|
["SPARK_HOME"]
|
python
| 1 | 0 | |
modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/Swift5ClientCodegen.java
|
/*
* Copyright 2018 OpenAPI-Generator Contributors (https://openapi-generator.tech)
* Copyright 2018 SmartBear Software
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.openapitools.codegen.languages;
import io.swagger.v3.oas.models.media.ArraySchema;
import io.swagger.v3.oas.models.media.Schema;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.text.WordUtils;
import org.openapitools.codegen.*;
import org.openapitools.codegen.meta.GeneratorMetadata;
import org.openapitools.codegen.meta.Stability;
import org.openapitools.codegen.utils.ModelUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.time.OffsetDateTime;
import java.time.Instant;
import java.time.temporal.ChronoField;
import java.util.concurrent.TimeUnit;
import static org.openapitools.codegen.utils.StringUtils.camelize;
public class Swift5ClientCodegen extends DefaultCodegen implements CodegenConfig {
private final Logger LOGGER = LoggerFactory.getLogger(Swift5ClientCodegen.class);
public static final String PROJECT_NAME = "projectName";
public static final String RESPONSE_AS = "responseAs";
public static final String OBJC_COMPATIBLE = "objcCompatible";
public static final String POD_SOURCE = "podSource";
public static final String POD_AUTHORS = "podAuthors";
public static final String POD_SOCIAL_MEDIA_URL = "podSocialMediaURL";
public static final String POD_LICENSE = "podLicense";
public static final String POD_HOMEPAGE = "podHomepage";
public static final String POD_SUMMARY = "podSummary";
public static final String POD_DESCRIPTION = "podDescription";
public static final String POD_SCREENSHOTS = "podScreenshots";
public static final String POD_DOCUMENTATION_URL = "podDocumentationURL";
public static final String READONLY_PROPERTIES = "readonlyProperties";
public static final String SWIFT_USE_API_NAMESPACE = "swiftUseApiNamespace";
public static final String DEFAULT_POD_AUTHORS = "OpenAPI Generator";
public static final String LENIENT_TYPE_CAST = "lenientTypeCast";
public static final String USE_SPM_FILE_STRUCTURE = "useSPMFileStructure";
public static final String SWIFT_PACKAGE_PATH = "swiftPackagePath";
public static final String USE_CLASSES = "useClasses";
public static final String USE_BACKTICK_ESCAPES = "useBacktickEscapes";
public static final String GENERATE_MODEL_ADDITIONAL_PROPERTIES = "generateModelAdditionalProperties";
public static final String HASHABLE_MODELS = "hashableModels";
public static final String MAP_FILE_BINARY_TO_DATA = "mapFileBinaryToData";
protected static final String LIBRARY_ALAMOFIRE = "alamofire";
protected static final String LIBRARY_URLSESSION = "urlsession";
protected static final String LIBRARY_VAPOR = "vapor";
protected static final String RESPONSE_LIBRARY_PROMISE_KIT = "PromiseKit";
protected static final String RESPONSE_LIBRARY_RX_SWIFT = "RxSwift";
protected static final String RESPONSE_LIBRARY_RESULT = "Result";
protected static final String RESPONSE_LIBRARY_COMBINE = "Combine";
protected static final String[] RESPONSE_LIBRARIES = {RESPONSE_LIBRARY_PROMISE_KIT, RESPONSE_LIBRARY_RX_SWIFT, RESPONSE_LIBRARY_RESULT, RESPONSE_LIBRARY_COMBINE};
protected String projectName = "OpenAPIClient";
protected boolean nonPublicApi = false;
protected boolean objcCompatible = false;
protected boolean lenientTypeCast = false;
protected boolean readonlyProperties = false;
protected boolean swiftUseApiNamespace = false;
protected boolean useSPMFileStructure = false;
protected String swiftPackagePath = "Classes" + File.separator + "OpenAPIs";
protected boolean useClasses = false;
protected boolean useBacktickEscapes = false;
protected boolean generateModelAdditionalProperties = true;
protected boolean hashableModels = true;
protected boolean mapFileBinaryToData = false;
protected String[] responseAs = new String[0];
protected String sourceFolder = swiftPackagePath;
protected HashSet objcReservedWords;
protected String apiDocPath = "docs/";
protected String modelDocPath = "docs/";
/**
* Constructor for the swift5 language codegen module.
*/
public Swift5ClientCodegen() {
super();
this.useOneOfInterfaces = true;
generatorMetadata = GeneratorMetadata.newBuilder(generatorMetadata)
.stability(Stability.STABLE)
.build();
outputFolder = "generated-code" + File.separator + "swift";
modelTemplateFiles.put("model.mustache", ".swift");
apiTemplateFiles.put("api.mustache", ".swift");
embeddedTemplateDir = templateDir = "swift5";
apiPackage = File.separator + "APIs";
modelPackage = File.separator + "Models";
modelDocTemplateFiles.put("model_doc.mustache", ".md");
apiDocTemplateFiles.put("api_doc.mustache", ".md");
languageSpecificPrimitives = new HashSet<>(
Arrays.asList(
"Int",
"Int32",
"Int64",
"Float",
"Double",
"Bool",
"Void",
"String",
"Data",
"Date",
"Character",
"UUID",
"URL",
"AnyObject",
"Any",
"Decimal")
);
defaultIncludes = new HashSet<>(
Arrays.asList(
"Data",
"Date",
"URL", // for file
"UUID",
"Array",
"Dictionary",
"Set",
"Any",
"Empty",
"AnyObject",
"Any",
"Decimal")
);
objcReservedWords = new HashSet<>(
Arrays.asList(
// Added for Objective-C compatibility
"id", "description", "NSArray", "NSURL", "CGFloat", "NSSet", "NSString", "NSInteger", "NSUInteger",
"NSError", "NSDictionary",
// 'Property 'hash' with type 'String' cannot override a property with type 'Int' (when objcCompatible=true)
"hash",
// Cannot override with a stored property 'className'
"className"
)
);
reservedWords = new HashSet<>(
Arrays.asList(
// name used by swift client
"ErrorResponse", "Response",
// Swift keywords. This list is taken from here:
// https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-ID410
//
// Keywords used in declarations
"associatedtype", "class", "deinit", "enum", "extension", "fileprivate", "func", "import", "init",
"inout", "internal", "let", "open", "operator", "private", "protocol", "public", "static", "struct",
"subscript", "typealias", "var",
// Keywords uses in statements
"break", "case", "continue", "default", "defer", "do", "else", "fallthrough", "for", "guard", "if",
"in", "repeat", "return", "switch", "where", "while",
// Keywords used in expressions and types
"as", "Any", "catch", "false", "is", "nil", "rethrows", "super", "self", "Self", "throw", "throws", "true", "try",
// Keywords used in patterns
"_",
// Keywords that begin with a number sign
"#available", "#colorLiteral", "#column", "#else", "#elseif", "#endif", "#file", "#fileLiteral", "#function", "#if",
"#imageLiteral", "#line", "#selector", "#sourceLocation",
// Keywords reserved in particular contexts
"associativity", "convenience", "dynamic", "didSet", "final", "get", "infix", "indirect", "lazy", "left",
"mutating", "none", "nonmutating", "optional", "override", "postfix", "precedence", "prefix", "Protocol",
"required", "right", "set", "Type", "unowned", "weak", "willSet",
//
// Swift Standard Library types
// https://developer.apple.com/documentation/swift
//
// Numbers and Basic Values
"Bool", "Int", "Double", "Float", "Range", "ClosedRange", "Error", "Optional",
// Special-Use Numeric Types
"UInt", "UInt8", "UInt16", "UInt32", "UInt64", "Int8", "Int16", "Int32", "Int64", "Float80", "Float32", "Float64",
// Strings and Text
"String", "Character", "Unicode", "StaticString",
// Collections
"Array", "Dictionary", "Set", "OptionSet", "CountableRange", "CountableClosedRange",
// The following are commonly-used Foundation types
"URL", "Data", "Codable", "Encodable", "Decodable",
// The following are other words we want to reserve
"Void", "AnyObject", "Class", "dynamicType", "COLUMN", "FILE", "FUNCTION", "LINE"
)
);
typeMapping = new HashMap<>();
typeMapping.put("array", "Array");
typeMapping.put("map", "Dictionary");
typeMapping.put("set", "Set");
typeMapping.put("date", "Date");
typeMapping.put("Date", "Date");
typeMapping.put("DateTime", "Date");
typeMapping.put("boolean", "Bool");
typeMapping.put("string", "String");
typeMapping.put("char", "Character");
typeMapping.put("short", "Int");
typeMapping.put("int", "Int");
typeMapping.put("long", "Int64");
typeMapping.put("integer", "Int");
typeMapping.put("Integer", "Int");
typeMapping.put("float", "Float");
typeMapping.put("number", "Double");
typeMapping.put("double", "Double");
typeMapping.put("file", "URL");
typeMapping.put("binary", "URL");
typeMapping.put("ByteArray", "Data");
typeMapping.put("UUID", "UUID");
typeMapping.put("URI", "String");
typeMapping.put("decimal", "Decimal");
typeMapping.put("object", "AnyCodable");
typeMapping.put("AnyType", "AnyCodable");
importMapping = new HashMap<>();
cliOptions.add(new CliOption(PROJECT_NAME, "Project name in Xcode"));
cliOptions.add(new CliOption(RESPONSE_AS,
"Optionally use libraries to manage response. Currently "
+ StringUtils.join(RESPONSE_LIBRARIES, ", ")
+ " are available."));
cliOptions.add(new CliOption(CodegenConstants.NON_PUBLIC_API,
CodegenConstants.NON_PUBLIC_API_DESC
+ "(default: false)"));
cliOptions.add(new CliOption(OBJC_COMPATIBLE,
"Add additional properties and methods for Objective-C "
+ "compatibility (default: false)"));
cliOptions.add(new CliOption(POD_SOURCE, "Source information used for Podspec"));
cliOptions.add(new CliOption(CodegenConstants.POD_VERSION, "Version used for Podspec"));
cliOptions.add(new CliOption(POD_AUTHORS, "Authors used for Podspec"));
cliOptions.add(new CliOption(POD_SOCIAL_MEDIA_URL, "Social Media URL used for Podspec"));
cliOptions.add(new CliOption(POD_LICENSE, "License used for Podspec"));
cliOptions.add(new CliOption(POD_HOMEPAGE, "Homepage used for Podspec"));
cliOptions.add(new CliOption(POD_SUMMARY, "Summary used for Podspec"));
cliOptions.add(new CliOption(POD_DESCRIPTION, "Description used for Podspec"));
cliOptions.add(new CliOption(POD_SCREENSHOTS, "Screenshots used for Podspec"));
cliOptions.add(new CliOption(POD_DOCUMENTATION_URL,
"Documentation URL used for Podspec"));
cliOptions.add(new CliOption(READONLY_PROPERTIES, "Make properties "
+ "readonly (default: false)"));
cliOptions.add(new CliOption(SWIFT_USE_API_NAMESPACE,
"Flag to make all the API classes inner-class "
+ "of {{projectName}}API"));
cliOptions.add(new CliOption(CodegenConstants.HIDE_GENERATION_TIMESTAMP,
CodegenConstants.HIDE_GENERATION_TIMESTAMP_DESC)
.defaultValue(Boolean.TRUE.toString()));
cliOptions.add(new CliOption(LENIENT_TYPE_CAST,
"Accept and cast values for simple types (string->bool, "
+ "string->int, int->string)")
.defaultValue(Boolean.FALSE.toString()));
cliOptions.add(new CliOption(USE_BACKTICK_ESCAPES,
"Escape reserved words using backticks (default: false)")
.defaultValue(Boolean.FALSE.toString()));
cliOptions.add(new CliOption(GENERATE_MODEL_ADDITIONAL_PROPERTIES,
"Generate model additional properties (default: true)")
.defaultValue(Boolean.TRUE.toString()));
cliOptions.add(new CliOption(CodegenConstants.API_NAME_PREFIX, CodegenConstants.API_NAME_PREFIX_DESC));
cliOptions.add(new CliOption(USE_SPM_FILE_STRUCTURE, "Use SPM file structure"
+ " and set the source path to Sources" + File.separator + "{{projectName}} (default: false)."));
cliOptions.add(new CliOption(SWIFT_PACKAGE_PATH, "Set a custom source path instead of "
+ projectName + File.separator + "Classes" + File.separator + "OpenAPIs" + "."));
cliOptions.add(new CliOption(USE_CLASSES, "Use final classes for models instead of structs (default: false)")
.defaultValue(Boolean.FALSE.toString()));
cliOptions.add(new CliOption(HASHABLE_MODELS,
"Make hashable models (default: true)")
.defaultValue(Boolean.TRUE.toString()));
cliOptions.add(new CliOption(MAP_FILE_BINARY_TO_DATA,
"[WARNING] This option will be removed and enabled by default in the future once we've enhanced the code to work with `Data` in all the different situations. Map File and Binary to Data (default: false)")
.defaultValue(Boolean.FALSE.toString()));
supportedLibraries.put(LIBRARY_URLSESSION, "[DEFAULT] HTTP client: URLSession");
supportedLibraries.put(LIBRARY_ALAMOFIRE, "HTTP client: Alamofire");
supportedLibraries.put(LIBRARY_VAPOR, "HTTP client: Vapor");
CliOption libraryOption = new CliOption(CodegenConstants.LIBRARY, "Library template (sub-template) to use");
libraryOption.setEnum(supportedLibraries);
libraryOption.setDefault(LIBRARY_URLSESSION);
cliOptions.add(libraryOption);
setLibrary(LIBRARY_URLSESSION);
}
private static CodegenModel reconcileProperties(CodegenModel codegenModel,
CodegenModel parentCodegenModel) {
// To support inheritance in this generator, we will analyze
// the parent and child models, look for properties that match, and remove
// them from the child models and leave them in the parent.
// Because the child models extend the parents, the properties
// will be available via the parent.
// Get the properties for the parent and child models
final List<CodegenProperty> parentModelCodegenProperties = parentCodegenModel.vars;
List<CodegenProperty> codegenProperties = codegenModel.vars;
codegenModel.allVars = new ArrayList<CodegenProperty>(codegenProperties);
codegenModel.parentVars = parentCodegenModel.allVars;
// Iterate over all of the parent model properties
boolean removedChildProperty = false;
for (CodegenProperty parentModelCodegenProperty : parentModelCodegenProperties) {
// Now that we have found a prop in the parent class,
// and search the child class for the same prop.
Iterator<CodegenProperty> iterator = codegenProperties.iterator();
while (iterator.hasNext()) {
CodegenProperty codegenProperty = iterator.next();
if (codegenProperty.baseName.equals(parentModelCodegenProperty.baseName)) {
// We found a property in the child class that is
// a duplicate of the one in the parent, so remove it.
iterator.remove();
removedChildProperty = true;
}
}
}
if (removedChildProperty) {
codegenModel.vars = codegenProperties;
}
return codegenModel;
}
@Override
public CodegenType getTag() {
return CodegenType.CLIENT;
}
@Override
public String getName() {
return "swift5";
}
@Override
public String getHelp() {
return "Generates a Swift 5.x client library.";
}
@Override
protected void addAdditionPropertiesToCodeGenModel(CodegenModel codegenModel,
Schema schema) {
final Schema additionalProperties = getAdditionalProperties(schema);
if (additionalProperties != null) {
Schema inner = null;
if (ModelUtils.isArraySchema(schema)) {
ArraySchema ap = (ArraySchema) schema;
inner = ap.getItems();
} else if (ModelUtils.isMapSchema(schema)) {
inner = getAdditionalProperties(schema);
}
codegenModel.additionalPropertiesType = inner != null ? getTypeDeclaration(inner) : getSchemaType(additionalProperties);
}
}
@Override
public void processOpts() {
super.processOpts();
if (StringUtils.isEmpty(System.getenv("SWIFT_POST_PROCESS_FILE"))) {
LOGGER.info("Environment variable SWIFT_POST_PROCESS_FILE not defined so the Swift code may not be properly formatted. To define it, try 'export SWIFT_POST_PROCESS_FILE=/usr/local/bin/swiftformat' (Linux/Mac)");
LOGGER.info("NOTE: To enable file post-processing, 'enablePostProcessFile' must be set to `true` (--enable-post-process-file for CLI).");
}
// Setup project name
if (additionalProperties.containsKey(PROJECT_NAME)) {
setProjectName((String) additionalProperties.get(PROJECT_NAME));
} else {
additionalProperties.put(PROJECT_NAME, projectName);
}
sourceFolder = projectName + File.separator + sourceFolder;
// Setup nonPublicApi option, which generates code with reduced access
// modifiers; allows embedding elsewhere without exposing non-public API calls
// to consumers
if (additionalProperties.containsKey(CodegenConstants.NON_PUBLIC_API)) {
setNonPublicApi(convertPropertyToBooleanAndWriteBack(CodegenConstants.NON_PUBLIC_API));
}
additionalProperties.put(CodegenConstants.NON_PUBLIC_API, nonPublicApi);
// Setup objcCompatible option, which adds additional properties
// and methods for Objective-C compatibility
if (additionalProperties.containsKey(OBJC_COMPATIBLE)) {
setObjcCompatible(convertPropertyToBooleanAndWriteBack(OBJC_COMPATIBLE));
}
additionalProperties.put(OBJC_COMPATIBLE, objcCompatible);
// add objc reserved words
if (Boolean.TRUE.equals(objcCompatible)) {
reservedWords.addAll(objcReservedWords);
}
if (additionalProperties.containsKey(RESPONSE_AS)) {
Object responseAsObject = additionalProperties.get(RESPONSE_AS);
if (responseAsObject instanceof String) {
setResponseAs(((String) responseAsObject).split(","));
} else {
setResponseAs((String[]) responseAsObject);
}
}
additionalProperties.put(RESPONSE_AS, responseAs);
if (ArrayUtils.contains(responseAs, RESPONSE_LIBRARY_PROMISE_KIT)) {
additionalProperties.put("usePromiseKit", true);
}
if (ArrayUtils.contains(responseAs, RESPONSE_LIBRARY_RX_SWIFT)) {
additionalProperties.put("useRxSwift", true);
}
if (ArrayUtils.contains(responseAs, RESPONSE_LIBRARY_RESULT)) {
additionalProperties.put("useResult", true);
}
if (ArrayUtils.contains(responseAs, RESPONSE_LIBRARY_COMBINE)) {
additionalProperties.put("useCombine", true);
}
// Setup readonlyProperties option, which declares properties so they can only
// be set at initialization
if (additionalProperties.containsKey(READONLY_PROPERTIES)) {
setReadonlyProperties(convertPropertyToBooleanAndWriteBack(READONLY_PROPERTIES));
}
additionalProperties.put(READONLY_PROPERTIES, readonlyProperties);
// Setup swiftUseApiNamespace option, which makes all the API
// classes inner-class of {{projectName}}
if (additionalProperties.containsKey(SWIFT_USE_API_NAMESPACE)) {
setSwiftUseApiNamespace(convertPropertyToBooleanAndWriteBack(SWIFT_USE_API_NAMESPACE));
}
if (!additionalProperties.containsKey(POD_AUTHORS)) {
additionalProperties.put(POD_AUTHORS, DEFAULT_POD_AUTHORS);
}
if (additionalProperties.containsKey(USE_SPM_FILE_STRUCTURE)) {
setUseSPMFileStructure(convertPropertyToBooleanAndWriteBack(USE_SPM_FILE_STRUCTURE));
sourceFolder = "Sources" + File.separator + projectName;
}
if (additionalProperties.containsKey(SWIFT_PACKAGE_PATH) && ((String)additionalProperties.get(SWIFT_PACKAGE_PATH)).length() > 0) {
setSwiftPackagePath((String)additionalProperties.get(SWIFT_PACKAGE_PATH));
sourceFolder = swiftPackagePath;
}
if (additionalProperties.containsKey(USE_BACKTICK_ESCAPES)) {
setUseBacktickEscapes(convertPropertyToBooleanAndWriteBack(USE_BACKTICK_ESCAPES));
}
if (additionalProperties.containsKey(GENERATE_MODEL_ADDITIONAL_PROPERTIES)) {
setGenerateModelAdditionalProperties(convertPropertyToBooleanAndWriteBack(GENERATE_MODEL_ADDITIONAL_PROPERTIES));
}
additionalProperties.put(GENERATE_MODEL_ADDITIONAL_PROPERTIES, generateModelAdditionalProperties);
if (additionalProperties.containsKey(HASHABLE_MODELS)) {
setHashableModels(convertPropertyToBooleanAndWriteBack(HASHABLE_MODELS));
}
additionalProperties.put(HASHABLE_MODELS, hashableModels);
if (additionalProperties.containsKey(MAP_FILE_BINARY_TO_DATA)) {
setMapFileBinaryToData(convertPropertyToBooleanAndWriteBack(MAP_FILE_BINARY_TO_DATA));
}
additionalProperties.put(MAP_FILE_BINARY_TO_DATA, mapFileBinaryToData);
if (mapFileBinaryToData) {
typeMapping.put("file", "Data");
typeMapping.put("binary", "Data");
}
if (additionalProperties.containsKey(USE_CLASSES)) {
setUseClasses(convertPropertyToBooleanAndWriteBack(USE_CLASSES));
}
additionalProperties.put(USE_CLASSES, useClasses);
setLenientTypeCast(convertPropertyToBooleanAndWriteBack(LENIENT_TYPE_CAST));
// make api and model doc path available in mustache template
additionalProperties.put("apiDocPath", apiDocPath);
additionalProperties.put("modelDocPath", modelDocPath);
if (!getLibrary().equals(LIBRARY_VAPOR)) {
supportingFiles.add(new SupportingFile("Podspec.mustache",
"",
projectName + ".podspec"));
supportingFiles.add(new SupportingFile("Cartfile.mustache",
"",
"Cartfile"));
supportingFiles.add(new SupportingFile("CodableHelper.mustache",
sourceFolder,
"CodableHelper.swift"));
supportingFiles.add(new SupportingFile("OpenISO8601DateFormatter.mustache",
sourceFolder,
"OpenISO8601DateFormatter.swift"));
supportingFiles.add(new SupportingFile("JSONDataEncoding.mustache",
sourceFolder,
"JSONDataEncoding.swift"));
supportingFiles.add(new SupportingFile("JSONEncodingHelper.mustache",
sourceFolder,
"JSONEncodingHelper.swift"));
supportingFiles.add(new SupportingFile("git_push.sh.mustache",
"",
"git_push.sh"));
supportingFiles.add(new SupportingFile("SynchronizedDictionary.mustache",
sourceFolder,
"SynchronizedDictionary.swift"));
supportingFiles.add(new SupportingFile("XcodeGen.mustache",
"",
"project.yml"));
supportingFiles.add(new SupportingFile("APIHelper.mustache",
sourceFolder,
"APIHelper.swift"));
supportingFiles.add(new SupportingFile("Models.mustache",
sourceFolder,
"Models.swift"));
}
supportingFiles.add(new SupportingFile("Package.swift.mustache",
"",
"Package.swift"));
supportingFiles.add(new SupportingFile("Configuration.mustache",
sourceFolder,
"Configuration.swift"));
supportingFiles.add(new SupportingFile("Extensions.mustache",
sourceFolder,
"Extensions.swift"));
supportingFiles.add(new SupportingFile("APIs.mustache",
sourceFolder,
"APIs.swift"));
supportingFiles.add(new SupportingFile("gitignore.mustache",
"",
".gitignore"));
supportingFiles.add(new SupportingFile("README.mustache",
"",
"README.md"));
switch (getLibrary()) {
case LIBRARY_ALAMOFIRE:
additionalProperties.put("useAlamofire", true);
supportingFiles.add(new SupportingFile("AlamofireImplementations.mustache",
sourceFolder,
"AlamofireImplementations.swift"));
break;
case LIBRARY_URLSESSION:
additionalProperties.put("useURLSession", true);
supportingFiles.add(new SupportingFile("URLSessionImplementations.mustache",
sourceFolder,
"URLSessionImplementations.swift"));
break;
case LIBRARY_VAPOR:
additionalProperties.put("useVapor", true);
break;
default:
break;
}
}
public boolean isMapFileBinaryToData() {
return mapFileBinaryToData;
}
public void setMapFileBinaryToData(boolean mapFileBinaryToData) {
this.mapFileBinaryToData = mapFileBinaryToData;
}
@Override
protected boolean isReservedWord(String word) {
return word != null && reservedWords.contains(word); //don't lowercase as super does
}
@Override
public String escapeReservedWord(String name) {
if (this.reservedWordsMappings().containsKey(name)) {
return this.reservedWordsMappings().get(name);
}
return useBacktickEscapes && !objcCompatible ? "`" + name + "`" : "_" + name;
}
@Override
public String modelFileFolder() {
return outputFolder + File.separator + sourceFolder
+ modelPackage().replace('.', File.separatorChar);
}
@Override
public String apiFileFolder() {
return outputFolder + File.separator + sourceFolder
+ apiPackage().replace('.', File.separatorChar);
}
@Override
public String getTypeDeclaration(Schema p) {
if (ModelUtils.isArraySchema(p)) {
ArraySchema ap = (ArraySchema) p;
Schema inner = ap.getItems();
return ModelUtils.isSet(p) ? "Set<" + getTypeDeclaration(inner) + ">" : "[" + getTypeDeclaration(inner) + "]";
} else if (ModelUtils.isMapSchema(p)) {
Schema inner = getAdditionalProperties(p);
return "[String: " + getTypeDeclaration(inner) + "]";
}
return super.getTypeDeclaration(p);
}
@Override
public String getSchemaType(Schema p) {
String openAPIType = super.getSchemaType(p);
String type;
if (typeMapping.containsKey(openAPIType)) {
type = typeMapping.get(openAPIType);
if (languageSpecificPrimitives.contains(type) || defaultIncludes.contains(type)) {
return type;
}
} else {
type = openAPIType;
}
return toModelName(type);
}
@Override
public boolean isDataTypeFile(String dataType) {
return "URL".equals(dataType);
}
@Override
public boolean isDataTypeBinary(final String dataType) {
return "Data".equals(dataType);
}
/**
* Output the proper model name (capitalized).
*
* @param name the name of the model
* @return capitalized model name
*/
@Override
public String toModelName(String name) {
// FIXME parameter should not be assigned. Also declare it as "final"
name = sanitizeName(name);
if (!StringUtils.isEmpty(modelNameSuffix)) { // set model suffix
name = name + "_" + modelNameSuffix;
}
if (!StringUtils.isEmpty(modelNamePrefix)) { // set model prefix
name = modelNamePrefix + "_" + name;
}
// camelize the model name
// phone_number => PhoneNumber
name = camelize(name);
// model name cannot use reserved keyword, e.g. return
if (isReservedWord(name)) {
String modelName = "Model" + name;
LOGGER.warn("{} (reserved word) cannot be used as model name. Renamed to {}", name, modelName);
return modelName;
}
// model name starts with number
if (name.matches("^\\d.*")) {
// e.g. 200Response => Model200Response (after camelize)
String modelName = "Model" + name;
LOGGER.warn("{} (model name starts with number) cannot be used as model name. Renamed to {}", name,
modelName);
return modelName;
}
return name;
}
/**
* Return the capitalized file name of the model.
*
* @param name the model name
* @return the file name of the model
*/
@Override
public String toModelFilename(String name) {
// should be the same as the model name
return toModelName(name);
}
@Override
public String toDefaultValue(Schema p) {
if (p.getEnum() != null && !p.getEnum().isEmpty()) {
if (p.getDefault() != null) {
if (ModelUtils.isStringSchema(p)) {
return "." + toEnumVarName(escapeText((String) p.getDefault()), p.getType());
} else {
return "." + toEnumVarName(escapeText(p.getDefault().toString()), p.getType());
}
}
}
if (p.getDefault() != null) {
if (ModelUtils.isIntegerSchema(p) || ModelUtils.isNumberSchema(p) || ModelUtils.isBooleanSchema(p)) {
return p.getDefault().toString();
} else if (ModelUtils.isDateTimeSchema(p)) {
// Datetime time stamps in Swift are expressed as Seconds with Microsecond precision.
// In Java, we need to be creative to get the Timestamp in Microseconds as a long.
Instant instant = ((OffsetDateTime) p.getDefault()).toInstant();
long epochMicro = TimeUnit.SECONDS.toMicros(instant.getEpochSecond()) + (instant.get(ChronoField.MICRO_OF_SECOND));
return "Date(timeIntervalSince1970: " + String.valueOf(epochMicro) + ".0 / 1_000_000)";
} else if (ModelUtils.isStringSchema(p)) {
return "\"" + escapeText((String) p.getDefault()) + "\"";
}
// TODO: Handle more cases from `ModelUtils`, such as Date
}
return null;
}
@Override
public String toInstantiationType(Schema p) {
if (ModelUtils.isMapSchema(p)) {
return getSchemaType(getAdditionalProperties(p));
} else if (ModelUtils.isArraySchema(p)) {
ArraySchema ap = (ArraySchema) p;
String inner = getSchemaType(ap.getItems());
return ModelUtils.isSet(p) ? "Set<" + inner + ">" : "[" + inner + "]";
}
return null;
}
@Override
public String toApiName(String name) {
if (name.length() == 0) {
return "DefaultAPI";
}
return camelize(apiNamePrefix + "_" + name) + "API";
}
@Override
public String apiDocFileFolder() {
return (outputFolder + "/" + apiDocPath).replace("/", File.separator);
}
@Override
public String modelDocFileFolder() {
return (outputFolder + "/" + modelDocPath).replace("/", File.separator);
}
@Override
public String toModelDocFilename(String name) {
return toModelName(name);
}
@Override
public String toApiDocFilename(String name) {
return toApiName(name);
}
@Override
public String toOperationId(String operationId) {
operationId = camelize(sanitizeName(operationId), true);
// Throw exception if method name is empty.
// This should not happen but keep the check just in case
if (StringUtils.isEmpty(operationId)) {
throw new RuntimeException("Empty method name (operationId) not allowed");
}
// method name cannot use reserved keyword, e.g. return
if (isReservedWord(operationId)) {
String newOperationId = camelize(("call_" + operationId), true);
LOGGER.warn("{} (reserved word) cannot be used as method name. Renamed to {}", operationId, newOperationId);
return newOperationId;
}
// operationId starts with a number
if (operationId.matches("^\\d.*")) {
LOGGER.warn("{} (starting with a number) cannot be used as method name. Renamed to {}", operationId, camelize(sanitizeName("call_" + operationId), true));
operationId = camelize(sanitizeName("call_" + operationId), true);
}
return operationId;
}
@Override
public String toVarName(String name) {
// sanitize name
name = sanitizeName(name);
// if it's all upper case, do nothing
if (name.matches("^[A-Z_]*$")) {
return name;
}
// camelize the variable name
// pet_id => petId
name = camelize(name, true);
// for reserved words surround with `` or append _
if (isReservedWord(name)) {
name = escapeReservedWord(name);
}
// for words starting with number, append _
if (name.matches("^\\d.*")) {
name = "_" + name;
}
return name;
}
@Override
public String toParamName(String name) {
// sanitize name
name = sanitizeName(name);
// replace - with _ e.g. created-at => created_at
name = name.replaceAll("-", "_");
// if it's all upper case, do nothing
if (name.matches("^[A-Z_]*$")) {
return name;
}
// camelize(lower) the variable name
// pet_id => petId
name = camelize(name, true);
// for reserved words surround with ``
if (isReservedWord(name)) {
name = escapeReservedWord(name);
}
// for words starting with number, append _
if (name.matches("^\\d.*")) {
name = "_" + name;
}
return name;
}
@Override
public CodegenModel fromModel(String name, Schema model) {
Map<String, Schema> allDefinitions = ModelUtils.getSchemas(this.openAPI);
CodegenModel codegenModel = super.fromModel(name, model);
if (codegenModel.description != null) {
codegenModel.imports.add("ApiModel");
}
if (allDefinitions != null) {
String parentSchema = codegenModel.parentSchema;
// multilevel inheritance: reconcile properties of all the parents
while (parentSchema != null) {
final Schema parentModel = allDefinitions.get(parentSchema);
final CodegenModel parentCodegenModel = super.fromModel(codegenModel.parent,
parentModel);
codegenModel = Swift5ClientCodegen.reconcileProperties(codegenModel, parentCodegenModel);
// get the next parent
parentSchema = parentCodegenModel.parentSchema;
}
}
if (hashableModels) {
codegenModel.vendorExtensions.put("x-swift-hashable", true);
}
return codegenModel;
}
public void setProjectName(String projectName) {
this.projectName = projectName;
}
public void setNonPublicApi(boolean nonPublicApi) {
this.nonPublicApi = nonPublicApi;
}
public void setObjcCompatible(boolean objcCompatible) {
this.objcCompatible = objcCompatible;
}
public void setLenientTypeCast(boolean lenientTypeCast) {
this.lenientTypeCast = lenientTypeCast;
}
public void setReadonlyProperties(boolean readonlyProperties) {
this.readonlyProperties = readonlyProperties;
}
public void setResponseAs(String[] responseAs) {
this.responseAs = responseAs;
}
public void setSwiftUseApiNamespace(boolean swiftUseApiNamespace) {
this.swiftUseApiNamespace = swiftUseApiNamespace;
}
public void setUseSPMFileStructure(boolean useSPMFileStructure) {
this.useSPMFileStructure = useSPMFileStructure;
}
public void setSwiftPackagePath(String swiftPackagePath) {
this.swiftPackagePath = swiftPackagePath;
}
public void setUseClasses(boolean useClasses) {
this.useClasses = useClasses;
}
public void setUseBacktickEscapes(boolean useBacktickEscapes) {
this.useBacktickEscapes = useBacktickEscapes;
}
public void setGenerateModelAdditionalProperties(boolean generateModelAdditionalProperties) {
this.generateModelAdditionalProperties = generateModelAdditionalProperties;
}
public void setHashableModels(boolean hashableModels) {
this.hashableModels = hashableModels;
}
@Override
public String toEnumValue(String value, String datatype) {
// for string, array of string
if ("String".equals(datatype) || "[String]".equals(datatype) || "[String: String]".equals(datatype)) {
return "\"" + String.valueOf(value) + "\"";
} else {
return String.valueOf(value);
}
}
@Override
public String toEnumDefaultValue(String value, String datatype) {
return datatype + "_" + value;
}
@Override
public String toEnumVarName(String name, String datatype) {
if (name.length() == 0) {
return "empty";
}
Pattern startWithNumberPattern = Pattern.compile("^\\d+");
Matcher startWithNumberMatcher = startWithNumberPattern.matcher(name);
if (startWithNumberMatcher.find()) {
String startingNumbers = startWithNumberMatcher.group(0);
String nameWithoutStartingNumbers = name.substring(startingNumbers.length());
return "_" + startingNumbers + camelize(nameWithoutStartingNumbers, true);
}
// for symbol, e.g. $, #
if (getSymbolName(name) != null) {
return camelize(WordUtils.capitalizeFully(getSymbolName(name).toUpperCase(Locale.ROOT)), true);
}
// Camelize only when we have a structure defined below
Boolean camelized = false;
if (name.matches("[A-Z][a-z0-9]+[a-zA-Z0-9]*")) {
name = camelize(name, true);
camelized = true;
}
// Reserved Name
String nameLowercase = StringUtils.lowerCase(name);
if (isReservedWord(nameLowercase)) {
return escapeReservedWord(nameLowercase);
}
// Check for numerical conversions
if ("Int".equals(datatype) || "Int32".equals(datatype) || "Int64".equals(datatype)
|| "Float".equals(datatype) || "Double".equals(datatype)) {
String varName = "number" + camelize(name);
varName = varName.replaceAll("-", "minus");
varName = varName.replaceAll("\\+", "plus");
varName = varName.replaceAll("\\.", "dot");
return varName;
}
// If we have already camelized the word, don't progress
// any further
if (camelized) {
return name;
}
char[] separators = {'-', '_', ' ', ':', '(', ')'};
return camelize(WordUtils.capitalizeFully(StringUtils.lowerCase(name), separators)
.replaceAll("[-_ :\\(\\)]", ""),
true);
}
@Override
public String toEnumName(CodegenProperty property) {
String enumName = toModelName(property.name);
// Ensure that the enum type doesn't match a reserved word or
// the variable name doesn't match the generated enum type or the
// Swift compiler will generate an error
if (isReservedWord(property.datatypeWithEnum)
|| toVarName(property.name).equals(property.datatypeWithEnum)) {
enumName = property.datatypeWithEnum + "Enum";
}
// TODO: toModelName already does something for names starting with number,
// so this code is probably never called
if (enumName.matches("\\d.*")) { // starts with number
return "_" + enumName;
} else {
return enumName;
}
}
@Override
public Map<String, Object> postProcessModels(Map<String, Object> objs) {
Map<String, Object> postProcessedModelsEnum = postProcessModelsEnum(objs);
// We iterate through the list of models, and also iterate through each of the
// properties for each model. For each property, if:
//
// CodegenProperty.name != CodegenProperty.baseName
//
// then we set
//
// CodegenProperty.vendorExtensions["x-codegen-escaped-property-name"] = true
//
// Also, if any property in the model has x-codegen-escaped-property-name=true, then we mark:
//
// CodegenModel.vendorExtensions["x-codegen-has-escaped-property-names"] = true
//
List<Object> models = (List<Object>) postProcessedModelsEnum.get("models");
for (Object _mo : models) {
Map<String, Object> mo = (Map<String, Object>) _mo;
CodegenModel cm = (CodegenModel) mo.get("model");
boolean modelHasPropertyWithEscapedName = false;
for (CodegenProperty prop : cm.allVars) {
if (!prop.name.equals(prop.baseName)) {
prop.vendorExtensions.put("x-codegen-escaped-property-name", true);
modelHasPropertyWithEscapedName = true;
}
}
if (modelHasPropertyWithEscapedName) {
cm.vendorExtensions.put("x-codegen-has-escaped-property-names", true);
}
}
return postProcessedModelsEnum;
}
@Override
public void postProcessModelProperty(CodegenModel model, CodegenProperty property) {
super.postProcessModelProperty(model, property);
boolean isSwiftScalarType = property.isInteger || property.isLong || property.isFloat
|| property.isDouble || property.isBoolean;
if ((!property.required || property.isNullable) && isSwiftScalarType) {
// Optional scalar types like Int?, Int64?, Float?, Double?, and Bool?
// do not translate to Objective-C. So we want to flag those
// properties in case we want to put special code in the templates
// which provide Objective-C compatibility.
property.vendorExtensions.put("x-swift-optional-scalar", true);
}
}
@Override
public String escapeQuotationMark(String input) {
// remove " to avoid code injection
return input.replace("\"", "");
}
@Override
public String escapeUnsafeCharacters(String input) {
return input.replace("*/", "*_/").replace("/*", "/_*");
}
@Override
public void postProcessFile(File file, String fileType) {
if (file == null) {
return;
}
String swiftPostProcessFile = System.getenv("SWIFT_POST_PROCESS_FILE");
if (StringUtils.isEmpty(swiftPostProcessFile)) {
return; // skip if SWIFT_POST_PROCESS_FILE env variable is not defined
}
// only process files with swift extension
if ("swift".equals(FilenameUtils.getExtension(file.toString()))) {
String command = swiftPostProcessFile + " " + file.toString();
try {
Process p = Runtime.getRuntime().exec(command);
int exitValue = p.waitFor();
if (exitValue != 0) {
LOGGER.error("Error running the command ({}). Exit value: {}", command, exitValue);
} else {
LOGGER.info("Successfully executed: {}", command);
}
} catch (InterruptedException | IOException e) {
LOGGER.error("Error running the command ({}). Exception: {}", command, e.getMessage());
// Restore interrupted state
Thread.currentThread().interrupt();
}
}
}
@Override
public Map<String, Object> postProcessOperationsWithModels(Map<String, Object> objs, List<Object> allModels) {
Map<String, Object> objectMap = (Map<String, Object>) objs.get("operations");
HashMap<String, CodegenModel> modelMaps = new HashMap<String, CodegenModel>();
for (Object o : allModels) {
HashMap<String, Object> h = (HashMap<String, Object>) o;
CodegenModel m = (CodegenModel) h.get("model");
modelMaps.put(m.classname, m);
}
List<CodegenOperation> operations = (List<CodegenOperation>) objectMap.get("operation");
for (CodegenOperation operation : operations) {
for (CodegenParameter cp : operation.allParams) {
cp.vendorExtensions.put("x-swift-example", constructExampleCode(cp, modelMaps, new HashSet<String>()));
}
}
return objs;
}
public String constructExampleCode(CodegenParameter codegenParameter, HashMap<String, CodegenModel> modelMaps, Set<String> visitedModels) {
if (codegenParameter.isArray) { // array
return "[" + constructExampleCode(codegenParameter.items, modelMaps, visitedModels) + "]";
} else if (codegenParameter.isMap) { // TODO: map, file type
return "\"TODO\"";
} else if (languageSpecificPrimitives.contains(codegenParameter.dataType)) { // primitive type
if ("String".equals(codegenParameter.dataType) || "Character".equals(codegenParameter.dataType)) {
if (StringUtils.isEmpty(codegenParameter.example)) {
return "\"" + codegenParameter.example + "\"";
} else {
return "\"" + codegenParameter.paramName + "_example\"";
}
} else if ("Bool".equals(codegenParameter.dataType)) { // boolean
if (Boolean.parseBoolean(codegenParameter.example)) {
return "true";
} else {
return "false";
}
} else if ("URL".equals(codegenParameter.dataType)) { // URL
return "URL(string: \"https://example.com\")!";
} else if ("Data".equals(codegenParameter.dataType)) { // URL
return "Data([9, 8, 7])";
} else if ("Date".equals(codegenParameter.dataType)) { // date
return "Date()";
} else { // numeric
if (StringUtils.isEmpty(codegenParameter.example)) {
return codegenParameter.example;
} else {
return "987";
}
}
} else { // model
// look up the model
if (modelMaps.containsKey(codegenParameter.dataType)) {
if (visitedModels.contains(codegenParameter.dataType)) {
// recursive/self-referencing model, simply return nil to avoid stackoverflow
return "nil";
} else {
visitedModels.add(codegenParameter.dataType);
return constructExampleCode(modelMaps.get(codegenParameter.dataType), modelMaps, visitedModels);
}
} else {
//LOGGER.error("Error in constructing examples. Failed to look up the model " + codegenParameter.dataType);
return "TODO";
}
}
}
public String constructExampleCode(CodegenProperty codegenProperty, HashMap<String, CodegenModel> modelMaps, Set<String> visitedModels) {
if (codegenProperty.isArray) { // array
return "[" + constructExampleCode(codegenProperty.items, modelMaps, visitedModels) + "]";
} else if (codegenProperty.isMap) { // TODO: map, file type
return "\"TODO\"";
} else if (languageSpecificPrimitives.contains(codegenProperty.dataType)) { // primitive type
if ("String".equals(codegenProperty.dataType) || "Character".equals(codegenProperty.dataType)) {
if (StringUtils.isEmpty(codegenProperty.example)) {
return "\"" + codegenProperty.example + "\"";
} else {
return "\"" + codegenProperty.name + "_example\"";
}
} else if ("Bool".equals(codegenProperty.dataType)) { // boolean
if (Boolean.parseBoolean(codegenProperty.example)) {
return "true";
} else {
return "false";
}
} else if ("URL".equals(codegenProperty.dataType)) { // URL
return "URL(string: \"https://example.com\")!";
} else if ("Date".equals(codegenProperty.dataType)) { // date
return "Date()";
} else { // numeric
if (StringUtils.isEmpty(codegenProperty.example)) {
return codegenProperty.example;
} else {
return "123";
}
}
} else {
// look up the model
if (modelMaps.containsKey(codegenProperty.dataType)) {
if (visitedModels.contains(codegenProperty.dataType)) {
// recursive/self-referencing model, simply return nil to avoid stackoverflow
return "nil";
} else {
visitedModels.add(codegenProperty.dataType);
return constructExampleCode(modelMaps.get(codegenProperty.dataType), modelMaps, visitedModels);
}
} else {
//LOGGER.error("Error in constructing examples. Failed to look up the model " + codegenProperty.dataType);
return "\"TODO\"";
}
}
}
public String constructExampleCode(CodegenModel codegenModel, HashMap<String, CodegenModel> modelMaps, Set<String> visitedModels) {
String example;
example = codegenModel.name + "(";
List<String> propertyExamples = new ArrayList<>();
for (CodegenProperty codegenProperty : codegenModel.vars) {
propertyExamples.add(codegenProperty.name + ": " + constructExampleCode(codegenProperty, modelMaps, visitedModels));
}
example += StringUtils.join(propertyExamples, ", ");
example += ")";
return example;
}
@Override
public void postProcess() {
System.out.println("################################################################################");
System.out.println("# Thanks for using OpenAPI Generator. #");
System.out.println("# Please consider donation to help us maintain this project \uD83D\uDE4F #");
System.out.println("# https://opencollective.com/openapi_generator/donate #");
System.out.println("# #");
System.out.println("# swift5 generator is contributed by Bruno Coelho (https://github.com/4brunu). #");
System.out.println("# Please support his work directly via https://paypal.com/paypalme/4brunu \uD83D\uDE4F #");
System.out.println("################################################################################");
}
}
|
[
"\"SWIFT_POST_PROCESS_FILE\"",
"\"SWIFT_POST_PROCESS_FILE\""
] |
[] |
[
"SWIFT_POST_PROCESS_FILE"
] |
[]
|
["SWIFT_POST_PROCESS_FILE"]
|
java
| 1 | 0 | |
tests/test_http.py
|
import logging
import io
import pytest
import os
import json
from requests.adapters import Response
from http import HTTPStatus
from typing import Dict, Any
from unittest.mock import patch
from pypwext.pwlogging import PyPwExtLogger
from pypwext.errors import PyPwExtError, PyPwExtHTTPError
from pypwext.pwhttp import LambdaResponse, PyPwExtHTTPSession
from .test_logging import get_new_logger_name
def test_no_region_and_no_aws_regin_env_var_raises_error():
with pytest.raises(PyPwExtError):
with PyPwExtHTTPSession():
pass
def test_default_pypwext_http_session_produces_no_json_content_type_and_accept_headers():
try:
os.environ['AWS_REGION'] = 'eu-west-1'
with io.StringIO() as s:
logger = PyPwExtLogger(
service=get_new_logger_name(),
logger_handler=logging.StreamHandler(s),
level=logging.DEBUG
)
with PyPwExtHTTPSession(logger=logger, api_gateway_mapping=False) as http:
http.get(
'https://api.openaq.org/v1/cities',
params={'country': 'SE'},
verify=False
)
value = s.getvalue()
vd = json.loads(value.splitlines()[0])
assert '"url":"https://api.openaq.org/v1/cities?country=SE"' in value
assert '"Connection":"keep-alive"' in value
assert '"Content-Type":"application/json"' in value
assert '"status":200' in value
assert '"name":"openaq-api"' in value
assert f'"service":"{logger.service}"' in value
assert vd['message']['request']['headers']['Content-Type'] == 'application/json'
assert vd['message']['request']['headers']['Accept'] == 'application/json'
finally:
del os.environ['AWS_REGION']
def test_default_headers_are_merged_with_explicit_set():
try:
os.environ['AWS_REGION'] = 'eu-west-1'
with io.StringIO() as s:
logger = PyPwExtLogger(
service=get_new_logger_name(),
logger_handler=logging.StreamHandler(s),
level=logging.DEBUG
)
with PyPwExtHTTPSession(
logger=logger,
api_gateway_mapping=False,
headers={
'Content-Type': 'application/text',
'Accept': 'application/json'
}
) as http:
http.get(
'https://api.openaq.org/v1/cities',
params={'country': 'SE'},
headers={'Content-Type': 'application/json'},
verify=False
)
value = json.loads(s.getvalue().splitlines()[0])
headers = value['message']['request']['headers']
assert headers.get('Content-Type') == 'application/json'
assert headers.get('Accept') == 'application/json'
finally:
del os.environ['AWS_REGION']
@pytest.mark.skip(reason="must setup a lambda environment on github account")
def test_api_gateway_execute_adds_headers():
import requests
the_headers = None
def send(request, **kwargs):
nonlocal the_headers
the_headers = request.headers
try:
os.environ['AWS_REGION'] = 'eu-west-1'
os.environ['AWS_ACCESS_KEY_ID'] = 'test'
os.environ['AWS_SECRET_ACCESS_KEY'] = 'test'
with patch.object(
requests.sessions.Session, 'send', side_effect=send
):
with PyPwExtHTTPSession(api_gateway_mapping=False) as http:
http.get(
'https://abc123.execute-api.eu-west-1.amazonaws.com/dev/cities',
params={'country': 'SE'}
)
assert the_headers['x-amz-date'] is not None
assert 'Credential=test' in the_headers['Authorization']
assert 'SignedHeaders=host;x-amz-date' in the_headers['Authorization']
assert 'AWS4-HMAC-SHA256' in the_headers['Authorization']
assert 'Signature=' in the_headers['Authorization']
finally:
del os.environ['AWS_REGION']
del os.environ['AWS_ACCESS_KEY_ID']
del os.environ['AWS_SECRET_ACCESS_KEY']
def test_decorator_simple():
with PyPwExtHTTPSession(api_gateway_mapping=False) as http:
@http.method(url='https://api.openaq.org/v1/cities', params={'country': '{country}'}, verify_ssl=False)
def get_cities(country: str, response: Response = None) -> str:
if response.status_code == HTTPStatus.OK.value:
return response.text
else:
raise PyPwExtHTTPError(
code=response.status_code,
message=f'Failed to get cities from {country}'
)
value = get_cities(country='SE')
assert '{"country":"SE","name":"Västernorrland","city":"Västernorrland","count":81637329,"locations":2}' in value
def test_decorated_api_gw_auth():
import requests
the_headers = None
def send(request, **kwargs):
nonlocal the_headers
the_headers = request.headers
resp = requests.Response()
resp.status_code = 200
resp._content = f"message: {request.body.decode('utf-8')}".encode('utf-8')
resp.request = request
return resp
try:
os.environ['AWS_REGION'] = 'eu-west-1'
os.environ['AWS_ACCESS_KEY_ID'] = 'test'
os.environ['AWS_SECRET_ACCESS_KEY'] = 'test'
with patch.object(
requests.sessions.Session, 'send', side_effect=send
):
with PyPwExtHTTPSession() as http:
@http.method(
method='POST',
url='https://{gw_id}.execute-api.{AWS_REGION}.amazonaws.com/dev/cities',
params={'country': '{country}'},
body='body'
)
def do_http(gw_id: str, country: str, body: str, response: requests.Response = None) -> str:
"""Gets the cities from a specific country."""
return f'processed response: {response.text}'
value = do_http('abc123', 'SE', 'the body')
assert 'processed response: message: the body' in value
assert the_headers['x-amz-date'] is not None
assert 'Credential=test' in the_headers['Authorization']
assert 'SignedHeaders=host;x-amz-date' in the_headers['Authorization']
assert 'AWS4-HMAC-SHA256' in the_headers['Authorization']
assert 'Signature=' in the_headers['Authorization']
finally:
del os.environ['AWS_REGION']
del os.environ['AWS_ACCESS_KEY_ID']
del os.environ['AWS_SECRET_ACCESS_KEY']
@pytest.mark.skip(reason="must setup a lambda on other account to test it from GitHub Actions")
def test_decorator_lambda_func():
with PyPwExtHTTPSession(api_gateway_mapping=False) as http:
@http.method(
method='FUNC',
url='arn:aws:lambda:eu-west-1:<account>:function:mario-unit-test-function',
params={'country': '{country}'}
)
def get_cities(country: str, response: LambdaResponse = None) -> str:
if response.StatusCode == HTTPStatus.OK.value:
return response.payload_as_text()
else:
raise PyPwExtHTTPError(
code=response.StatusCode,
message=f'Failed to get cities from {country}',
details={
'error': response.payload_as_text()
}
)
try:
value = get_cities(country='SE')
except Exception as e:
value = e.details['error']
assert '{"country": "SE", "name": "Västernorrland", "city": "Västernorrland", "count": 81637329, "locations": 2}' in value
@pytest.mark.skip(reason="must setup a lambda on other account to test it from GitHub Actions")
def test_manual_lambda_func_invoke():
with PyPwExtHTTPSession(api_gateway_mapping=False) as http:
result = http.func(
url='mario-unit-test-function',
params={'country': 'SE'})
assert result.StatusCode == HTTPStatus.OK.value
assert '"city": "Västernorrland"' in result.payload_as_text()
@pytest.mark.skip(reason="must setup a lambda on other account to test it from GitHub Actions")
def test_decorator_lambda_func_partial_arn():
with PyPwExtHTTPSession(api_gateway_mapping=False) as http:
@http.method(
method='FUNC',
url='function:mario-unit-test-function',
params={'country': '{country}'}
)
def get_cities(country: str, response: LambdaResponse = None) -> str:
if response.StatusCode == HTTPStatus.OK.value:
return response.payload_as_text()
else:
raise PyPwExtHTTPError(
code=response.StatusCode,
message=f'Failed to get cities from {country}',
details={
'error': response.payload_as_text()
}
)
try:
value = get_cities(country='SE')
except Exception as e:
value = e.details['error']
assert '{"country": "SE", "name": "Västernorrland", "city": "Västernorrland", "count": 81637329, "locations": 2}' in value
@pytest.mark.skip(reason="must setup a lambda on other account to test it from GitHub Actions")
def test_decorator_lambda_event():
with PyPwExtHTTPSession(api_gateway_mapping=False) as http:
@http.method(
method='EVENT',
url='arn:aws:lambda:eu-west-1:<account>:function:mario-unit-test-function',
body='body'
)
def get_cities(body: Dict[str, Any], response: LambdaResponse = None) -> str:
if response.StatusCode == HTTPStatus.ACCEPTED.value:
return json.dumps(response.ResponseMetadata)
else:
raise PyPwExtHTTPError(
code=response.StatusCode,
message=f'Failed to get cities from {body}',
details={
'error': response.payload_as_text()
}
)
try:
value = get_cities({'country': 'SE'})
except Exception as e:
value = e.details['error']
assert ' "HTTPStatusCode": 202' in value
|
[] |
[] |
[
"AWS_ACCESS_KEY_ID",
"AWS_SECRET_ACCESS_KEY",
"AWS_REGION"
] |
[]
|
["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"]
|
python
| 3 | 0 | |
src/app.py
|
import os
import layout
import callbacks # layout needs to be defined before creating callbacks
import routes
import appserver
server = appserver.app.server
if __name__ == "__main__":
debug_mode = True if os.getenv("DEBUG", "false") == "true" else False
if debug_mode is True:
print(f"Initiating server. Debug mode enabled.")
# appserver.app.enable_dev_tools(debug=True)
else:
print(f"Initiating server.")
appserver.app.run_server(
debug=debug_mode,
host="0.0.0.0",
port=5000
)
|
[] |
[] |
[
"DEBUG"
] |
[]
|
["DEBUG"]
|
python
| 1 | 0 | |
art/test/138-duplicate-classes-check/src/FancyLoader.java
|
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
/**
* A class loader with atypical behavior: we try to load a private
* class implementation before asking the system or boot loader. This
* is used to create multiple classes with identical names in a single VM.
*
* If DexFile is available, we use that; if not, we assume we're not in
* Dalvik and instantiate the class with defineClass().
*
* The location of the DEX files and class data is dependent upon the
* test framework.
*/
public class FancyLoader extends ClassLoader {
/* this is where the "alternate" .class files live */
static final String CLASS_PATH = "classes-ex/";
/* this is the "alternate" DEX/Jar file */
static final String DEX_FILE = System.getenv("DEX_LOCATION") +
"/138-duplicate-classes-check-ex.jar";
/* on Dalvik, this is a DexFile; otherwise, it's null */
private Class mDexClass;
private Object mDexFile;
/**
* Construct FancyLoader, grabbing a reference to the DexFile class
* if we're running under Dalvik.
*/
public FancyLoader(ClassLoader parent) {
super(parent);
try {
mDexClass = parent.loadClass("dalvik.system.DexFile");
} catch (ClassNotFoundException cnfe) {
// ignore -- not running Dalvik
}
}
/**
* Finds the class with the specified binary name.
*
* We search for a file in CLASS_PATH or pull an entry from DEX_FILE.
* If we don't find a match, we throw an exception.
*/
protected Class<?> findClass(String name) throws ClassNotFoundException
{
if (mDexClass != null) {
return findClassDalvik(name);
} else {
return findClassNonDalvik(name);
}
}
/**
* Finds the class with the specified binary name, from a DEX file.
*/
private Class<?> findClassDalvik(String name)
throws ClassNotFoundException {
if (mDexFile == null) {
synchronized (FancyLoader.class) {
Constructor ctor;
/*
* Construct a DexFile object through reflection.
*/
try {
ctor = mDexClass.getConstructor(new Class[] {String.class});
} catch (NoSuchMethodException nsme) {
throw new ClassNotFoundException("getConstructor failed",
nsme);
}
try {
mDexFile = ctor.newInstance(DEX_FILE);
} catch (InstantiationException ie) {
throw new ClassNotFoundException("newInstance failed", ie);
} catch (IllegalAccessException iae) {
throw new ClassNotFoundException("newInstance failed", iae);
} catch (InvocationTargetException ite) {
throw new ClassNotFoundException("newInstance failed", ite);
}
}
}
/*
* Call DexFile.loadClass(String, ClassLoader).
*/
Method meth;
try {
meth = mDexClass.getMethod("loadClass",
new Class[] { String.class, ClassLoader.class });
} catch (NoSuchMethodException nsme) {
throw new ClassNotFoundException("getMethod failed", nsme);
}
try {
meth.invoke(mDexFile, name, this);
} catch (IllegalAccessException iae) {
throw new ClassNotFoundException("loadClass failed", iae);
} catch (InvocationTargetException ite) {
throw new ClassNotFoundException("loadClass failed",
ite.getCause());
}
return null;
}
/**
* Finds the class with the specified binary name, from .class files.
*/
private Class<?> findClassNonDalvik(String name)
throws ClassNotFoundException {
String pathName = CLASS_PATH + name + ".class";
//System.out.println("--- Fancy: looking for " + pathName);
File path = new File(pathName);
RandomAccessFile raf;
try {
raf = new RandomAccessFile(path, "r");
} catch (FileNotFoundException fnfe) {
throw new ClassNotFoundException("Not found: " + pathName);
}
/* read the entire file in */
byte[] fileData;
try {
fileData = new byte[(int) raf.length()];
raf.readFully(fileData);
} catch (IOException ioe) {
throw new ClassNotFoundException("Read error: " + pathName);
} finally {
try {
raf.close();
} catch (IOException ioe) {
// drop
}
}
/* create the class */
//System.out.println("--- Fancy: defining " + name);
try {
return defineClass(name, fileData, 0, fileData.length);
} catch (Throwable th) {
throw new ClassNotFoundException("defineClass failed", th);
}
}
/**
* Load a class.
*
* Normally a class loader wouldn't override this, but we want our
* version of the class to take precedence over an already-loaded
* version.
*
* We still want the system classes (e.g. java.lang.Object) from the
* bootstrap class loader.
*/
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
Class res;
/*
* 1. Invoke findLoadedClass(String) to check if the class has
* already been loaded.
*
* This doesn't change.
*/
res = findLoadedClass(name);
if (res != null) {
System.out.println("FancyLoader.loadClass: "
+ name + " already loaded");
if (resolve)
resolveClass(res);
return res;
}
/*
* 3. Invoke the findClass(String) method to find the class.
*/
try {
res = findClass(name);
if (resolve)
resolveClass(res);
}
catch (ClassNotFoundException e) {
// we couldn't find it, so eat the exception and keep going
}
/*
* 2. Invoke the loadClass method on the parent class loader. If
* the parent loader is null the class loader built-in to the
* virtual machine is used, instead.
*
* (Since we're not in java.lang, we can't actually invoke the
* parent's loadClass() method, but we passed our parent to the
* super-class which can take care of it for us.)
*/
res = super.loadClass(name, resolve); // returns class or throws
return res;
}
}
|
[
"\"DEX_LOCATION\""
] |
[] |
[
"DEX_LOCATION"
] |
[]
|
["DEX_LOCATION"]
|
java
| 1 | 0 | |
cvat/apps/engine/task.py
|
# Copyright (C) 2018 Intel Corporation
#
# SPDX-License-Identifier: MIT
import os
import sys
import rq
import shlex
import shutil
import tempfile
import requests
import re
import xml.etree.ElementTree as ET
from threading import Thread
from io import BytesIO
from PIL import Image
from traceback import print_exception
from ast import literal_eval
from .handle_file_s3 import copyFileToOSByThread, deleteFolder, getFileUrl, copyFileToOS, uploadFile, downloadFile, getBucketConnection
from .segmentation import process_watershed
import numpy as np
import urllib
import ssl
from imutils.video import FPS
import argparse
import imutils
import cv2
import threading
import time
import json
import errno
import skvideo.io
import mimetypes
_SCRIPT_DIR = os.path.realpath(os.path.dirname(__file__))
_MEDIA_MIMETYPES_FILE = os.path.join(_SCRIPT_DIR, "media.mimetypes")
mimetypes.init(files=[_MEDIA_MIMETYPES_FILE])
from cvat.apps.engine.models import StatusChoice
from cvat.apps.engine import formatter
import django_rq
from django.forms.models import model_to_dict
from django.conf import settings
from django.core import serializers
from django.db import transaction
from django.db.models import Max
from ffmpy import FFmpeg
from pyunpack import Archive
from distutils.dir_util import copy_tree
from collections import OrderedDict
from django.contrib.auth.models import User
from . import models
from .log import slogger
############################# Global Variables
TRACKER_THREADS = {}
############################# Low Level server API
@transaction.atomic
def create_empty(params):
"""Create empty directory structure for a new task, add it to DB."""
db_task = models.Task()
db_task.name = params['task_name']
db_task.bug_tracker = params['bug_tracker_link']
db_task.path = ""
db_task.size = 0
db_task.owner = params['owner']
db_task.project = models.Projects.objects.get(pk=params['project'])
db_task.assignee = User.objects.get(pk=params['assignee'])
db_task.save()
task_path = os.path.join(settings.DATA_ROOT, str(db_task.id))
db_task.set_task_dirname(task_path)
task_path = db_task.get_task_dirname()
if os.path.isdir(task_path):
shutil.rmtree(task_path)
os.mkdir(task_path)
upload_dir = db_task.get_upload_dirname()
os.makedirs(upload_dir)
output_dir = db_task.get_data_dirname()
os.makedirs(output_dir)
return db_task
def create(tid, params):
"""Schedule the task"""
q = django_rq.get_queue('default')
q.enqueue_call(func=_create_thread, args=(tid, params),
job_id="task.create/{}".format(tid))
def check(tid):
"""Check status of the scheduled task"""
response = {}
queue = django_rq.get_queue('default')
job = queue.fetch_job("task.create/{}".format(tid))
if job is None:
response = {"state": "unknown"}
elif job.is_failed:
response = {"state": "error", "stderr": "Could not create the task. " + job.exc_info }
elif job.is_finished:
destFile = r'/home/django/data/' + str(tid) + r'/data/xml/annotations.txt'
if os.path.exists(destFile):
with open(destFile, 'r') as f:
fileData = f.read()
response = {"state": "created", "annotationFile" : fileData, "tid" : tid}
else:
response = {"state": "created"}
else:
response = {"state": "started"}
if 'status' in job.meta:
response['status'] = job.meta['status']
return response
@transaction.atomic
def delete(tid):
"""Delete the task"""
db_task = models.Task.objects.select_for_update().get(pk=tid)
if db_task:
db_task.delete()
shutil.rmtree(db_task.get_task_dirname(), ignore_errors=True)
threads = deleteFolder(db_task.get_task_dirname())
for t in threads:
t.join()
else:
raise Exception("The task doesn't exist")
@transaction.atomic
def update(tid, labels, score, assignee):
"""Update labels for the task"""
db_task = models.Task.objects.select_for_update().get(pk=tid)
db_labels = list(db_task.label_set.prefetch_related('attributespec_set').all())
if (labels):
new_labels = _parse_labels(labels)
old_labels = _parse_db_labels(db_labels)
for label_name in new_labels:
if label_name in old_labels:
db_label = [l for l in db_labels if l.name == label_name][0]
for attr_name in new_labels[label_name]:
if attr_name in old_labels[label_name]:
db_attr = [attr for attr in db_label.attributespec_set.all()
if attr.get_name() == attr_name][0]
new_attr = new_labels[label_name][attr_name]
old_attr = old_labels[label_name][attr_name]
if new_attr['prefix'] != old_attr['prefix']:
raise Exception("new_attr['prefix'] != old_attr['prefix']")
if new_attr['type'] != old_attr['type']:
raise Exception("new_attr['type'] != old_attr['type']")
if set(old_attr['values']) - set(new_attr['values']):
raise Exception("set(old_attr['values']) - set(new_attr['values'])")
db_attr.text = "{}{}={}:{}".format(new_attr['prefix'],
new_attr['type'], attr_name, ",".join(new_attr['values']))
db_attr.save()
else:
db_attr = models.AttributeSpec()
attr = new_labels[label_name][attr_name]
db_attr.text = "{}{}={}:{}".format(attr['prefix'],
attr['type'], attr_name, ",".join(attr['values']))
db_attr.label = db_label
db_attr.save()
else:
db_label = models.Label()
db_label.name = label_name
db_label.task = db_task
db_label.save()
for attr_name in new_labels[label_name]:
db_attr = models.AttributeSpec()
attr = new_labels[label_name][attr_name]
db_attr.text = "{}{}={}:{}".format(attr['prefix'],
attr['type'], attr_name, ",".join(attr['values']))
db_attr.label = db_label
db_attr.save()
db_task.assignee = User.objects.get(pk=assignee)
# If score sent from the client is -1 it means there is no score because the project has_score attribute is set to true.
if (score != -1):
db_task.score = score
db_task.save()
@transaction.atomic
def updateProperties(tid, properties):
db_task = models.Task.objects.select_for_update().get(pk=tid)
newFrameProperties = _parse_frameproperties(properties)
for frameprop in newFrameProperties:
db_taskframespec = models.TaskFrameSpec()
db_taskframespec.task = db_task
db_framepropvals = models.FrameProperties.objects.get(prop=frameprop[0], value=frameprop[1], project__pk=db_task.project.pk)
db_taskframespec.propVal = db_framepropvals
if (models.TaskFrameSpec.objects.filter(task__id=db_task.id, propVal__id=db_framepropvals.id).count() == 0):
db_taskframespec.save()
def get_frame_path(tid, frame):
"""Read corresponding frame for the task"""
db_task = models.Task.objects.get(pk=tid)
path = _get_frame_path(frame, db_task.get_data_dirname())
return path
def get_frame_watershed_path(tid, frame):
"""Read corresponding frame for the task"""
db_task = models.Task.objects.get(pk=tid)
path = _get_frame_watershed_path(frame, db_task.get_data_dirname())
return path
def get(tid):
"""Get the task as dictionary of attributes"""
db_task = models.Task.objects.get(pk=tid)
if db_task:
db_labels = db_task.label_set.prefetch_related('attributespec_set').order_by('-pk').all()
im_meta_data = get_image_meta_cache(db_task)
attributes = {}
for db_label in db_labels:
attributes[db_label.id] = {}
for db_attrspec in db_label.attributespec_set.all():
attributes[db_label.id][db_attrspec.id] = db_attrspec.text
db_segments = list(db_task.segment_set.prefetch_related('job_set').all())
segment_length = max(db_segments[0].stop_frame - db_segments[0].start_frame + 1, 1)
job_indexes = []
for segment in db_segments:
db_job = segment.job_set.first()
job_indexes.append({
"job_id": db_job.id,
"max_shape_id": db_job.max_shape_id,
})
labels_colors = models.LabelDetails.objects.filter(labelType__label__in=[db_label.name for db_label in db_labels])
response = {
"status": db_task.status,
"spec": {
"labels": OrderedDict((db_label.id, db_label.name) for db_label in db_labels),
"attributes": attributes,
"segmentation": {label_color.labelType.label: {"color": label_color.color, "label_type_id": label_color.labelType.id} for label_color in labels_colors}
},
"size": db_task.size,
"taskid": db_task.id,
"name": db_task.name,
"mode": db_task.mode,
"segment_length": segment_length,
"jobs": job_indexes,
"overlap": db_task.overlap,
"z_orded": db_task.z_order,
"flipped": db_task.flipped,
"score": db_task.score,
"image_meta_data": im_meta_data,
}
else:
raise Exception("Cannot find the task: {}".format(tid))
return response
@transaction.atomic
def save_job_status(jid, status, user):
db_job = models.Job.objects.select_related("segment__task").select_for_update().get(pk = jid)
db_task = db_job.segment.task
status = StatusChoice(status)
slogger.job[jid].info('changing job status from {} to {} by an user {}'.format(db_job.status, str(status), user))
db_job.status = status.value
db_job.save()
db_segments = list(db_task.segment_set.prefetch_related('job_set').all())
db_jobs = [db_segment.job_set.first() for db_segment in db_segments]
if len(list(filter(lambda x: StatusChoice(x.status) == StatusChoice.ANNOTATION, db_jobs))) > 0:
db_task.status = StatusChoice.ANNOTATION
elif len(list(filter(lambda x: StatusChoice(x.status) == StatusChoice.VALIDATION, db_jobs))) > 0:
db_task.status = StatusChoice.VALIDATION
else:
db_task.status = StatusChoice.COMPLETED
db_task.save()
class CSRTTrackerThread(threading.Thread):
def __init__(self, data, base_dir, results):
threading.Thread.__init__(self)
self.data = data
self.base_dir = base_dir
self.results = results
self._stop_event = False
def stop(self):
self._stop_event = True
def stopped(self):
return self._stop_event
def run(self):
def _frame_path(frame, base_dir):
d1 = str(frame // 10000)
d2 = str(frame // 100)
path = os.path.join(d1, d2, str(frame) + '.jpg')
if base_dir:
path = os.path.join(base_dir, path)
return path
def _get_frame(currentFrame, base_dir):
# Download the requested frame
frame_path = _frame_path(currentFrame, base_dir)
downloadFile(settings.AWS_STORAGE_BUCKET_NAME, frame_path, frame_path)
return frame_path
tracker = cv2.TrackerCSRT_create()
currentFrame = self.data['frame']
frame_path = _get_frame(currentFrame, self.base_dir)
frame = cv2.imread(frame_path)
self.results[self.data['id']] = {'results': {}}
counter = 0
x = self.data['positions']['x']
y = self.data['positions']['y']
w = self.data['positions']['w']
h = self.data['positions']['h']
bbox = (x, y, w, h)
tracker.init(frame, bbox)
if os.environ.get('WITH_OS') == 'True':
os.remove(frame_path)
while ((not self.stopped()) and (counter < 10)):
currentFrame += 1
frame_path = _get_frame(currentFrame, self.base_dir)
frame = cv2.imread(frame_path)
if frame is None:
break
ok, bbox = tracker.update(frame)
if os.environ.get('WITH_OS') == 'True':
os.remove(frame_path)
(x, y, w, h) = [int(v) for v in bbox]
if (h == 0 and w == 0):
self.results[self.data['id']]['results'][currentFrame] = {'x': x, 'y': y, 'h': h, 'w': w}
break
self.results[self.data['id']]['results'][currentFrame] = {'x': x, 'y': y, 'h': h, 'w': w}
key = cv2.waitKey(1) & 0xFF
counter += 1
def track_shapes(data, tid):
base_dir='/home/django/data/%d/data' % (tid)
results = {}
shape = data['shapes'][0]
results[shape['id']] = {'results': {}}
thread = CSRTTrackerThread(shape, base_dir, results)
thread.start()
if tid not in TRACKER_THREADS:
TRACKER_THREADS[tid] = []
TRACKER_THREADS[tid].append(thread)
thread.join()
return results
def stop_tracking(tid):
for thread in TRACKER_THREADS[tid]:
thread.stop()
def download_vid(tid, currentTask):
base_dir = '/home/django/data/%d/data' % (tid)
vid_dir_path = os.path.join(base_dir, 'video')
if not os.path.isdir(vid_dir_path):
try:
os.mkdir(vid_dir_path)
except OSError as e:
if e.errno == errno.EEXIST:
os.remove(vid_dir_path)
os.mkdir(vid_dir_path)
if os.environ.get('WITH_OS') == 'True':
bucket = getBucketConnection()
for object_summary in bucket.objects.filter(Prefix=base_dir + "/video"):
currentTask["video path"] = object_summary.key
downloadFile(settings.AWS_STORAGE_BUCKET_NAME, currentTask["video path"], currentTask["video path"])
break
else:
currentTask["video path"] = os.path.join(vid_dir_path, os.listdir(vid_dir_path)[0])
currentTask["downloaded"] = True
currentTask["startedDownloading"] = False
def track_all_video(shape, currentTask):
vs = cv2.VideoCapture(currentTask["video path"].split("?")[0])
currentFrame = shape['frame']
vs.set(1, currentFrame)
box = (shape['positions']['x'], shape['positions']['y'], shape['positions']['h'], shape['positions']['w'])
ok, frame = vs.read()
# Add a tracker to each box in the frame
tracker = cv2.TrackerCSRT_create()
tracker.init(frame, box)
while not currentTask["shapes"][shape["id"]]["stopped"]:
currentFrame += 1
ok, frame = vs.read()
if frame is None:
break
ok, box = tracker.update(frame)
(x, y, h, w) = [int(v) for v in box]
if (h == 0 and w == 0):
break
# If the predicted position is lower than 0 the box is out of bounds.
xtl = x if x > 0 else 0
ytl = y if y > 0 else 0
# If the predicted position is greater than either the frame width or height the box is out of bounds.
xbr = shape["frameWidth"] if (x + w) > shape["frameWidth"] else (x + w)
ybr = shape["frameHeight"] if (y + h) > shape["frameHeight"] else (y + h)
currentTask["shapes"][shape["id"]]["positions"][currentFrame] = {"xtl": xtl, "ytl": ytl, "xbr": xbr, "ybr": ybr, "occluded": shape["occluded"], "z_order": shape["z_order"], "outside": shape["outside"]}
currentTask["shapes"][shape["id"]]["finished"] = True
def check_video_path(tid):
base_dir = '/home/django/data/%d/data' % (tid)
if os.environ.get('WITH_OS') == 'False':
return os.path.exists(base_dir + "/video")
else:
bucket = getBucketConnection()
objs = list(bucket.objects.filter(Prefix=base_dir + "/video"))
return len(objs) > 0
def watershed(tid, frame, draws, username):
frame_path = "/home/django/data/watershed/" + str(tid) + "/" + username + "/" + str(frame) + ".jpg"
watershed_path = get_frame_path(tid, frame).replace('.jpg', '_w.png')
cvImg = cv2.imread(frame_path)
print("start process")
overlay = process_watershed(cvImg, draws, tid, frame)
print("end process")
print("start save")
save_watershed_image(overlay, watershed_path)
print("end save")
# q = django_rq.get_queue('default')
# q.enqueue_call(func=save_watershed_matrix, args=(tid, frame, matrix),
# job_id="task/{}.frame/{}.save_matrix".format(tid, frame))
#result['polygons'] = polygons
#return result
def save_watershed_image(image, path):
im = Image.fromarray(image)
im.save(path)
def compress_matrix(matrix):
compressedMatrix = []
sequenceCount = 0
prevLabel = matrix[0][0]
# Each sequence (n elements) of label in matrix is reduced
# to array with 2 elements: [the label, n (sequence count)]
for currLabel in np.nditer(matrix):
if currLabel == prevLabel:
sequenceCount += 1
else:
compressedMatrix.append([prevLabel, sequenceCount])
sequenceCount = 1
prevLabel = currLabel
return compressedMatrix
def save_watershed_matrix(tid, frame, matrix):
db_task = models.Task.objects.get(pk=tid)
models.Watershed.objects.update_or_create(task=db_task, frame=frame, defaults={'task':db_task, 'frame':frame, 'watershed':compress_matrix(matrix)})
def save_paintings(tid, frame, paintings):
db_task = models.Task.objects.get(pk=tid)
models.Watershed.objects.update_or_create(task=db_task, frame=frame, defaults={'task':db_task, 'frame':frame, 'paintings':paintings})
def get_paintings(tid, frame):
db_task = models.Task.objects.get(pk=tid)
db_frame_paintings = models.Watershed.objects.filter(task=db_task, frame=frame).first()
if db_frame_paintings is None:
paintings = []
else:
paintings = db_frame_paintings.paintings
return paintings
def get_task_byjob(jid):
"""Get the task by the jobid"""
db_job = models.Job.objects.select_related("segment__task").get(id=jid)
if db_job:
db_segment = db_job.segment
db_task = db_segment.task
return get(db_task.id)
else:
raise Exception("Cannot find the job: {}".format(jid))
return {}
def get_job(jid):
"""Get the job as dictionary of attributes"""
db_job = models.Job.objects.select_related("segment__task").get(id=jid)
if db_job:
db_segment = db_job.segment
db_task = db_segment.task
im_meta_data = get_image_meta_cache(db_task)
# Truncate extra image sizes
if db_task.mode == 'annotation':
im_meta_data['original_size'] = im_meta_data['original_size'][db_segment.start_frame:db_segment.stop_frame + 1]
db_labels = db_task.label_set.prefetch_related('attributespec_set').order_by('-pk').all()
attributes = {}
for db_label in db_labels:
attributes[db_label.id] = {}
for db_attrspec in db_label.attributespec_set.all():
attributes[db_label.id][db_attrspec.id] = db_attrspec.text
framePropertiesDict = {"allProperties": {}, "keyframeSpec": {}}
# Get all of the task frame spec rows related to the requested task.
taskFrameSpecQuerySet = db_task.taskframespec_set.all()
# Save the prop name, value name, and relation id for each row in the database for the task in a dictionary
for taskFrameSpec in taskFrameSpecQuerySet:
propName = taskFrameSpec.propVal.prop
valName = taskFrameSpec.propVal.value
propValId = taskFrameSpec.propVal.pk
# If the propName is not in the dictionary yet, add an empty dictionary to it
if (propName not in framePropertiesDict["allProperties"]):
framePropertiesDict["allProperties"][propName] = {}
framePropertiesDict["allProperties"][propName][valName] = propValId
keyframes = taskFrameSpec.keyframespec_set.all()
for keyframe in keyframes:
frame = keyframe.frame
if (frame not in framePropertiesDict["keyframeSpec"]):
framePropertiesDict["keyframeSpec"][frame] = {}
framePropertiesDict["keyframeSpec"][frame][propName] = propValId
labels_colors = models.LabelDetails.objects.filter(labelType__label__in=[db_label.name for db_label in db_labels])
commentsList = list(models.Comments.objects.filter(task=db_task).values_list('frame', 'comment'))
comments = {}
for comment in commentsList:
comments[comment[0]] = comment[1]
project = serializers.serialize('json', [db_task.project])
response = {
"status": db_job.status,
"labels": OrderedDict((db_label.id, db_label.name) for db_label in db_labels),
"frameProperties": framePropertiesDict,
"comments": comments,
"segmentation": {label_color.labelType.label: {"color": label_color.color, "label_type_id": label_color.labelType.id} for label_color in labels_colors},
"stop": db_segment.stop_frame,
"taskid": db_task.id,
"slug": db_task.name,
"jobid": jid,
"start": db_segment.start_frame,
"mode": db_task.mode,
"overlap": db_task.overlap,
"attributes": attributes,
"z_order": db_task.z_order,
"flipped": db_task.flipped,
"score": db_task.score,
"project": project,
"image_meta_data": im_meta_data,
"max_shape_id": db_job.max_shape_id,
"current": models.Task.objects.get(pk=db_task.id).last_viewed_frame, # db_task.last_viewed_frame returns the previous value from the database
}
else:
raise Exception("Cannot find the job: {}".format(jid))
return response
@transaction.atomic
def rq_handler(job, exc_type, exc_value, traceback):
tid = job.id.split('/')[1]
db_task = models.Task.objects.select_for_update().get(pk=tid)
with open(db_task.get_log_path(), "wt") as log_file:
print_exception(exc_type, exc_value, traceback, file=log_file)
db_task.delete()
return False
def nextJobIdByPriority(username, status, tid):
project = models.Task.objects.get(pk=tid).project
if not username == "staff_user":
currentUser = User.objects.get(username=username)
opened_tasks = models.Task.objects.filter(project=project, assignee=currentUser, status=status)
else:
currentUser = username
opened_tasks = models.Task.objects.filter(project=project, status=status)
if opened_tasks.exists():
max_score = opened_tasks.aggregate(maxscore=Max('score'))['maxscore']
if currentUser == "staff_user":
highest_priority_task = models.Task.objects.filter(project=project, status=status, score=max_score)
else:
highest_priority_task = models.Task.objects.filter(project=project, assignee=currentUser, status=status, score=max_score)
return models.Job.objects.get(segment__task=highest_priority_task[0]).id
else:
return "No task found"
############################# Internal implementation for server API
def _make_image_meta_cache(db_task, sorted_filenames=None):
with open(db_task.get_image_meta_cache_path(), 'w') as meta_file:
cache = {
'original_size': []
}
if db_task.mode == 'interpolation':
frame_0_url = getFileUrl(get_frame_path(db_task.id, 0))
image = Image.open(frame_0_url)
cache['original_size'].append({
'width': image.size[0],
'height': image.size[1]
})
image.close()
else:
filenames = []
if sorted_filenames is None:
for root, _, files in os.walk(db_task.get_upload_dirname()):
fullnames = map(lambda f: os.path.join(root, f), files)
images = filter(lambda x: _get_mime(x) == 'image', fullnames)
filenames.extend(images)
filenames.sort()
else:
filenames = sorted_filenames
for image_path in filenames:
image = Image.open(image_path)
cache['original_size'].append({
'width': image.size[0],
'height': image.size[1]
})
image.close()
meta_file.write(str(cache))
def get_image_meta_cache(db_task):
try:
with open(db_task.get_image_meta_cache_path()) as meta_cache_file:
return literal_eval(meta_cache_file.read())
except Exception:
_make_image_meta_cache(db_task)
with open(db_task.get_image_meta_cache_path()) as meta_cache_file:
return literal_eval(meta_cache_file.read())
def _get_mime(name):
mime = mimetypes.guess_type(name)
mime_type = mime[0]
encoding = mime[1]
# zip, rar, tar, tar.gz, tar.bz2, 7z, cpio
supportedArchives = ['application/zip', 'application/x-rar-compressed',
'application/x-tar', 'application/x-7z-compressed', 'application/x-cpio',
'gzip', 'bzip2']
if mime_type is not None:
if mime_type.startswith('video'):
return 'video'
elif mime_type in supportedArchives or encoding in supportedArchives:
return 'archive'
elif mime_type.startswith('image'):
return 'image'
else:
return 'empty'
else:
if os.path.isdir(name):
return 'directory'
else:
return 'empty'
def _get_frame_path(frame, base_dir):
d1 = str(frame // 10000)
d2 = str(frame // 100)
path = os.path.join(d1, d2, str(frame) + '.jpg')
if base_dir:
path = os.path.join(base_dir, path)
return path
def _parse_frameproperties(frameproperties):
parsed_frameprops = []
for row in frameproperties:
if (row['parent'] != '#' and row['parent'] != '$$$'):
parsed_frameprops.append(row['original']['path'].split("/"))
return parsed_frameprops
def _get_frame_watershed_path(frame, base_dir):
d1 = str(frame // 10000)
d2 = str(frame // 100)
path = os.path.join(d1, d2, str(frame) + '_w.png')
if base_dir:
path = os.path.join(base_dir, path)
return path
def _parse_labels(labels):
parsed_labels = OrderedDict()
last_label = ""
for token in shlex.split(labels):
if token[0] != "~" and token[0] != "@":
if token in parsed_labels:
raise ValueError("labels string is not corect. " +
"`{}` label is specified at least twice.".format(token))
parsed_labels[token] = {}
last_label = token
else:
attr = models.parse_attribute(token)
attr['text'] = token
if not attr['type'] in ['checkbox', 'radio', 'number', 'text', 'select']:
raise ValueError("labels string is not corect. " +
"`{}` attribute has incorrect type {}.".format(
attr['name'], attr['type']))
values = attr['values']
if attr['type'] == 'checkbox': # <prefix>checkbox=name:true/false
if not (len(values) == 1 and values[0] in ['true', 'false']):
raise ValueError("labels string is not corect. " +
"`{}` attribute has incorrect value.".format(attr['name']))
elif attr['type'] == 'number': # <prefix>number=name:min,max,step
try:
if len(values) != 3 or float(values[2]) <= 0 or \
float(values[0]) >= float(values[1]):
raise ValueError
except ValueError:
raise ValueError("labels string is not correct. " +
"`{}` attribute has incorrect format.".format(attr['name']))
if attr['name'] in parsed_labels[last_label]:
raise ValueError("labels string is not corect. " +
"`{}` attribute is specified at least twice.".format(attr['name']))
parsed_labels[last_label][attr['name']] = attr
return parsed_labels
def _parse_db_labels(db_labels):
result = []
for db_label in db_labels:
result += [db_label.name]
result += [attr.text for attr in db_label.attributespec_set.all()]
return _parse_labels(" ".join(result))
'''
Count all files, remove garbage (unknown mime types or extra dirs)
'''
def _prepare_paths(source_paths, target_paths, storage):
counters = {
"image": 0,
"directory": 0,
"video": 0,
"archive": 0
}
share_dirs_mapping = {}
share_files_mapping = {}
if storage == 'local':
# Files were uploaded early. Remove trash if it exists. Count them.
for path in target_paths:
mime = _get_mime(path)
if mime in ['video', 'archive', 'image']:
counters[mime] += 1
else:
try:
os.remove(path)
except:
os.rmdir(path)
else:
# Files are available via mount share. Count them and separate dirs.
for source_path, target_path in zip(source_paths, target_paths):
mime = _get_mime(source_path)
if mime in ['directory', 'image', 'video', 'archive']:
counters[mime] += 1
if mime == 'directory':
share_dirs_mapping[source_path] = target_path
else:
share_files_mapping[source_path] = target_path
# Remove directories if other files from them exists in input paths
exclude = []
for dir_name in share_dirs_mapping.keys():
for patch in share_files_mapping.keys():
if dir_name in patch:
exclude.append(dir_name)
break
for excluded_dir in exclude:
del share_dirs_mapping[excluded_dir]
counters['directory'] = len(share_dirs_mapping.keys())
return (counters, share_dirs_mapping, share_files_mapping)
'''
Check file set on valid
Valid if:
1 video, 0 images and 0 dirs (interpolation mode)
1 archive, 0 images and 0 dirs (annotation mode)
Many images or many dirs with images (annotation mode), 0 archives and 0 videos
'''
def _valid_file_set(counters):
if (counters['image'] or counters['directory']) and (counters['video'] or counters['archive']):
return False
elif counters['video'] > 1 or (counters['video'] and (counters['archive'] or counters['image'] or counters['directory'])):
return False
elif counters['archive'] > 1 or (counters['archive'] and (counters['video'] or counters['image'] or counters['directory'])):
return False
return True
'''
Copy data from share to local
'''
def _copy_data_from_share(share_files_mapping, share_dirs_mapping):
for source_path in share_dirs_mapping:
copy_tree(source_path, share_dirs_mapping[source_path])
for source_path in share_files_mapping:
target_path = share_files_mapping[source_path]
target_dir = os.path.dirname(target_path)
if not os.path.exists(target_dir):
os.makedirs(target_dir)
shutil.copyfile(source_path, target_path)
'''
Find and unpack archive in upload dir
'''
def _find_and_unpack_archive(upload_dir):
archive = None
for root, _, files in os.walk(upload_dir):
fullnames = map(lambda f: os.path.join(root, f), files)
archives = list(filter(lambda x: _get_mime(x) == 'archive', fullnames))
if len(archives):
archive = archives[0]
break
if archive:
Archive(archive).extractall(upload_dir)
os.remove(archive)
else:
raise Exception('Type defined as archive, but archives were not found.')
return archive
'''
Search a video in upload dir and split it by frames. Copy frames to target dirs
'''
def _find_and_extract_video(upload_dir, output_dir, db_task, job):
video = None
for root, _, files in os.walk(upload_dir):
fullnames = map(lambda f: os.path.join(root, f), files)
videos = list(filter(lambda x: _get_mime(x) == 'video', fullnames))
if len(videos):
video = videos[0]
break
if video:
job.meta['status'] = 'Video is being extracted..'
job.save_meta()
_dir, vid_name = os.path.split(video)
uploadFile(video, os.path.join(output_dir, 'video', vid_name))
frame_count = extract_frames(video, output_dir)
db_task.size += frame_count
else:
raise Exception("Video files were not found")
return video
def count_frames(path):
video = cv2.VideoCapture(path)
total = 0
# Try to count the frames using opencv property.
# If opencv can't count the frames, count them manually.
try:
# VieoCapture.get returns float value, so we need to convert it to int.
total = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
except:
total = count_frames_manual(video)
video.release()
return total
def count_frames_manual(video):
total = 0
# frameExists is a boolean returned from read that indicates wether or not
# a frame was read.
(frameExists, _) = video.read()
# Continue to iterate over the video frames until the end of the video.
while frameExists:
total += 1
# video.read() is a function that advances the pointer of the video and
# returns wether or not the frame exists and the frame itself.
(frameExists, _) = video.read()
return total
def get_meta_data(source_path):
meta_data = skvideo.io.ffprobe(source_path)['video']
if '@nb_frames' not in meta_data:
meta_data['@nb_frames'] = count_frames(source_path)
return meta_data
def extract_frames(source_path, output_dir):
count = 0
threads = []
output = tempfile.mkdtemp(prefix='cvat-', suffix='.data')
target_path = os.path.join(output, '%d.jpg')
LocalImagesPath = target_path
# create a folder for this video and for entire dataser (if doesnt exist)
_dir, vid_name = os.path.split(source_path)
name = os.path.splitext(vid_name)[0]
save_dir = os.path.abspath(os.path.join(LocalImagesPath, name))
os.makedirs(save_dir)
# Parse the video
for frame_count, frame in protected_reader(source_path):
if frame is not False:
img_path = os.path.join(save_dir, str(frame_count) + 'jpg')
#Remove combing lines effect from image
deint_image = deinterlace(frame)
cv2.imwrite(img_path, deint_image[:, :,::-1]) # save image (cv2 uses BGR color channels so reverse)
image_dest_path = _get_frame_path(frame_count, output_dir)
count += 1
dirname = os.path.dirname(image_dest_path)
if not os.path.exists(dirname):
os.makedirs(dirname)
t = copyFileToOSByThread(img_path, image_dest_path)
t.start()
threads.append(t)
else:
break
threads = [t for t in threads if t.isAlive()]
for t in threads:
t.join()
return count
def protected_reader(src_path, max_frames=None):
"""A wrapper reader for skvideo.io.FFmpegReader to avoid crashing on a RuntimeError exception.
:param src_path: Path to the video file to be read.
:param max_frames: (default=None) Number of frames to read. If left as None will attempt to read the entire video.
:return: A tuple of frame_count, frame
"""
frame, reader, count = False, None, 0
metadata = get_meta_data(src_path)
if max_frames is None:
max_frames = metadata['@nb_frames']
video_codec = metadata['@codec_name']
reader = skvideo.io.FFmpegReader(filename=src_path, inputdict={'-vcodec': video_codec})
gen = reader.nextFrame()
while count < int(max_frames):
try:
frame = gen.__next__()
except Exception:
frame = False
reader.close()
finally:
yield count, frame
count += 1
try:
reader.close()
except Exception:
pass
def deinterlace(image):
interpolation = cv2.INTER_LINEAR # cv2.INTER_NEAREST - fast, looks ok for tagging | cv2.INTER_LINEAR - slower, looks good
# if sample of image and tags
h, w, c = image.shape
# cut image in half
temp = image[::2, :, :] if h % 2 == 0 else image[:h-1:2, :, :]
return cv2.resize(temp, (w, h), interpolation=interpolation)
'''
Recursive search for all images in upload dir and compress it to RGB jpg with specified quality. Create symlinks for them.
'''
def _find_and_compress_images(upload_dir, output_dir, db_task, compress_quality, flip_flag, job):
filenames = []
for root, _, files in os.walk(upload_dir):
fullnames = map(lambda f: os.path.join(root, f), files)
images = filter(lambda x: _get_mime(x) == 'image', fullnames)
filenames.extend(images)
filenames.sort()
_make_image_meta_cache(db_task, filenames)
if len(filenames):
for idx, name in enumerate(filenames):
job.meta['status'] = 'Images are being compressed.. {}%'.format(idx * 100 // len(filenames))
job.save_meta()
compressed_name = os.path.splitext(name)[0] + '.jpg'
image = Image.open(name).convert('RGB')
if flip_flag:
image = image.transpose(Image.ROTATE_180)
image.save(compressed_name, quality=compress_quality, optimize=True)
image.close()
if compressed_name != name:
os.remove(name)
# PIL::save uses filename in order to define image extension.
# We need save it as jpeg for compression and after rename the file
# Else annotation file will contain invalid file names (with other extensions)
os.rename(compressed_name, name)
threads = []
for frame, image_orig_path in enumerate(filenames):
image_dest_path = _get_frame_path(frame, output_dir)
image_orig_path = os.path.abspath(image_orig_path)
db_task.size += 1
dirname = os.path.dirname(image_dest_path)
if not os.path.exists(dirname):
os.makedirs(dirname)
os.rename(image_orig_path, image_dest_path)
t = copyFileToOSByThread(image_orig_path, image_dest_path)
t.start()
threads.append(t)
threads = [t for t in threads if t.isAlive()]
for t in threads:
t.join()
else:
raise Exception("Image files were not found")
return filenames
def _save_task_to_db(db_task, task_params):
db_task.overlap = min(db_task.size, task_params['overlap'])
db_task.mode = task_params['mode']
db_task.z_order = task_params['z_order']
db_task.flipped = task_params['flip']
db_task.score = task_params['score'] and task_params['score'] or 0 # Set to task_params['score'] unless its undefined, then 0.
db_task.video_id = task_params['video_id']
db_task.source = task_params['data']
segment_step = task_params['segment'] - db_task.overlap
for x in range(0, db_task.size, segment_step):
start_frame = x
stop_frame = min(x + task_params['segment'] - 1, db_task.size - 1)
slogger.glob.info("New segment for task #{}: start_frame = {}, \
stop_frame = {}".format(db_task.id, start_frame, stop_frame))
db_segment = models.Segment()
db_segment.task = db_task
db_segment.start_frame = start_frame
db_segment.stop_frame = stop_frame
db_segment.save()
db_job = models.Job()
db_job.segment = db_segment
db_job.save()
parsed_frameprops = _parse_frameproperties(task_params['frame_properties'])
for frameprop in parsed_frameprops:
db_taskframespec = models.TaskFrameSpec()
db_taskframespec.task = db_task
db_framepropvals = models.FrameProperties.objects.get(prop=frameprop[0], value=frameprop[1], project__pk=db_task.project.pk)
db_taskframespec.propVal = db_framepropvals
db_taskframespec.save()
parsed_labels = _parse_labels(task_params['labels'])
for label in parsed_labels:
db_label = models.Label()
db_label.task = db_task
db_label.name = label
db_label.save()
for attr in parsed_labels[label]:
db_attrspec = models.AttributeSpec()
db_attrspec.label = db_label
db_attrspec.text = parsed_labels[label][attr]['text']
db_attrspec.save()
db_task.save()
def _save_paths_to_db(task, files):
count = 0
for currFile in files:
db_task_source = models.TaskSource()
db_task_source.task = task
db_task_source.source_name = currFile
db_task_source.frame = count
count+=1
db_task_source.save()
def parseTxtToXml(fileData, taskId):
try:
# Getting image size
frame_0_url = getFileUrl(get_frame_path(taskId, 0))
width, height = Image.open(frame_0_url).size
except Exception:
raise ex
return (formatter.parse_format(fileData, frame_0_url, width, height))
@transaction.atomic
def _create_thread(tid, params):
def raise_exception(images, dirs, videos, archives):
raise Exception('Only one archive, one video or many images can be dowloaded simultaneously. \
{} image(s), {} dir(s), {} video(s), {} archive(s) found'.format(images, dirs, videos, archives))
slogger.glob.info("create task #{}".format(tid))
job = rq.get_current_job()
db_task = models.Task.objects.select_for_update().get(pk=tid)
upload_dir = db_task.get_upload_dirname()
output_dir = db_task.get_data_dirname()
counters, share_dirs_mapping, share_files_mapping = _prepare_paths(
params['SOURCE_PATHS'],
params['TARGET_PATHS'],
params['storage']
)
if (not _valid_file_set(counters)):
raise Exception('Only one archive, one video or many images can be dowloaded simultaneously. \
{} image(s), {} dir(s), {} video(s), {} archive(s) found'.format(
counters['image'],
counters['directory'],
counters['video'],
counters['archive']
)
)
archive = None
if counters['archive']:
job.meta['status'] = 'Archive is being unpacked..'
job.save_meta()
archive = _find_and_unpack_archive(upload_dir)
# Define task mode and other parameters
task_video_id = -1
print(params)
task_score = params['score']
if 'video_id' in params:
task_video_id = params['video_id']
task_params = {
'mode': 'annotation' if counters['image'] or counters['directory'] or counters['archive'] else 'interpolation',
'flip': params['flip_flag'].lower() == 'true',
'score': task_score,
'video_id': task_video_id,
'z_order': params['z_order'].lower() == 'true',
'compress': int(params.get('compress_quality', 50)),
'segment': int(sys.maxsize),
'labels': params['labels'],
'frame_properties': json.loads(params['frame_properties'])
}
task_params['overlap'] = int(params.get('overlap_size', 5 if task_params['mode'] == 'interpolation' else 0))
slogger.glob.info("Task #{} parameters: {}".format(tid, task_params))
files = []
if task_params['mode'] == 'interpolation':
video = _find_and_extract_video(upload_dir, output_dir, db_task, job)
task_params['data'] = os.path.relpath(video, upload_dir)
else:
files =_find_and_compress_images(upload_dir, output_dir, db_task,
task_params['compress'], task_params['flip'], job)
if archive:
task_params['data'] = os.path.relpath(archive, upload_dir)
else:
task_params['data'] = '{} images: {}, ...'.format(len(files),
", ".join([os.path.relpath(x, upload_dir) for x in files[0:2]]))
slogger.glob.info("Founded frames {} for task #{}".format(db_task.size, tid))
task_params['segment'] = db_task.size + 10
job.meta['status'] = 'Task is being saved in database'
job.save_meta()
try:
_save_task_to_db(db_task, task_params)
if task_params['mode'] == 'annotation':
# add sources paths to db
_save_paths_to_db(db_task, params['SOURCE_PATHS'])
# Parsing taggs file
if params['storage'] == 'share':
txt = parseTxtToXml(upload_dir, db_task.id)
destDir = r'/home/django/data/' + str(db_task.id) + r'/data/xml/'
os.makedirs(destDir)
with open(destDir + r'annotations.txt', 'w') as annotationFile:
annotationFile.write(txt)
except Exception:
pass
finally:
# Deleting upload dir
shutil.rmtree(upload_dir)
|
[] |
[] |
[
"WITH_OS"
] |
[]
|
["WITH_OS"]
|
python
| 1 | 0 | |
simple_recipes/db/__init__.py
|
from psycopg2 import sql, connect
import psycopg2.extras
import os
from simple_recipes import app
def get_connection():
DATABASE_URL = None
if app.config['ENV'] == 'development':
DATABASE_URL = app.config['DATABASE_URL']
elif 'DATABASE_URL' in os.environ:
DATABASE_URL = os.environ['DATABASE_URL']
else:
DATABASE_URL = 'host=localhost port=5433 dbname=recipes user=postgres password=admin'
return connect(DATABASE_URL)
def get_cursor(cn):
return cn.cursor(cursor_factory = psycopg2.extras.DictCursor)
def get_table_names():
table_names = []
statement = sql.SQL( "SELECT table_name "
"FROM information_schema.tables "
"WHERE "
"table_schema = 'public' "
"AND table_type = 'BASE TABLE'")
with get_connection() as cn:
with get_cursor(cn) as cur:
cur.execute(statement)
for record in cur:
table_names.append(record[0])
return table_names
def get_table_counts():
table_names = get_table_names()
select_template = sql.SQL( "SELECT "
"{table_as_literal}, "
"COUNT(*) "
"FROM {table_as_identifier}")
table_statements = [select_template.format(
table_as_literal = sql.Literal(s),
table_as_identifier = sql.Identifier(s))
for s in table_names]
statement = sql.SQL(" UNION ALL ").join(table_statements)
with get_connection() as cn:
with cn.cursor() as cur:
cur.execute(statement)
return cur.fetchall()
|
[] |
[] |
[
"DATABASE_URL"
] |
[]
|
["DATABASE_URL"]
|
python
| 1 | 0 | |
f1.py
|
#!/usr/bin/env python3
import argparse
import os
import http.server
import socketserver
import requests
# Arguments parsing
parser = argparse.ArgumentParser(
description="Expose acestreams from morningstreams in you local network.",
epilog="Source code: https://github.com/S1M0N38/morningstreams",
)
parser.add_argument(
"--ip",
default="127.0.0.1",
help="ip where the m3u8 will be exposed",
)
parser.add_argument(
"--port",
default=8080,
help="port where the m3u8 will be exposed",
)
parser.add_argument(
"--username",
default=os.getenv("MORNINGSTREAMS_USERNAME"),
help="your morningstreams username",
)
parser.add_argument(
"--password",
default=os.getenv("MORNINGSTREAMS_PASSWORD"),
help="your morningstreams password",
)
args = parser.parse_args()
# Check if username and password are set
if not args.username or not args.password:
raise ValueError(
"""
morningstreams credentials are not provided.
Used the flags --username and --password or
export MORNINGSTREAMS_USERNAME and MORNINGSTREAMS_PASSWORD
environment variables."""
)
# Check if ACE stream Engine is running
try:
requests.get(f"http://{args.ip}:6878/webui/api/service")
except requests.exceptions.ConnectionError:
raise EnvironmentError("ACE stream engine is not running.")
# Login Morningstreams
login_url = "https://api.morningstreams.com/api/users/login"
credentials = {
"username": args.username,
"password": args.password,
"rememberMe": False,
}
response = requests.post(login_url, json=credentials)
assert response.json()["success"]
token = response.json()["token"]
# Update IP
update_id_url = "https://api.morningstreams.com/api/posts/update_ip"
headers = {"authorization": token}
ace_ip = {"aceIP": requests.get("https://wtfismyip.com/text").text.strip()}
response = requests.post(update_id_url, headers=headers, json=ace_ip)
assert response.json()["aceIP"] == ace_ip["aceIP"]
# ACE Stream
posts_url = "https://api.morningstreams.com/api/posts"
response = requests.get(posts_url, headers=headers)
m3u8 = "#EXTM3U\n"
for link in response.json():
try:
int(link["text"], 16) # check if is a acestream link
m3u8 += f'#EXTINF:-1,{link["title"]}\n'
m3u8 += f'http://{args.ip}:6878/ace/getstream?id={link["text"]}\n'
except ValueError:
pass
# Save links in m3u8 file
with open("playlist.m3u8", "w") as f:
f.write(m3u8)
# Spawn http server
address = ("", args.port)
httpd = socketserver.TCPServer(address, http.server.SimpleHTTPRequestHandler)
print(f"Starting httpd... http://{args.ip}:{args.port}/playlist.m3u8")
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass
httpd.server_close()
print("\nStopping httpd...")
|
[] |
[] |
[
"MORNINGSTREAMS_PASSWORD",
"MORNINGSTREAMS_USERNAME"
] |
[]
|
["MORNINGSTREAMS_PASSWORD", "MORNINGSTREAMS_USERNAME"]
|
python
| 2 | 0 | |
test/test_tcp_address.py
|
from asyncdbus import Message, MessageBus
from asyncdbus._private.address import parse_address
import anyio
import pytest
import os
@pytest.mark.anyio
async def test_tcp_connection_with_forwarding():
async with anyio.create_task_group() as tg:
closables = []
host = '127.0.0.1'
port = '55556'
addr_info = parse_address(os.environ.get('DBUS_SESSION_BUS_ADDRESS'))
assert addr_info
assert 'abstract' in addr_info[0][1]
path = f'\0{addr_info[0][1]["abstract"]}'
async def handle_connection(tcp_sock):
async with await anyio.connect_unix(path) as unix_sock:
async with anyio.create_task_group() as tg:
async def handle_read():
try:
while True:
data = await tcp_sock.receive()
await unix_sock.send(data)
except (anyio.ClosedResourceError, anyio.EndOfStream):
return
async def handle_write():
try:
while True:
data = await unix_sock.receive()
await tcp_sock.send(data)
except (anyio.ClosedResourceError, anyio.EndOfStream):
return
tg.spawn(handle_read)
tg.spawn(handle_write)
listener = await anyio.create_tcp_listener(local_port=port, local_host=host)
tg.spawn(listener.serve, handle_connection)
await anyio.sleep(0.1)
try:
async with MessageBus(bus_address=f'tcp:host={host},port={port}').connect() as bus:
# basic tests to see if it works
result = await bus.call(
Message(
destination='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus.Peer',
member='Ping'))
assert result
intr = await bus.introspect('org.freedesktop.DBus', '/org/freedesktop/DBus')
obj = await bus.get_proxy_object('org.freedesktop.DBus', '/org/freedesktop/DBus',
intr)
iface = await obj.get_interface('org.freedesktop.DBus.Peer')
await iface.call_ping()
sock = bus._sock.extra(anyio.abc.SocketAttribute.raw_socket) \
if hasattr(bus._sock,'extra') else bus._sock
assert sock.getpeername()[0] == host
assert sock.getsockname()[0] == host
assert sock.gettimeout() == 0
pass # A
finally:
tg.cancel_scope.cancel()
|
[] |
[] |
[
"DBUS_SESSION_BUS_ADDRESS"
] |
[]
|
["DBUS_SESSION_BUS_ADDRESS"]
|
python
| 1 | 0 | |
python_modules/libraries/dagster-aws/dagster_aws_tests/s3_tests/test_intermediate_store.py
|
import os
import uuid
import pytest
from dagster_aws.s3.intermediate_store import S3IntermediateStore
from dagster_aws.s3.resources import s3_resource
from dagster_aws.s3.system_storage import s3_plus_default_storage_defs
from dagster import (
Bool,
InputDefinition,
Int,
List,
ModeDefinition,
OutputDefinition,
RunConfig,
SerializationStrategy,
String,
check,
execute_pipeline,
lambda_solid,
pipeline,
)
from dagster.core.events import DagsterEventType
from dagster.core.execution.api import create_execution_plan, execute_plan, scoped_pipeline_context
from dagster.core.instance import DagsterInstance
from dagster.core.storage.pipeline_run import PipelineRun
from dagster.core.storage.type_storage import TypeStoragePlugin, TypeStoragePluginRegistry
from dagster.core.types.runtime.runtime_type import Bool as RuntimeBool
from dagster.core.types.runtime.runtime_type import RuntimeType
from dagster.core.types.runtime.runtime_type import String as RuntimeString
from dagster.core.types.runtime.runtime_type import resolve_to_runtime_type
from dagster.utils.test import yield_empty_pipeline_context
class UppercaseSerializationStrategy(SerializationStrategy): # pylint: disable=no-init
def serialize(self, value, write_file_obj):
return write_file_obj.write(bytes(value.upper().encode('utf-8')))
def deserialize(self, read_file_obj):
return read_file_obj.read().decode('utf-8').lower()
class LowercaseString(RuntimeType):
def __init__(self):
super(LowercaseString, self).__init__(
'lowercase_string',
'LowercaseString',
serialization_strategy=UppercaseSerializationStrategy('uppercase'),
)
def aws_credentials_present():
return os.getenv('AWS_ACCESS_KEY_ID') and os.getenv('AWS_SECRET_ACCESS_KEY')
nettest = pytest.mark.nettest
def define_inty_pipeline(should_throw=True):
@lambda_solid
def return_one():
return 1
@lambda_solid(input_defs=[InputDefinition('num', Int)], output_def=OutputDefinition(Int))
def add_one(num):
return num + 1
@lambda_solid
def user_throw_exception():
raise Exception('whoops')
@pipeline(
mode_defs=[
ModeDefinition(
system_storage_defs=s3_plus_default_storage_defs, resource_defs={'s3': s3_resource}
)
]
)
def basic_external_plan_execution():
add_one(return_one())
if should_throw:
user_throw_exception()
return basic_external_plan_execution
def get_step_output(step_events, step_key, output_name='result'):
for step_event in step_events:
if (
step_event.event_type == DagsterEventType.STEP_OUTPUT
and step_event.step_key == step_key
and step_event.step_output_data.output_name == output_name
):
return step_event
return None
@nettest
def test_using_s3_for_subplan(s3_bucket):
pipeline_def = define_inty_pipeline()
environment_dict = {'storage': {'s3': {'config': {'s3_bucket': s3_bucket}}}}
run_id = str(uuid.uuid4())
execution_plan = create_execution_plan(
pipeline_def, environment_dict=environment_dict, run_config=RunConfig(run_id=run_id)
)
assert execution_plan.get_step_by_key('return_one.compute')
step_keys = ['return_one.compute']
instance = DagsterInstance.ephemeral()
pipeline_run = PipelineRun.create_empty_run(
pipeline_def.name, run_id=run_id, environment_dict=environment_dict
)
return_one_step_events = list(
execute_plan(
execution_plan.build_subset_plan(step_keys),
environment_dict=environment_dict,
pipeline_run=pipeline_run,
instance=instance,
)
)
assert get_step_output(return_one_step_events, 'return_one.compute')
with scoped_pipeline_context(pipeline_def, environment_dict, pipeline_run, instance) as context:
store = S3IntermediateStore(
s3_bucket, run_id, s3_session=context.scoped_resources_builder.build().s3.session
)
assert store.has_intermediate(context, 'return_one.compute')
assert store.get_intermediate(context, 'return_one.compute', Int).obj == 1
add_one_step_events = list(
execute_plan(
execution_plan.build_subset_plan(['add_one.compute']),
environment_dict=environment_dict,
pipeline_run=pipeline_run,
instance=instance,
)
)
assert get_step_output(add_one_step_events, 'add_one.compute')
with scoped_pipeline_context(pipeline_def, environment_dict, pipeline_run, instance) as context:
assert store.has_intermediate(context, 'add_one.compute')
assert store.get_intermediate(context, 'add_one.compute', Int).obj == 2
class FancyStringS3TypeStoragePlugin(TypeStoragePlugin): # pylint:disable=no-init
@classmethod
def compatible_with_storage_def(cls, _):
# Not needed for these tests
raise NotImplementedError()
@classmethod
def set_object(cls, intermediate_store, obj, context, runtime_type, paths):
check.inst_param(intermediate_store, 'intermediate_store', S3IntermediateStore)
paths.append(obj)
return intermediate_store.set_object('', context, runtime_type, paths)
@classmethod
def get_object(cls, intermediate_store, _context, _runtime_type, paths):
check.inst_param(intermediate_store, 'intermediate_store', S3IntermediateStore)
res = intermediate_store.object_store.s3.list_objects(
Bucket=intermediate_store.object_store.bucket,
Prefix=intermediate_store.key_for_paths(paths),
)
return res['Contents'][0]['Key'].split('/')[-1]
@nettest
def test_s3_intermediate_store_with_type_storage_plugin(s3_bucket):
run_id = str(uuid.uuid4())
intermediate_store = S3IntermediateStore(
run_id=run_id,
s3_bucket=s3_bucket,
type_storage_plugin_registry=TypeStoragePluginRegistry(
{RuntimeString.inst(): FancyStringS3TypeStoragePlugin}
),
)
with yield_empty_pipeline_context(run_id=run_id) as context:
try:
intermediate_store.set_value('hello', context, RuntimeString.inst(), ['obj_name'])
assert intermediate_store.has_object(context, ['obj_name'])
assert (
intermediate_store.get_value(context, RuntimeString.inst(), ['obj_name']) == 'hello'
)
finally:
intermediate_store.rm_object(context, ['obj_name'])
@nettest
def test_s3_intermediate_store_with_composite_type_storage_plugin(s3_bucket):
run_id = str(uuid.uuid4())
intermediate_store = S3IntermediateStore(
run_id=run_id,
s3_bucket=s3_bucket,
type_storage_plugin_registry=TypeStoragePluginRegistry(
{RuntimeString.inst(): FancyStringS3TypeStoragePlugin}
),
)
with yield_empty_pipeline_context(run_id=run_id) as context:
with pytest.raises(check.NotImplementedCheckError):
intermediate_store.set_value(
['hello'], context, resolve_to_runtime_type(List[String]), ['obj_name']
)
@nettest
def test_s3_intermediate_store_composite_types_with_custom_serializer_for_inner_type(s3_bucket):
run_id = str(uuid.uuid4())
intermediate_store = S3IntermediateStore(run_id=run_id, s3_bucket=s3_bucket)
with yield_empty_pipeline_context(run_id=run_id) as context:
try:
intermediate_store.set_object(
['foo', 'bar'],
context,
resolve_to_runtime_type(List[LowercaseString]).inst(),
['list'],
)
assert intermediate_store.has_object(context, ['list'])
assert intermediate_store.get_object(
context, resolve_to_runtime_type(List[Bool]).inst(), ['list']
).obj == ['foo', 'bar']
finally:
intermediate_store.rm_object(context, ['foo'])
@nettest
def test_s3_intermediate_store_with_custom_serializer(s3_bucket):
run_id = str(uuid.uuid4())
intermediate_store = S3IntermediateStore(run_id=run_id, s3_bucket=s3_bucket)
with yield_empty_pipeline_context(run_id=run_id) as context:
try:
intermediate_store.set_object('foo', context, LowercaseString.inst(), ['foo'])
assert (
intermediate_store.object_store.s3.get_object(
Bucket=intermediate_store.object_store.bucket,
Key='/'.join([intermediate_store.root] + ['foo']),
)['Body']
.read()
.decode('utf-8')
== 'FOO'
)
assert intermediate_store.has_object(context, ['foo'])
assert (
intermediate_store.get_object(context, LowercaseString.inst(), ['foo']).obj == 'foo'
)
finally:
intermediate_store.rm_object(context, ['foo'])
@nettest
def test_s3_pipeline_with_custom_prefix(s3_bucket):
run_id = str(uuid.uuid4())
s3_prefix = 'custom_prefix'
pipe = define_inty_pipeline(should_throw=False)
environment_dict = {
'storage': {'s3': {'config': {'s3_bucket': s3_bucket, 's3_prefix': s3_prefix}}}
}
pipeline_run = PipelineRun.create_empty_run(
pipe.name, run_id=run_id, environment_dict=environment_dict
)
instance = DagsterInstance.ephemeral()
result = execute_pipeline(
pipe, environment_dict=environment_dict, run_config=RunConfig(run_id=run_id),
)
assert result.success
with scoped_pipeline_context(pipe, environment_dict, pipeline_run, instance) as context:
store = S3IntermediateStore(
run_id=run_id,
s3_bucket=s3_bucket,
s3_prefix=s3_prefix,
s3_session=context.scoped_resources_builder.build().s3.session,
)
assert store.root == '/'.join(['custom_prefix', 'storage', run_id])
assert store.get_intermediate(context, 'return_one.compute', Int).obj == 1
assert store.get_intermediate(context, 'add_one.compute', Int).obj == 2
@nettest
def test_s3_intermediate_store_with_custom_prefix(s3_bucket):
run_id = str(uuid.uuid4())
intermediate_store = S3IntermediateStore(
run_id=run_id, s3_bucket=s3_bucket, s3_prefix='custom_prefix'
)
assert intermediate_store.root == '/'.join(['custom_prefix', 'storage', run_id])
try:
with yield_empty_pipeline_context(run_id=run_id) as context:
intermediate_store.set_object(True, context, RuntimeBool.inst(), ['true'])
assert intermediate_store.has_object(context, ['true'])
assert intermediate_store.uri_for_paths(['true']).startswith(
's3://%s/custom_prefix' % s3_bucket
)
finally:
intermediate_store.rm_object(context, ['true'])
@nettest
def test_s3_intermediate_store(s3_bucket):
run_id = str(uuid.uuid4())
run_id_2 = str(uuid.uuid4())
intermediate_store = S3IntermediateStore(run_id=run_id, s3_bucket=s3_bucket)
assert intermediate_store.root == '/'.join(['dagster', 'storage', run_id])
intermediate_store_2 = S3IntermediateStore(run_id=run_id_2, s3_bucket=s3_bucket)
assert intermediate_store_2.root == '/'.join(['dagster', 'storage', run_id_2])
try:
with yield_empty_pipeline_context(run_id=run_id) as context:
intermediate_store.set_object(True, context, RuntimeBool.inst(), ['true'])
assert intermediate_store.has_object(context, ['true'])
assert intermediate_store.get_object(context, RuntimeBool.inst(), ['true']).obj is True
assert intermediate_store.uri_for_paths(['true']).startswith('s3://')
intermediate_store_2.copy_object_from_prev_run(context, run_id, ['true'])
assert intermediate_store_2.has_object(context, ['true'])
assert (
intermediate_store_2.get_object(context, RuntimeBool.inst(), ['true']).obj is True
)
finally:
intermediate_store.rm_object(context, ['true'])
intermediate_store_2.rm_object(context, ['true'])
|
[] |
[] |
[
"AWS_ACCESS_KEY_ID",
"AWS_SECRET_ACCESS_KEY"
] |
[]
|
["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"]
|
python
| 2 | 0 | |
Lambda/vanilla-golang/shoppingcart-example/add-item-to-cart/main.go
|
package main
import (
"encoding/json"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
"github.com/satori/go.uuid"
"io/ioutil"
"log"
"os"
"net/http"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/dynamodb"
"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
)
var baseUrl = os.Getenv("APIURL")
type ItemInventory struct {
Name string `json:"name"`
Stock int `json:"stock"`
Cost float64 `json:"cost"`
}
type ItemCart struct {
Name string `json:"name"`
Quantity int `json:"quantity"`
Cost float64 `json:"cost"`
}
type Affectee struct {
Name string `json:"name"`
Quantity int `json:"quantity"`
}
type Affected struct {
Name string `json:"name"`
CostPtg float64 `json:"costPtg"`
CostFixed float64 `json:"costFixed"`
}
type Promotion struct {
UUID string `json:"uuid"`
Affectee Affectee `json:"affectee"`
Affected Affected `json:"affected"`
}
type CartSession struct {
Session string `json:"session"`
Cart []ItemCart `json:"cart"`
Total float64 `json:"total"`
Promos []Promotion `json:"promos"`
}
type RequestBody struct {
Name string `json:"name"`
Quantity int `json:"quantity"`
}
func Handler(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
// ************
// Preparation
// ************
sess, err := session.NewSession(&aws.Config{
Region: aws.String("us-west-2")},
)
if err != nil {
return serverError(err)
}
// Get body of request
requestBody := new(RequestBody)
err = json.Unmarshal([]byte(request.Body), requestBody)
if err != nil {
return serverError(err)
}
// Verifying request
if requestBody.Name == "" || requestBody.Quantity <= 0 {
return parametersError()
}
// Create DynamoDB client
svc := dynamodb.New(sess)
cartSession := new(CartSession)
itemInventory := new(ItemInventory)
// ************
// Operation
// ************
// Step 1: Find existing session or create one
if request.PathParameters["session"] != "" {
cartString := getUrl("/cart/" + request.PathParameters["session"])
err := json.Unmarshal(cartString, cartSession)
if err != nil {
return serverError(err)
}
if cartSession.Session == "" {
cartSession, err = addCart(svc)
}
} else {
cartSession, err = addCart(svc)
}
// Step 2: Modify cart array
// Step 2.1: Check if inventory has enough stock
itemCart := new(ItemCart)
// Get the item from inventory
inventoryString := getUrl("/item/" + requestBody.Name)
err = json.Unmarshal(inventoryString, itemInventory)
if err != nil {
return serverError(err)
}
// Get the item from cart array
itemIndexInCart := -1
for i, item := range cartSession.Cart {
if item.Name == requestBody.Name {
itemCart = &item
itemIndexInCart = i
}
}
// Check if quantity exceeds stock
if itemInventory.Stock < (requestBody.Quantity + itemCart.Quantity) {
log.Println("Error: Not enough stock", itemInventory.Stock, requestBody.Quantity, itemCart.Quantity)
return notEnoughStockError()
}
// Step 2.2 if item isn't found in cart then create it & update cart
if itemIndexInCart == -1 {
itemCart.Name = requestBody.Name
itemCart.Quantity = requestBody.Quantity
itemCart.Cost = float64(itemCart.Quantity) * itemInventory.Cost
cartSession.Cart = append(cartSession.Cart, *itemCart)
} else {
cartSession.Cart[itemIndexInCart].Quantity += requestBody.Quantity
cartSession.Cart[itemIndexInCart].Cost += (itemCart.Cost / float64(itemCart.Quantity)) * float64(requestBody.Quantity)
}
// Step 3: Apply promotions
// Get all promotions
var promotions []Promotion
promoString := getUrl("/promo/")
err = json.Unmarshal(promoString, &promotions)
if err != nil {
return serverError(err)
}
OUTER:
for i, item := range cartSession.Cart {
for _, promo := range promotions {
// Skip applied promos if they do not apply to the same
// UNLESS it's a promo where the affected and the affectee are the same
alreadyApplied := false
skippable := false
for _, appliedPromo := range cartSession.Promos {
if promo.UUID == appliedPromo.UUID {
alreadyApplied = true
if appliedPromo.Affectee.Name != appliedPromo.Affected.Name {
skippable = true
} else {
skippable = false
}
break
}
}
if alreadyApplied && skippable {
alreadyApplied = false
skippable = false
continue
}
if item.Name == promo.Affected.Name {
// If an item in the cart can be affected by the promo
// then start investigating if we have the affectee
// If the item is the affected and affectee
if item.Name == promo.Affectee.Name {
// If the item does not exceed affectee quantity then there is no affected
if item.Quantity+requestBody.Quantity <= promo.Affectee.Quantity {
continue OUTER
}
// then modify the affected's cost without
// modifying the affectee
// Calculating the affectee cost
costOfAffecteeItems := itemInventory.Cost * float64(promo.Affectee.Quantity)
quantityOfAffected := cartSession.Cart[i].Quantity - promo.Affectee.Quantity
var costOfAffectedItems float64
if promo.Affected.CostPtg != 0 {
// Calcuating the affected cost
costOfAffectedItems = float64(quantityOfAffected) * (itemInventory.Cost * promo.Affected.CostPtg)
} else {
costOfAffectedItems = float64(quantityOfAffected) * promo.Affected.CostFixed
}
cartSession.Cart[i].Cost = costOfAffecteeItems + costOfAffectedItems
// Add promo to cart
if !alreadyApplied {
cartSession.Promos = append(cartSession.Promos, promo)
}
continue OUTER
} else {
for _, subItem := range cartSession.Cart {
// If we have the affectee & its quantity is equal or higher than promo
if subItem.Name == promo.Affectee.Name && subItem.Quantity >= promo.Affectee.Quantity {
// Apply the promo
if promo.Affected.CostPtg != 0 {
cartSession.Cart[i].Cost *= promo.Affected.CostPtg
} else {
cartSession.Cart[i].Cost = float64(cartSession.Cart[i].Quantity) * promo.Affected.CostFixed
}
// Add promo to cart
cartSession.Promos = append(cartSession.Promos, promo)
continue OUTER
}
}
}
}
}
}
// Step 4: Calculate total cost
// Even though this iteration already happened in another area
// it is safer to keep different functionalities separate
// and avoid spaghetti code as long as it does not have a big
// impact on the performance
cartSession.Total = 0
for _, item := range cartSession.Cart {
cartSession.Total += item.Cost
}
// Update Cart Session
err = updateCart(svc, cartSession)
if err != nil {
return serverError(err)
}
// ************
// Return
// ************
js, err := json.Marshal(cartSession)
if err != nil {
return serverError(err)
}
return events.APIGatewayProxyResponse{
Headers: map[string]string{"content-type": "application/json"},
Body: string(js),
StatusCode: 200,
}, nil
}
func updateCart(svc *dynamodb.DynamoDB, cartSession *CartSession) error {
// Add new cart session in database
av, err := dynamodbattribute.MarshalMap(cartSession)
if err != nil {
log.Println("Got error marshalling map")
return err
}
input := &dynamodb.PutItemInput{
Item: av,
TableName: aws.String("Cart"),
}
_, err = svc.PutItem(input)
if err != nil {
log.Println("Got error calling PutItem")
return err
}
return nil
}
func addCart(svc *dynamodb.DynamoDB) (*CartSession, error) {
// Create UUID for new session
uid := uuid.Must(uuid.NewV4())
cartSession := CartSession{
Session: uid.String(),
}
// Add new cart session in database
av, err := dynamodbattribute.MarshalMap(cartSession)
if err != nil {
log.Println("Got error marshalling map")
serverError(err)
return nil, err
}
input := &dynamodb.PutItemInput{
Item: av,
TableName: aws.String("Cart"),
}
_, err = svc.PutItem(input)
if err != nil {
log.Println("Got error calling PutItem")
serverError(err)
return nil, err
}
return &cartSession, nil
}
// Function used to call other lambda functions
func getUrl(url string) []byte {
// Make a get request
rs, err := http.Get(baseUrl + url)
// Process response
if err != nil {
log.Printf("error calling url")
serverError(err)
}
defer rs.Body.Close()
bodyBytes, err := ioutil.ReadAll(rs.Body)
if err != nil {
log.Printf("error reading body from url")
serverError(err)
}
return bodyBytes
}
func serverError(err error) (events.APIGatewayProxyResponse, error) {
log.Println("Error: " + err.Error())
return events.APIGatewayProxyResponse{
StatusCode: http.StatusInternalServerError,
Body: http.StatusText(http.StatusInternalServerError),
}, nil
}
func parametersError() (events.APIGatewayProxyResponse, error) {
log.Println("Parameters requirment not met")
return events.APIGatewayProxyResponse{
StatusCode: http.StatusPreconditionFailed,
Body: http.StatusText(http.StatusPreconditionFailed),
}, nil
}
func notEnoughStockError() (events.APIGatewayProxyResponse, error) {
log.Println("Not enough stock")
return events.APIGatewayProxyResponse{
StatusCode: http.StatusForbidden,
Body: http.StatusText(http.StatusForbidden),
}, nil
}
func main() {
lambda.Start(Handler)
}
|
[
"\"APIURL\""
] |
[] |
[
"APIURL"
] |
[]
|
["APIURL"]
|
go
| 1 | 0 | |
data_steward/test/unit_test/achilles_test.py
|
import os
import unittest
from google.appengine.ext import testbed
import bq_utils
import gcs_utils
import resources
import test_util
import validation.sql_wrangle
from test_util import FAKE_HPO_ID
from validation import achilles
# This may change if we strip out unused analyses
ACHILLES_LOOKUP_COUNT = 215
ACHILLES_ANALYSIS_COUNT = 134
ACHILLES_RESULTS_COUNT = 2497
SOURCE_NAME_QUERY = """insert into synpuf_100.achilles_analysis (analysis_id, analysis_name)
values (0, 'Source name')"""
TEMP_QUERY_1 = """INTO temp.tempresults
WITH rawdata as ( select p.person_id as person_id, min(EXTRACT(YEAR from observation_period_start_date)) -
p.year_of_birth as age_value from synpuf_100.person p
join synpuf_100.observation_period op on p.person_id = op.person_id
group by p.person_id, p.year_of_birth
), overallstats as (select cast(avg(1.0 * age_value) as float64) as avg_value, cast(STDDEV(age_value) as
float64) as stdev_value, min(age_value) as min_value, max(age_value) as max_value, COUNT(*) as total from rawdata
), agestats as ( select age_value as age_value, COUNT(*) as total, row_number() over (order by age_value) as rn
from rawdata
group by 1 ), agestatsprior as ( select s.age_value as age_value, s.total as total, sum(p.total) as
accumulated from agestats s
join agestats p on p.rn <= s.rn
group by s.age_value, s.total, s.rn
)
select 103 as analysis_id, o.total as count_value, o.min_value, o.max_value, o.avg_value, o.stdev_value,
min(case when p.accumulated >= .50 * o.total then age_value end) as median_value, min(case when p.accumulated >= .10
* o.total then age_value end) as p10_value, min(case when p.accumulated >= .25 * o.total then age_value end) as
p25_value, min(case when p.accumulated >= .75 * o.total then age_value end) as p75_value, min(case when
p.accumulated >= .90 * o.total then age_value end) as p90_value
FROM agestatsprior p
cross join overallstats o
group by o.total, o.min_value, o.max_value, o.avg_value, o.stdev_value"""
TEMP_QUERY_2 = """INTO temp.rawdata_1006
SELECT ce.condition_concept_id as subject_id, p1.gender_concept_id, ce.condition_start_year - p1.year_of_birth as
count_value
FROM synpuf_100.person p1
inner join
(
select person_id, condition_concept_id, min(EXTRACT(YEAR from condition_era_start_date)) as condition_start_year
from synpuf_100.condition_era
group by 1, 2 ) ce on p1.person_id = ce.person_id"""
@unittest.skipIf(os.getenv('ALL_TESTS') == 'False', 'Skipping AchillesTest cases')
class AchillesTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
print('**************************************************************')
print(cls.__name__)
print('**************************************************************')
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_app_identity_stub()
self.testbed.init_memcache_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_blobstore_stub()
self.testbed.init_datastore_v3_stub()
self.hpo_bucket = gcs_utils.get_hpo_bucket(test_util.FAKE_HPO_ID)
test_util.empty_bucket(self.hpo_bucket)
test_util.delete_all_tables(bq_utils.get_dataset_id())
def _load_dataset(self):
for cdm_table in resources.CDM_TABLES:
cdm_file_name = os.path.join(test_util.FIVE_PERSONS_PATH, cdm_table + '.csv')
if os.path.exists(cdm_file_name):
test_util.write_cloud_file(self.hpo_bucket, cdm_file_name)
else:
test_util.write_cloud_str(self.hpo_bucket, cdm_table + '.csv', 'dummy\n')
bq_utils.load_cdm_csv(FAKE_HPO_ID, cdm_table)
def test_detect_commented_block(self):
commented_command = """
--1300- ORGANIZATION
--NOT APPLICABLE IN CDMV5
--insert into fake_ACHILLES_analysis (analysis_id, analysis_name, stratum_1_name)
-- values (1300, 'Number of organizations by place of service', 'place_of_service_concept_id')"""
self.assertFalse(validation.sql_wrangle.is_active_command(commented_command))
def test_load_analyses(self):
achilles.create_tables(FAKE_HPO_ID, True)
achilles.load_analyses(FAKE_HPO_ID)
cmd = validation.sql_wrangle.qualify_tables(
'SELECT DISTINCT(analysis_id) FROM %sachilles_analysis' % validation.sql_wrangle.PREFIX_PLACEHOLDER,
FAKE_HPO_ID)
result = bq_utils.query(cmd)
self.assertEqual(ACHILLES_LOOKUP_COUNT, int(result['totalRows']))
def test_get_run_analysis_commands(self):
cmd_iter = achilles._get_run_analysis_commands(FAKE_HPO_ID)
commands = list(cmd_iter)
self.assertEqual(len(commands), ACHILLES_ANALYSIS_COUNT)
def test_temp_table(self):
self.assertTrue(validation.sql_wrangle.is_to_temp_table(TEMP_QUERY_1))
self.assertTrue(validation.sql_wrangle.is_to_temp_table(TEMP_QUERY_2))
self.assertFalse(validation.sql_wrangle.is_to_temp_table(SOURCE_NAME_QUERY))
self.assertEqual(validation.sql_wrangle.get_temp_table_name(TEMP_QUERY_1), 'temp.tempresults')
self.assertEqual(validation.sql_wrangle.get_temp_table_name(TEMP_QUERY_2), 'temp.rawdata_1006')
self.assertTrue(validation.sql_wrangle.get_temp_table_query(TEMP_QUERY_1).startswith('WITH rawdata'))
self.assertTrue(
validation.sql_wrangle.get_temp_table_query(TEMP_QUERY_2).startswith('SELECT ce.condition_concept_id'))
def test_run_analyses(self):
# Long-running test
self._load_dataset()
achilles.create_tables(FAKE_HPO_ID, True)
achilles.load_analyses(FAKE_HPO_ID)
achilles.run_analyses(hpo_id=FAKE_HPO_ID)
cmd = validation.sql_wrangle.qualify_tables(
'SELECT COUNT(1) FROM %sachilles_results' % validation.sql_wrangle.PREFIX_PLACEHOLDER, FAKE_HPO_ID)
result = bq_utils.query(cmd)
self.assertEqual(int(result['rows'][0]['f'][0]['v']), ACHILLES_RESULTS_COUNT)
def test_parse_temp(self):
commands = achilles._get_run_analysis_commands(FAKE_HPO_ID)
for command in commands:
is_temp = validation.sql_wrangle.is_to_temp_table(command)
self.assertFalse(is_temp)
def tearDown(self):
test_util.delete_all_tables(bq_utils.get_dataset_id())
test_util.empty_bucket(self.hpo_bucket)
self.testbed.deactivate()
|
[] |
[] |
[
"ALL_TESTS"
] |
[]
|
["ALL_TESTS"]
|
python
| 1 | 0 | |
src/catkin_projects/rlg_simulation/scripts/generate_dishrack_arrangements.py
|
import argparse
import math
import numpy as np
import os
import re
import time
import yaml
# For physical simulation
#import pybullet as p
# For projection into nonpenetration
# (pre-processing for simulation)
#import pydrake
#from pydrake.solvers import ik
# Eventually, for visualization,
# though not used yet.
#from director import viewerclient
models = {
"plate_11in": "drake/../models/dish_models/plate_11in_decomp/plate_11in_decomp.urdf",
"plate_8p5in": "drake/../models/dish_models/plate_8p5in_decomp/plate_8p5in_decomp.urdf",
"bowl_6p25in": "drake/../models/dish_models/bowl_6p25in_decomp/bowl_6p25in_decomp.urdf",
"dish_rack": "drake/../models/dish_models/dish_rack_simple.urdf",
"floor": "drake/../build/bullet3/data/plane.urdf"
}
class ObjectInstance:
def __init__(self, model, q0, fixed=False):
self.model = model
self.q0 = q0
self.fixed = fixed
def to_dict(self):
return {"model": str(self.model),
"q0": [float(x) for x in self.q0], "fixed": self.fixed}
def load_rbt_from_urdf_rel_drake_root(model_name, rbt, weld_frame = None):
urdf_filename = models[model_name]
drake_root = os.getenv("DRAKE_RESOURCE_ROOT")
urdf_string = open(drake_root + "/" + urdf_filename).read()
base_dir = os.path.dirname(drake_root + "/" + urdf_filename)
package_map = pydrake.rbtree.PackageMap()
if weld_frame is None:
floating_base_type = pydrake.rbtree.kRollPitchYaw
else:
floating_base_type = pydrake.rbtree.kFixed
pydrake.rbtree.AddModelInstanceFromUrdfStringSearchingInRosPackages(
urdf_string,
package_map,
base_dir,
floating_base_type,
weld_frame,
rbt)
class DishrackArrangement:
def __init__(self):
self.instances = [ObjectInstance("dish_rack", [0, 0, 0, 0, 0, 0], True)]
def add_instance(self, instance):
self.instances.append(instance)
def get_non_rack_instances(self):
return [instance for instance in self.instances if instance.model != "dish_rack"]
def project_instance_to_nonpenetration(self):
# Set up a rigidbodytree
r = pydrake.rbtree.RigidBodyTree()
q0 = []
# create hacky ground frame just under world frame, but a little lower so no collision
# between world and ground (which causes IK infeasibility)
# could replace with careful collision groups)
ground_frame = pydrake.rbtree.RigidBodyFrame("ground_frame", r.world(), [0, 0, -1E-3], [0, 0, 0])
# Add floor as a fixed frame.
#load_rbt_from_urdf_rel_drake_root("floor", r, ground_frame)
world_frame = pydrake.rbtree.RigidBodyFrame("world_frame", r.world(), [0, 0, 0], [0, 0, 0])
for instance in self.instances:
# I'd do this to load in the tray as a fixed mesh.
# But, Drake's bullet interface doesn't support closest points
# checks against nonconvex geometry, even though bullet does.
# So instead I'll load it as dynamic geometry, have drake take
# a chull of it, and allow this step to give feasible but
# conservative results...
if instance.fixed:
#load_rbt_from_urdf_rel_drake_root(instance.model, r, world_frame)
#[q0.append(x) for x in instance.q0]
pass
else:
load_rbt_from_urdf_rel_drake_root(instance.model, r)
[q0.append(x) for x in instance.q0]
tspan = np.array([0., 1.])
constraints = [
# Nonpenetration: no two bodies with negative min distance
# (i.e. no penetration)
ik.MinDistanceConstraint(r, 1e-3, list(), set())
# ik.QuasiStaticConstraint(r, tspan)
]
info = 13
while info != 100 and info != 1:
options = ik.IKoptions(r)
print "Feasibility: ", options.getMajorFeasibilityTolerance()
print "superbasics lim: ", options.getSuperbasicsLimit()
q0_array = np.array(q0, dtype=np.float64, ndmin=2)[0]
q0_seed = q0_array + np.random.randn(len(q0))
q0_seed[0:6] = [0.0]*6
results = ik.InverseKin(r, q0_array, q0_seed, constraints, options)
qsol = list(results.q_sol[0])
info = results.info[0]
print("Results ", qsol, " with info ", info)
if (info != 100 or info != 1):
print "Trying against because IK failed."
else:
q0 = qsol
# Remap flattened state back into the individual instance states
ind = 0
for instance in self.instances:
num_states = len(instance.q0)
print("For instance %s: mapped ", instance.q0, " to ", q0[ind:(ind+num_states)])
instance.q0 = q0[ind:(ind+num_states)]
ind += num_states
def simulate_instance(self, n_secs, timestep=0.01):
# Assumes physics client already set up
p.resetSimulation()
p.setGravity(0,0,-9.81)
p.setTimeStep(timestep)
# Load in a ground
p.loadURDF(os.environ["SPARTAN_SOURCE_DIR"] + "/build/bullet3/data/plane.urdf")
# Add each model as requested
drake_resource_root = os.environ["DRAKE_RESOURCE_ROOT"]
ids = []
for instance in self.instances:
urdf = drake_resource_root + "/" + models[instance.model]
q0 = instance.q0
position = q0[0:3]
quaternion = p.getQuaternionFromEuler(q0[3:8])
fixed = instance.fixed
ids.append(p.loadURDF(urdf, position, quaternion, fixed))
# Simulate it
for i in range(int(n_secs / timestep)):
p.stepSimulation()
# Extract model states
for i, instance in enumerate(self.instances):
pos, quat = p.getBasePositionAndOrientation(i+1)
instance.q0[0:3] = pos
instance.q0[3:7] = p.getEulerFromQuaternion(quat)
def save_to_file(self, filename):
data = {}
data["models"] = models
data["with_ground"] = True
data["instances"] = []
for instance in self.instances:
data["instances"].append(instance.to_dict())
with open(filename, 'w') as outfile:
yaml.dump(data, outfile, default_flow_style=False)
@staticmethod
def load_from_file(filename):
arrangement = DishrackArrangement()
config = yaml.load(open(filename, 'r'))
for instance in config["instances"]:
if instance["model"] != "dish_rack":
arrangement.add_instance(ObjectInstance(instance["model"], instance["q0"]))
return arrangement
# Place plates vertically, but with random yaw from [0, pi/2, pi, 3pi/2],
# within the bounds of the rack
plate_11in_params = {
"lower_bound_x": 0.017,
"upper_bound_x": 0.47,
"lower_bound_y": -0.47,
"upper_bound_y": -0.017,
"height": 0.3
}
def place_plate_11in():
center_location_x = np.random.uniform(plate_11in_params["lower_bound_x"], plate_11in_params["upper_bound_x"])
center_location_y = np.random.uniform(plate_11in_params["lower_bound_y"], plate_11in_params["upper_bound_y"])
yaw = float(np.random.randint(0, 4))*math.pi/2.
return [center_location_x, center_location_y, plate_11in_params["height"],
0, 0, yaw]
placement_generators = {
"plate_11in": place_plate_11in
}
# Hand-written data generation script
def generate_dishrack_arrangement(max_num_dishes, allowable_dish_types):
arrangement = DishrackArrangement()
num_dishes = np.random.randint(0, max_num_dishes)
for k in range(num_dishes):
# Pick dish type
dish_type = allowable_dish_types[np.random.randint(0, len(allowable_dish_types))]
if dish_type not in placement_generators.keys():
print("Error: generator not defined for dish type %s" % (dish_type))
exit(-1)
# Generate a placement and add it to the arrangement
arrangement.add_instance(ObjectInstance(dish_type, placement_generators[dish_type](), False))
return arrangement
def load_arrangements_from_folder(folder_name, filename_regex=".*\.yaml"):
all_arrangements = []
matcher = re.compile(filename_regex)
if not os.path.isdir(folder_name):
print "Data directory ", folder_name, " doesn't exist."
exit(0)
filenames = next(os.walk(folder_name))[2]
for filename in sorted(filenames):
if matcher.match(filename):
all_arrangements.append(DishrackArrangement.load_from_file(folder_name + "/" + filename))
print "Loaded %d arrangements." % len(all_arrangements)
return all_arrangements
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("folder", help="Folder to put generated files in.", type=str)
parser.add_argument("-n", "--max_num_dishes", help="Max # of dishes to generate", type=int, default=20)
parser.add_argument("-m", "--num_samples", help="# of arrangements to generate", type=int, default=1)
parser.add_argument("-s", "--seed", help="Random seed", type=int)
args = parser.parse_args()
# Set up a simulation with a ground plane and desired timestep
physicsClient = p.connect(p.GUI)#or p.DIRECT for non-graphical version
if args.seed is not None:
np.random.seed(args.seed)
os.system("mkdir -p " + args.folder)
for i in range(args.num_samples):
arrangement = generate_dishrack_arrangement(args.max_num_dishes, ["plate_11in",])
arrangement.save_to_file(args.folder + "/" + "%03d_1_pre_projection.yaml" % i)
#arrangement.project_instance_to_nonpenetration()
#arrangement.save_to_file(args.folder + "/" + "%03d_2_post_projection.yaml" % i)
arrangement.simulate_instance(2.)
arrangement.save_to_file(args.folder + "/" + "%03d_3_post_simulation.yaml" % i)
|
[] |
[] |
[
"DRAKE_RESOURCE_ROOT",
"SPARTAN_SOURCE_DIR"
] |
[]
|
["DRAKE_RESOURCE_ROOT", "SPARTAN_SOURCE_DIR"]
|
python
| 2 | 0 | |
backend/metadata_writer/src/metadata_writer.py
|
# Copyright 2020 kubeflow.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import hashlib
import os
import sys
import re
import kubernetes
import yaml
from time import sleep
from metadata_helpers import *
namespace_to_watch = os.environ.get('NAMESPACE_TO_WATCH', 'default')
kubernetes.config.load_incluster_config()
k8s_api = kubernetes.client.CoreV1Api()
k8s_watch = kubernetes.watch.Watch()
patch_retries = 20
sleep_time = 0.1
def patch_pod_metadata(
namespace: str,
pod_name: str,
patch: dict,
k8s_api: kubernetes.client.CoreV1Api = None,
):
k8s_api = k8s_api or kubernetes.client.CoreV1Api()
patch = {
'metadata': patch
}
for retry in range(patch_retries):
try:
pod = k8s_api.patch_namespaced_pod(
name=pod_name,
namespace=namespace,
body=patch,
)
return pod
except Exception as e:
print(e)
sleep(sleep_time)
#Connecting to MetadataDB
mlmd_store = connect_to_mlmd()
print("Connected to the metadata store")
PIPELINE_RUNTIME = os.getenv("PIPELINE_RUNTIME", "tekton").lower()
ARGO_OUTPUTS_ANNOTATION_KEY = 'workflows.argoproj.io/outputs'
ARGO_TEMPLATE_ANNOTATION_KEY = 'workflows.argoproj.io/template'
KFP_COMPONENT_SPEC_ANNOTATION_KEY = 'pipelines.kubeflow.org/component_spec'
METADATA_EXECUTION_ID_LABEL_KEY = 'pipelines.kubeflow.org/metadata_execution_id'
METADATA_CONTEXT_ID_LABEL_KEY = 'pipelines.kubeflow.org/metadata_context_id'
METADATA_ARTIFACT_IDS_ANNOTATION_KEY = 'pipelines.kubeflow.org/metadata_artifact_ids'
METADATA_INPUT_ARTIFACT_IDS_ANNOTATION_KEY = 'pipelines.kubeflow.org/metadata_input_artifact_ids'
METADATA_OUTPUT_ARTIFACT_IDS_ANNOTATION_KEY = 'pipelines.kubeflow.org/metadata_output_artifact_ids'
ARGO_WORKFLOW_LABEL_KEY = 'workflows.argoproj.io/workflow'
ARGO_COMPLETED_LABEL_KEY = 'workflows.argoproj.io/completed'
METADATA_WRITTEN_LABEL_KEY = 'pipelines.kubeflow.org/metadata_written'
TEKTON_PIPELINERUN_LABEL_KEY = 'tekton.dev/pipelineRun'
TEKTON_READY_ANNOTATION_KEY = 'tekton.dev/ready'
TEKTON_TASKRUN_LABEL_KEY = 'tekton.dev/taskRun'
TEKTON_PIPELINETASK_LABEL_KEY = 'tekton.dev/pipelineTask'
TEKTON_INPUT_ARTIFACT_ANNOTATION_KEY = 'tekton.dev/input_artifacts'
TEKTON_OUTPUT_ARTIFACT_ANNOTATION_KEY = 'tekton.dev/output_artifacts'
TEKTON_BUCKET_ARTIFACT_ANNOTATION_KEY = 'tekton.dev/artifact_bucket'
PIPELINE_LABEL_KEY = TEKTON_PIPELINERUN_LABEL_KEY if PIPELINE_RUNTIME == "tekton" else ARGO_WORKFLOW_LABEL_KEY
def output_name_to_argo(name: str) -> str:
import re
# This sanitization code should be kept in sync with the code in the DSL compiler.
# See https://github.com/kubeflow/pipelines/blob/39975e3cde7ba4dcea2bca835b92d0fe40b1ae3c/sdk/python/kfp/compiler/_k8s_helper.py#L33
return re.sub('-+', '-', re.sub('[^-_0-9A-Za-z]+', '-', name)).strip('-')
def is_s3_endpoint(endpoint: str) -> bool:
return re.search('^.*s3.*amazonaws.com.*$', endpoint)
def get_object_store_provider(endpoint: str) -> bool:
if is_s3_endpoint(endpoint):
return 's3'
else:
return 'minio'
def artifact_to_uri(artifact: dict) -> str:
# s3 here means s3 compatible object storage. not AWS S3.
if 's3' in artifact:
s3_artifact = artifact['s3']
return '{provider}://{bucket}/{key}'.format(
provider=get_object_store_provider(s3_artifact.get('endpoint', 'minio')),
bucket=s3_artifact.get('bucket', ''),
key=s3_artifact.get('key', ''),
)
elif 'raw' in artifact:
return None
else:
return None
def is_tfx_pod(pod) -> bool:
main_step_name = 'step-main' if PIPELINE_RUNTIME == "tekton" else 'main'
main_containers = [container for container in pod.spec.containers if container.name == main_step_name]
if len(main_containers) != 1:
return False
main_container = main_containers[0]
return main_container.command and main_container.command[-1].endswith('tfx/orchestration/kubeflow/container_entrypoint.py')
def get_component_template(obj):
'''
Return an Argo formatted component template
'''
if PIPELINE_RUNTIME == "tekton":
artifacts = json.loads(obj.metadata.annotations[TEKTON_INPUT_ARTIFACT_ANNOTATION_KEY])
results = artifacts.get(obj.metadata.labels[TEKTON_PIPELINETASK_LABEL_KEY], [])
component_template = {
"name": obj.metadata.labels[TEKTON_PIPELINETASK_LABEL_KEY],
"inputs": {
"artifacts": [
{
"name": i["name"],
"s3": {
"bucket": obj.metadata.annotations.get(TEKTON_BUCKET_ARTIFACT_ANNOTATION_KEY, "mlpipeline"),
"key": "artifacts/%s/%s/%s.tgz" % (obj.metadata.labels[TEKTON_PIPELINERUN_LABEL_KEY],
i['parent_task'],
i["name"].replace(i['parent_task'] + '-', ''))
}
} for i in results
]
}
}
return component_template
else:
return json.loads(obj.metadata.annotations[ARGO_TEMPLATE_ANNOTATION_KEY])
def get_output_template(obj):
'''
Return an Argo formatted artifact output template
'''
if PIPELINE_RUNTIME == "tekton":
artifacts = json.loads(obj.metadata.annotations[TEKTON_OUTPUT_ARTIFACT_ANNOTATION_KEY])
results = artifacts.get(obj.metadata.labels[TEKTON_PIPELINETASK_LABEL_KEY], [])
artifact_prefix = obj.metadata.labels[TEKTON_PIPELINETASK_LABEL_KEY] + '-'
s3_key_prefix = 'artifacts/%s/%s' % (obj.metadata.labels[TEKTON_PIPELINERUN_LABEL_KEY],
obj.metadata.labels[TEKTON_PIPELINETASK_LABEL_KEY])
output_template = {
"name": obj.metadata.labels[TEKTON_PIPELINETASK_LABEL_KEY],
"artifacts": [
{
"name": i["name"],
"path": i["path"],
"s3": {
"bucket": obj.metadata.annotations.get(TEKTON_BUCKET_ARTIFACT_ANNOTATION_KEY, "mlpipeline"),
"key": "%s/%s.tgz" % (s3_key_prefix,
i["name"].replace(artifact_prefix, ''))
}
} for i in results
]
}
return output_template
else:
return json.loads(obj.metadata.annotations[ARGO_OUTPUTS_ANNOTATION_KEY])
# Caches (not expected to be persistent)
# These caches are only used to prevent race conditions. Race conditions happen because the writer can see multiple versions of K8s object before the applied labels show up.
# They are expected to be lost when restarting the service.
# The operation of the Metadata Writer remains correct even if it's getting restarted frequently. (Kubernetes only sends the latest version of resource for new watchers.)
# Technically, we could remove the objects from cache as soon as we see that our labels have been applied successfully.
pod_name_to_execution_id = {}
workflow_name_to_context_id = {}
pods_with_written_metadata = set()
while True:
print("Start watching Kubernetes Pods created by Argo or Tekton")
try:
for event in k8s_watch.stream(
k8s_api.list_namespaced_pod,
namespace=namespace_to_watch,
label_selector=PIPELINE_LABEL_KEY,
timeout_seconds=1800, # Sometimes watch gets stuck
_request_timeout=2000, # Sometimes HTTP GET gets stuck
):
obj = event['object']
print('Kubernetes Pod event: ', event['type'], obj.metadata.name, obj.metadata.resource_version)
if event['type'] == 'ERROR':
print(event)
pod_name = obj.metadata.name
# Logging pod changes for debugging
with open('/tmp/pod_' + obj.metadata.name + '_' + obj.metadata.resource_version, 'w') as f:
f.write(yaml.dump(obj.to_dict()))
assert obj.kind == 'Pod'
if METADATA_WRITTEN_LABEL_KEY in obj.metadata.labels:
continue
# Skip TFX pods - they have their own metadata writers
if is_tfx_pod(obj):
continue
pipeline_name = obj.metadata.labels[PIPELINE_LABEL_KEY] # Should exist due to initial filtering
template = get_component_template(obj)
template_name = template['name']
component_name = template_name
component_version = component_name
output_name_to_type = {}
if KFP_COMPONENT_SPEC_ANNOTATION_KEY in obj.metadata.annotations:
component_spec_text = obj.metadata.annotations[KFP_COMPONENT_SPEC_ANNOTATION_KEY]
component_spec = json.loads(component_spec_text)
component_spec_digest = hashlib.sha256(component_spec_text.encode()).hexdigest()
component_name = component_spec.get('name', component_name)
component_version = component_name + '@sha256=' + component_spec_digest
output_name_to_type = {output['name']: output.get('type', None) for output in component_spec.get('outputs', [])}
output_name_to_type = {output_name_to_argo(k): v for k, v in output_name_to_type.items() if v}
if obj.metadata.name in pod_name_to_execution_id:
execution_id = pod_name_to_execution_id[obj.metadata.name]
context_id = workflow_name_to_context_id[pipeline_name]
elif METADATA_EXECUTION_ID_LABEL_KEY in obj.metadata.labels:
execution_id = int(obj.metadata.labels[METADATA_EXECUTION_ID_LABEL_KEY])
context_id = int(obj.metadata.labels[METADATA_CONTEXT_ID_LABEL_KEY])
print('Found execution id: {}, context id: {} for pod {}.'.format(execution_id, context_id, obj.metadata.name))
else:
run_context = get_or_create_run_context(
store=mlmd_store,
run_id=pipeline_name, # We can switch to internal run IDs once backend starts adding them
)
# Adding new execution to the database
execution = create_new_execution_in_existing_run_context(
store=mlmd_store,
context_id=run_context.id,
execution_type_name=KFP_EXECUTION_TYPE_NAME_PREFIX + component_version,
pod_name=pod_name,
pipeline_name=pipeline_name,
run_id=pipeline_name,
instance_id=component_name,
)
input_artifacts = template.get('inputs', {}).get('artifacts', [])
input_artifact_ids = []
for input_artifact in input_artifacts:
artifact_uri = artifact_to_uri(input_artifact)
if not artifact_uri:
continue
if PIPELINE_RUNTIME == "tekton":
input_name = input_artifact.get('name', '')
input_prefix = template_name + '-'
input_name = input_name[len(input_prefix):]
else:
input_name = input_artifact.get('path', '') # Every artifact should have a path in Argo
input_artifact_path_prefix = '/tmp/inputs/'
input_artifact_path_postfix = '/data'
if input_name.startswith(input_artifact_path_prefix):
input_name = input_name[len(input_artifact_path_prefix):]
if input_name.endswith(input_artifact_path_postfix):
input_name = input_name[0: -len(input_artifact_path_postfix)]
artifact = link_execution_to_input_artifact(
store=mlmd_store,
execution_id=execution.id,
uri=artifact_uri,
input_name=input_name,
)
if artifact is None:
# TODO: Maybe there is a better way to handle missing upstream artifacts
continue
input_artifact_ids.append(dict(
id=artifact.id,
name=input_name,
uri=artifact.uri,
))
print('Found Input Artifact: ' + str(dict(
input_name=input_name,
id=artifact.id,
uri=artifact.uri,
)))
execution_id = execution.id
context_id = run_context.id
obj.metadata.labels[METADATA_EXECUTION_ID_LABEL_KEY] = execution_id
obj.metadata.labels[METADATA_CONTEXT_ID_LABEL_KEY] = context_id
metadata_to_add = {
'labels': {
METADATA_EXECUTION_ID_LABEL_KEY: str(execution_id),
METADATA_CONTEXT_ID_LABEL_KEY: str(context_id),
},
'annotations': {
METADATA_INPUT_ARTIFACT_IDS_ANNOTATION_KEY: json.dumps(input_artifact_ids),
},
}
patch_pod_metadata(
namespace=obj.metadata.namespace,
pod_name=obj.metadata.name,
patch=metadata_to_add,
)
pod_name_to_execution_id[obj.metadata.name] = execution_id
workflow_name_to_context_id[pipeline_name] = context_id
print('New execution id: {}, context id: {} for pod {}.'.format(execution_id, context_id, obj.metadata.name))
print('Execution: ' + str(dict(
context_id=context_id,
context_name=pipeline_name,
execution_id=execution_id,
execution_name=obj.metadata.name,
component_name=component_name,
)))
# TODO: Log input parameters as execution options.
# Unfortunately, DSL compiler loses the information about inputs and their arguments.
if (
obj.metadata.name not in pods_with_written_metadata
and (
obj.metadata.labels.get(ARGO_COMPLETED_LABEL_KEY, 'false') == 'true'
or ARGO_OUTPUTS_ANNOTATION_KEY in obj.metadata.annotations
or TEKTON_OUTPUT_ARTIFACT_ANNOTATION_KEY in obj.metadata.annotations
)
):
artifact_ids = []
if ARGO_OUTPUTS_ANNOTATION_KEY in obj.metadata.annotations or TEKTON_OUTPUT_ARTIFACT_ANNOTATION_KEY in obj.metadata.annotations: # Should be present
outputs = get_output_template(obj)
pipeline_output_artifacts = {}
# Add logging as output artifacts if enabled.
archive_logs = os.environ.get('ARCHIVE_LOGS', 'false')
if archive_logs.lower() == 'true':
main_log_artifact = {
"name": "main-log",
"path": "/var/log/containers/",
"s3": {
"bucket": obj.metadata.annotations.get(TEKTON_BUCKET_ARTIFACT_ANNOTATION_KEY, "mlpipeline"),
"key": "artifacts/%s/%s/main-log.tgz" % (obj.metadata.labels[TEKTON_PIPELINERUN_LABEL_KEY],
obj.metadata.labels[TEKTON_PIPELINETASK_LABEL_KEY])
}
}
pipeline_output_artifacts['main-log'] = main_log_artifact
for artifact in outputs.get('artifacts', []):
art_name = artifact['name']
output_prefix = template_name + '-'
if art_name.startswith(output_prefix):
art_name = art_name[len(output_prefix):]
pipeline_output_artifacts[art_name] = artifact
output_artifacts = []
for name, art in pipeline_output_artifacts.items():
artifact_uri = artifact_to_uri(art)
if not artifact_uri:
continue
artifact_type_name = output_name_to_type.get(name, 'NoType') # Cannot be None or ''
print('Adding Output Artifact: ' + str(dict(
output_name=name,
uri=artifact_uri,
type=artifact_type_name,
)))
artifact = create_new_output_artifact(
store=mlmd_store,
execution_id=execution_id,
context_id=context_id,
uri=artifact_uri,
type_name=artifact_type_name,
output_name=name,
#run_id='Context_' + str(context_id) + '_run',
run_id=pipeline_name,
argo_artifact=art,
)
artifact_ids.append(dict(
id=artifact.id,
name=name,
uri=artifact_uri,
type=artifact_type_name,
))
metadata_to_add = {
'labels': {
METADATA_WRITTEN_LABEL_KEY: 'true',
},
'annotations': {
METADATA_OUTPUT_ARTIFACT_IDS_ANNOTATION_KEY: json.dumps(artifact_ids),
},
}
patch_pod_metadata(
namespace=obj.metadata.namespace,
pod_name=obj.metadata.name,
patch=metadata_to_add,
)
pods_with_written_metadata.add(obj.metadata.name)
except Exception as e:
import traceback
print(traceback.format_exc())
|
[] |
[] |
[
"PIPELINE_RUNTIME",
"NAMESPACE_TO_WATCH",
"ARCHIVE_LOGS"
] |
[]
|
["PIPELINE_RUNTIME", "NAMESPACE_TO_WATCH", "ARCHIVE_LOGS"]
|
python
| 3 | 0 | |
mmic_md_gmx/components/gmx_compute_component.py
|
# Import models
from ..models import InputComputeGmx, OutputComputeGmx
from cmselemental.util.decorators import classproperty
# Import components
from mmic_cmd.components import CmdComponent
from mmic.components.blueprints import GenericComponent
from typing import Dict, Any, List, Tuple, Optional
from pathlib import Path
import os
import shutil
import tempfile
import ntpath
__all__ = ["ComputeGmxComponent"]
class ComputeGmxComponent(GenericComponent):
@classproperty
def input(cls):
return InputComputeGmx
@classproperty
def output(cls):
return OutputComputeGmx
@classproperty
def version(cls) -> str:
"""Finds program, extracts version, returns normalized version string.
Returns
-------
str
Return a valid, safe python version string.
"""
return ""
def execute(
self,
inputs: InputComputeGmx,
extra_outfiles: Optional[List[str]] = None,
extra_commands: Optional[List[str]] = None,
scratch_name: Optional[str] = None,
timeout: Optional[int] = None,
) -> Tuple[bool, OutputComputeGmx]:
# Call gmx pdb2gmx, mdrun, etc. here
if isinstance(inputs, dict):
inputs = self.input(**inputs)
# Extract info from ComputeGmxInput
proc_input, mdp_file, gro_file, top_file = (
inputs.proc_input,
inputs.mdp_file,
inputs.molecule,
inputs.forcefield,
)
tpr_file = tempfile.NamedTemporaryFile(suffix=".tpr").name
# tpr file's name must be defined out of input builders
input_model = {
"proc_input": proc_input,
"mdp_file": mdp_file,
"gro_file": gro_file,
"top_file": top_file,
"tpr_file": tpr_file,
}
clean_files, cmd_input_grompp = self.build_input_grompp(input_model)
rvalue = CmdComponent.compute(cmd_input_grompp)
grompp_scratch_dir = [str(rvalue.scratch_directory)]
self.cleanup(clean_files) # Del mdp and top file in the working dir
self.cleanup([inputs.scratch_dir])
input_model = {"proc_input": proc_input, "tpr_file": tpr_file}
cmd_input_mdrun = self.build_input_mdrun(input_model)
rvalue = CmdComponent.compute(cmd_input_mdrun)
self.cleanup([tpr_file, gro_file])
self.cleanup(grompp_scratch_dir)
return True, self.parse_output(rvalue.dict(), proc_input)
@staticmethod
def cleanup(remove: List[str]):
for item in remove:
if os.path.isdir(item):
shutil.rmtree(item)
elif os.path.isfile(item):
os.remove(item)
def build_input_grompp(
self,
inputs: Dict[str, Any],
config: Optional["TaskConfig"] = None,
template: Optional[str] = None,
) -> Dict[str, Any]:
"""
Build the input for grompp
"""
assert inputs["proc_input"].engine == "gmx", "Engine must be gmx (Gromacs)!"
env = os.environ.copy()
if config:
env["MKL_NUM_THREADS"] = str(config.ncores)
env["OMP_NUM_THREADS"] = str(config.ncores)
scratch_directory = config.scratch_directory if config else None
tpr_file = inputs["tpr_file"]
clean_files = []
clean_files.append(inputs["mdp_file"])
clean_files.append(inputs["top_file"])
cmd = [
inputs["proc_input"].engine,
"grompp",
"-f",
inputs["mdp_file"],
"-c",
inputs["gro_file"],
"-p",
inputs["top_file"],
"-o",
tpr_file,
"-maxwarn",
"-1",
]
outfiles = [tpr_file]
return (
clean_files,
{
"command": cmd,
"as_binary": [tpr_file],
"infiles": [inputs["mdp_file"], inputs["gro_file"], inputs["top_file"]],
"outfiles": outfiles,
"outfiles_track": outfiles,
"scratch_directory": scratch_directory,
"environment": env,
"scratch_messy": True,
},
)
def build_input_mdrun(
self,
inputs: Dict[str, Any],
config: Optional["TaskConfig"] = None,
template: Optional[str] = None,
) -> Dict[str, Any]:
env = os.environ.copy()
if config:
env["MKL_NUM_THREADS"] = str(config.ncores)
env["OMP_NUM_THREADS"] = str(config.ncores)
scratch_directory = config.scratch_directory if config else None
log_file = tempfile.NamedTemporaryFile(suffix=".log").name
trr_file = tempfile.NamedTemporaryFile(suffix=".trr").name
edr_file = tempfile.NamedTemporaryFile(suffix=".edr").name
gro_file = tempfile.NamedTemporaryFile(suffix=".gro").name
tpr_file = inputs["tpr_file"]
tpr_fname = ntpath.basename(tpr_file)
cmd = [
inputs["proc_input"].engine, # Should here be gmx_mpi?
"mdrun",
"-s",
tpr_file, # input
"-o",
trr_file, # output
"-c",
gro_file, # output
"-e",
edr_file, # output
"-g",
log_file, # output
]
outfiles = [trr_file, gro_file, edr_file, log_file]
# For extra args
if inputs["proc_input"].keywords:
for key, val in inputs["proc_input"].keywords.items():
if val:
cmd.extend([key, val])
else:
cmd.extend([key])
return {
"command": cmd,
"as_binary": [tpr_fname, trr_file, edr_file],
"infiles": [tpr_file],
"outfiles": outfiles,
"outfiles_track": outfiles,
"scratch_directory": scratch_directory,
"environment": env,
"scratch_messy": True,
}
def parse_output(
self, output: Dict[str, str], inputs: Dict[str, Any]
) -> OutputComputeGmx:
# stdout = output["stdout"]
# stderr = output["stderr"]
outfiles = output["outfiles"]
scratch_dir = str(output["scratch_directory"])
traj, conf, energy, log = outfiles.keys()
# Deal with energy, log files later ... ?
self.cleanup([energy, log])
return self.output(
proc_input=inputs, molecule=conf, trajectory=traj, scratch_dir=scratch_dir
)
|
[] |
[] |
[] |
[]
|
[]
|
python
| 0 | 0 | |
selenium-junit4-examples/src/test/java/com/saucedemo/SimpleVisualE2ETest.java
|
package com.saucedemo;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.MutableCapabilities;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.RemoteWebDriver;
import java.net.URL;
import java.util.Map;
import static org.junit.Assert.assertEquals;
public class SimpleVisualE2ETest {
protected WebDriver webDriver;
public String sauceUsername = System.getenv("SAUCE_USERNAME");
public String sauceAccessKey = System.getenv("SAUCE_ACCESS_KEY");
public String screenerApiKey = System.getenv("SCREENER_API_KEY");
@Before
public void setUp() throws Exception {
MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability(CapabilityType.BROWSER_NAME, "chrome");
capabilities.setCapability(CapabilityType.BROWSER_VERSION, "latest");
capabilities.setCapability(CapabilityType.PLATFORM_NAME, "Windows 10");
MutableCapabilities sauceOptions = new MutableCapabilities();
sauceOptions.setCapability("username", sauceUsername);
sauceOptions.setCapability("accesskey", sauceAccessKey);
capabilities.setCapability("sauce:options", sauceOptions);
MutableCapabilities visualOptions = new MutableCapabilities();
visualOptions.setCapability("apiKey", screenerApiKey);
visualOptions.setCapability("projectName", "visual-e2e-test");
visualOptions.setCapability("viewportSize", "1280x1024");
capabilities.setCapability("sauce:visual", visualOptions);
URL url = new URL("https://hub.screener.io/wd/hub");
webDriver = new RemoteWebDriver(url, capabilities);
}
@Test
public void testVisualE2E() {
webDriver.get("https://screener.io");
JavascriptExecutor js = (JavascriptExecutor) webDriver;
js.executeScript("/*@visual.init*/", "My Visual Test 2");
js.executeScript("/*@visual.snapshot*/", "Home");
Map<String, Object> response = (Map<String, Object>) js.executeScript("/*@visual.end*/");
assertEquals( true, response.get("passed"));
}
}
|
[
"\"SAUCE_USERNAME\"",
"\"SAUCE_ACCESS_KEY\"",
"\"SCREENER_API_KEY\""
] |
[] |
[
"SAUCE_USERNAME",
"SAUCE_ACCESS_KEY",
"SCREENER_API_KEY"
] |
[]
|
["SAUCE_USERNAME", "SAUCE_ACCESS_KEY", "SCREENER_API_KEY"]
|
java
| 3 | 0 | |
vendor/github.com/openshift/origin/pkg/generate/app/sourcelookup.go
|
package app
import (
"errors"
"fmt"
"io/ioutil"
"net/url"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/docker/docker/builder/dockerfile/parser"
"github.com/golang/glog"
s2iapi "github.com/openshift/source-to-image/pkg/api"
s2igit "github.com/openshift/source-to-image/pkg/scm/git"
s2iutil "github.com/openshift/source-to-image/pkg/util"
kapi "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/validation"
buildapi "github.com/openshift/origin/pkg/build/api"
"github.com/openshift/origin/pkg/generate"
"github.com/openshift/origin/pkg/generate/git"
"github.com/openshift/origin/pkg/generate/source"
)
type Dockerfile interface {
AST() *parser.Node
Contents() string
}
func NewDockerfileFromFile(path string) (Dockerfile, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
if len(data) == 0 {
return nil, fmt.Errorf("Dockerfile %q is empty", path)
}
return NewDockerfile(string(data))
}
func NewDockerfile(contents string) (Dockerfile, error) {
if len(contents) == 0 {
return nil, errors.New("Dockerfile is empty")
}
node, err := parser.Parse(strings.NewReader(contents))
if err != nil {
return nil, err
}
return dockerfileContents{node, contents}, nil
}
type dockerfileContents struct {
ast *parser.Node
contents string
}
func (d dockerfileContents) AST() *parser.Node {
return d.ast
}
func (d dockerfileContents) Contents() string {
return d.contents
}
// IsPossibleSourceRepository checks whether the provided string is a source repository or not
func IsPossibleSourceRepository(s string) bool {
return IsRemoteRepository(s) || isDirectory(s)
}
// IsRemoteRepository checks whether the provided string is a remote repository or not
func IsRemoteRepository(s string) bool {
if !s2igit.New(s2iutil.NewFileSystem()).ValidCloneSpecRemoteOnly(s) {
glog.V(5).Infof("%s is not a valid remote git clone spec", s)
return false
}
url, err := url.Parse(s)
if err != nil {
glog.V(5).Infof("%s is not a valid url: %v", s, err)
return false
}
url.Fragment = ""
gitRepo := git.NewRepository()
if _, _, err := gitRepo.ListRemote(url.String()); err != nil {
glog.V(5).Infof("could not list git remotes for %s: %v", s, err)
return false
}
glog.V(5).Infof("%s is a valid remote git repository", s)
return true
}
// SourceRepository represents a code repository that may be the target of a build.
type SourceRepository struct {
location string
url url.URL
localDir string
remoteURL *url.URL
contextDir string
secrets []buildapi.SecretBuildSource
info *SourceRepositoryInfo
sourceImage ComponentReference
sourceImageFrom string
sourceImageTo string
usedBy []ComponentReference
strategy generate.Strategy
ignoreRepository bool
binary bool
forceAddDockerfile bool
requiresAuth bool
}
// NewSourceRepository creates a reference to a local or remote source code repository from
// a URL or path.
func NewSourceRepository(s string, strategy generate.Strategy) (*SourceRepository, error) {
location, err := git.ParseRepository(s)
if err != nil {
return nil, err
}
return &SourceRepository{
location: s,
url: *location,
strategy: strategy,
}, nil
}
// NewSourceRepositoryWithDockerfile creates a reference to a local source code repository with
// the provided relative Dockerfile path (defaults to "Dockerfile").
func NewSourceRepositoryWithDockerfile(s, dockerfilePath string) (*SourceRepository, error) {
r, err := NewSourceRepository(s, generate.StrategyDocker)
if err != nil {
return nil, err
}
if len(dockerfilePath) == 0 {
dockerfilePath = "Dockerfile"
}
f, err := NewDockerfileFromFile(filepath.Join(s, dockerfilePath))
if err != nil {
return nil, err
}
if r.info == nil {
r.info = &SourceRepositoryInfo{}
}
r.info.Dockerfile = f
return r, nil
}
// NewSourceRepositoryForDockerfile creates a source repository that is set up to use
// the contents of a Dockerfile as the input of the build.
func NewSourceRepositoryForDockerfile(contents string) (*SourceRepository, error) {
s := &SourceRepository{
ignoreRepository: true,
strategy: generate.StrategyDocker,
}
err := s.AddDockerfile(contents)
return s, err
}
// NewBinarySourceRepository creates a source repository that is configured for binary
// input.
func NewBinarySourceRepository(strategy generate.Strategy) *SourceRepository {
return &SourceRepository{
binary: true,
ignoreRepository: true,
strategy: strategy,
}
}
// TODO: this doesn't really match the others - this should likely be a different type of
// object that is associated with a build or component.
func NewImageSourceRepository(compRef ComponentReference, from, to string) *SourceRepository {
return &SourceRepository{
sourceImage: compRef,
sourceImageFrom: from,
sourceImageTo: to,
ignoreRepository: true,
location: compRef.Input().From,
strategy: generate.StrategySource,
}
}
// UsedBy sets up which component uses the source repository
func (r *SourceRepository) UsedBy(ref ComponentReference) {
r.usedBy = append(r.usedBy, ref)
}
// Remote checks whether the source repository is remote
func (r *SourceRepository) Remote() bool {
return r.url.Scheme != "file"
}
// InUse checks if the source repository is in use
func (r *SourceRepository) InUse() bool {
return len(r.usedBy) > 0
}
// SetStrategy sets the source repository strategy
func (r *SourceRepository) SetStrategy(strategy generate.Strategy) {
r.strategy = strategy
}
// GetStrategy returns the source repository strategy
func (r *SourceRepository) GetStrategy() generate.Strategy {
return r.strategy
}
func (r *SourceRepository) String() string {
return r.location
}
// Detect clones source locally if not already local and runs code detection
// with the given detector.
func (r *SourceRepository) Detect(d Detector, dockerStrategy bool) error {
if r.info != nil {
return nil
}
path, err := r.LocalPath()
if err != nil {
return err
}
r.info, err = d.Detect(path, dockerStrategy)
if err != nil {
return err
}
if err = r.DetectAuth(); err != nil {
return err
}
return nil
}
// SetInfo sets the source repository info. This is to facilitate certain tests.
func (r *SourceRepository) SetInfo(info *SourceRepositoryInfo) {
r.info = info
}
// Info returns the source repository info generated on code detection
func (r *SourceRepository) Info() *SourceRepositoryInfo {
return r.info
}
// LocalPath returns the local path of the source repository
func (r *SourceRepository) LocalPath() (string, error) {
if len(r.localDir) > 0 {
return r.localDir, nil
}
switch {
case r.url.Scheme == "file":
r.localDir = filepath.Join(r.url.Path, r.contextDir)
default:
gitRepo := git.NewRepository()
var err error
if r.localDir, err = ioutil.TempDir("", "gen"); err != nil {
return "", err
}
localURL, ref := cloneURLAndRef(&r.url)
r.localDir, err = CloneAndCheckoutSources(gitRepo, localURL.String(), ref, r.localDir, r.contextDir)
if err != nil {
return "", err
}
}
return r.localDir, nil
}
func cloneURLAndRef(url *url.URL) (*url.URL, string) {
localURL := *url
ref := localURL.Fragment
localURL.Fragment = ""
return &localURL, ref
}
// DetectAuth returns an error if the source repository cannot be cloned
// without the current user's environment. The following changes are made to the
// environment:
// 1) The HOME directory is set to a temporary dir to avoid loading any settings in .gitconfig
// 2) The GIT_SSH variable is set to /dev/null so the regular SSH keys are not used
// (changing the HOME directory is not enough).
// 3) GIT_CONFIG_NOSYSTEM prevents git from loading system-wide config
// 4) GIT_ASKPASS to prevent git from prompting for a user/password
func (r *SourceRepository) DetectAuth() error {
url, ok, err := r.RemoteURL()
if err != nil {
return err
}
if !ok {
return nil // No auth needed, we can't find a remote URL
}
tempHome, err := ioutil.TempDir("", "githome")
if err != nil {
return err
}
defer os.RemoveAll(tempHome)
tempSrc, err := ioutil.TempDir("", "gen")
if err != nil {
return err
}
defer os.RemoveAll(tempSrc)
env := []string{
fmt.Sprintf("HOME=%s", tempHome),
"GIT_SSH=/dev/null",
"GIT_CONFIG_NOSYSTEM=true",
"GIT_ASKPASS=true",
}
if runtime.GOOS == "windows" {
env = append(env,
fmt.Sprintf("ProgramData=%s", os.Getenv("ProgramData")),
fmt.Sprintf("SystemRoot=%s", os.Getenv("SystemRoot")),
)
}
gitRepo := git.NewRepositoryWithEnv(env)
localURL, ref := cloneURLAndRef(url)
_, err = CloneAndCheckoutSources(gitRepo, localURL.String(), ref, tempSrc, "")
if err != nil {
r.requiresAuth = true
}
return nil
}
// RemoteURL returns the remote URL of the source repository
func (r *SourceRepository) RemoteURL() (*url.URL, bool, error) {
if r.remoteURL != nil {
return r.remoteURL, true, nil
}
switch r.url.Scheme {
case "file":
gitRepo := git.NewRepository()
remote, ok, err := gitRepo.GetOriginURL(r.url.Path)
if err != nil && err != git.ErrGitNotAvailable {
return nil, false, err
}
if !ok {
return nil, ok, nil
}
ref := gitRepo.GetRef(r.url.Path)
if len(ref) > 0 {
remote = fmt.Sprintf("%s#%s", remote, ref)
}
if r.remoteURL, err = git.ParseRepository(remote); err != nil {
return nil, false, err
}
default:
r.remoteURL = &r.url
}
return r.remoteURL, true, nil
}
// SetContextDir sets the context directory to use for the source repository
func (r *SourceRepository) SetContextDir(dir string) {
r.contextDir = dir
}
// ContextDir returns the context directory of the source repository
func (r *SourceRepository) ContextDir() string {
return r.contextDir
}
// Secrets returns the secrets
func (r *SourceRepository) Secrets() []buildapi.SecretBuildSource {
return r.secrets
}
// SetSourceImage sets the source(input) image for a repository
func (r *SourceRepository) SetSourceImage(c ComponentReference) {
r.sourceImage = c
}
// SetSourceImagePath sets the source/destination to use when copying from the SourceImage
func (r *SourceRepository) SetSourceImagePath(source, dest string) {
r.sourceImageFrom = source
r.sourceImageTo = dest
}
// AddDockerfile adds the Dockerfile contents to the SourceRepository and
// configure it to build with Docker strategy. Returns an error if the contents
// are invalid.
func (r *SourceRepository) AddDockerfile(contents string) error {
dockerfile, err := NewDockerfile(contents)
if err != nil {
return err
}
if r.info == nil {
r.info = &SourceRepositoryInfo{}
}
r.info.Dockerfile = dockerfile
r.SetStrategy(generate.StrategyDocker)
r.forceAddDockerfile = true
return nil
}
// AddBuildSecrets adds the defined secrets into a build. The input format for
// the secrets is "<secretName>:<destinationDir>". The destinationDir is
// optional and when not specified the default is the current working directory.
func (r *SourceRepository) AddBuildSecrets(secrets []string) error {
injections := s2iapi.VolumeList{}
r.secrets = []buildapi.SecretBuildSource{}
for _, in := range secrets {
if err := injections.Set(in); err != nil {
return err
}
}
secretExists := func(name string) bool {
for _, s := range r.secrets {
if s.Secret.Name == name {
return true
}
}
return false
}
for _, in := range injections {
if r.GetStrategy() == generate.StrategyDocker && filepath.IsAbs(in.Destination) {
return fmt.Errorf("for the docker strategy, the secret destination directory %q must be a relative path", in.Destination)
}
if len(validation.ValidateSecretName(in.Source, false)) != 0 {
return fmt.Errorf("the %q must be valid secret name", in.Source)
}
if secretExists(in.Source) {
return fmt.Errorf("the %q secret can be used just once", in.Source)
}
r.secrets = append(r.secrets, buildapi.SecretBuildSource{
Secret: kapi.LocalObjectReference{Name: in.Source},
DestinationDir: in.Destination,
})
}
return nil
}
// SourceRepositories is a list of SourceRepository objects
type SourceRepositories []*SourceRepository
func (rr SourceRepositories) String() string {
repos := []string{}
for _, r := range rr {
repos = append(repos, r.String())
}
return strings.Join(repos, ",")
}
// NotUsed returns the list of SourceRepositories that are not used
func (rr SourceRepositories) NotUsed() SourceRepositories {
notUsed := SourceRepositories{}
for _, r := range rr {
if !r.InUse() {
notUsed = append(notUsed, r)
}
}
return notUsed
}
// SourceRepositoryInfo contains info about a source repository
type SourceRepositoryInfo struct {
Path string
Types []SourceLanguageType
Dockerfile Dockerfile
Jenkinsfile bool
}
// Terms returns which languages the source repository was
// built with
func (info *SourceRepositoryInfo) Terms() []string {
terms := []string{}
for i := range info.Types {
terms = append(terms, info.Types[i].Term())
}
return terms
}
// SourceLanguageType contains info about the type of the language
// a source repository is built in
type SourceLanguageType struct {
Platform string
Version string
}
// Term returns a search term for the given source language type
// the term will be in the form of language:version
func (t *SourceLanguageType) Term() string {
if len(t.Version) == 0 {
return t.Platform
}
return fmt.Sprintf("%s:%s", t.Platform, t.Version)
}
// Detector is an interface for detecting information about a
// source repository
type Detector interface {
Detect(dir string, dockerStrategy bool) (*SourceRepositoryInfo, error)
}
// SourceRepositoryEnumerator implements the Detector interface
type SourceRepositoryEnumerator struct {
Detectors source.Detectors
DockerfileTester generate.Tester
JenkinsfileTester generate.Tester
}
// Detect extracts source code information about the provided source repository
func (e SourceRepositoryEnumerator) Detect(dir string, noSourceDetection bool) (*SourceRepositoryInfo, error) {
info := &SourceRepositoryInfo{
Path: dir,
}
// no point in doing source-type detection if the requested build strategy
// is docker or pipeline
if !noSourceDetection {
for _, d := range e.Detectors {
if detected := d(dir); detected != nil {
info.Types = append(info.Types, SourceLanguageType{
Platform: detected.Platform,
Version: detected.Version,
})
}
}
}
if path, ok, err := e.DockerfileTester.Has(dir); err == nil && ok {
dockerfile, err := NewDockerfileFromFile(path)
if err != nil {
return nil, err
}
info.Dockerfile = dockerfile
}
if _, ok, err := e.JenkinsfileTester.Has(dir); err == nil && ok {
info.Jenkinsfile = true
}
return info, nil
}
// StrategyAndSourceForRepository returns the build strategy and source code reference
// of the provided source repository
// TODO: user should be able to choose whether to download a remote source ref for
// more info
func StrategyAndSourceForRepository(repo *SourceRepository, image *ImageRef) (*BuildStrategyRef, *SourceRef, error) {
strategy := &BuildStrategyRef{
Base: image,
Strategy: repo.strategy,
}
source := &SourceRef{
Binary: repo.binary,
Secrets: repo.secrets,
RequiresAuth: repo.requiresAuth,
}
if repo.sourceImage != nil {
srcImageRef, err := InputImageFromMatch(repo.sourceImage.Input().ResolvedMatch)
if err != nil {
return nil, nil, err
}
source.SourceImage = srcImageRef
source.ImageSourcePath = repo.sourceImageFrom
source.ImageDestPath = repo.sourceImageTo
}
if (repo.ignoreRepository || repo.forceAddDockerfile) && repo.Info() != nil && repo.Info().Dockerfile != nil {
source.DockerfileContents = repo.Info().Dockerfile.Contents()
}
if !repo.ignoreRepository {
remoteURL, ok, err := repo.RemoteURL()
if err != nil {
return nil, nil, fmt.Errorf("cannot obtain remote URL for repository at %s", repo.location)
}
if ok {
source.URL = remoteURL
source.Ref = remoteURL.Fragment
} else {
source.Binary = true
}
source.ContextDir = repo.ContextDir()
}
return strategy, source, nil
}
// CloneAndCheckoutSources clones the remote repository using either regular
// git clone operation or shallow git clone, based on the "ref" provided (you
// cannot shallow clone using the 'ref').
// This function will return the full path to the buildable sources, including
// the context directory if specified.
func CloneAndCheckoutSources(repo git.Repository, remote, ref, localDir, contextDir string) (string, error) {
if len(ref) == 0 {
glog.V(5).Infof("No source ref specified, using shallow git clone")
if err := repo.CloneWithOptions(localDir, remote, git.Shallow, "--recursive"); err != nil {
return "", fmt.Errorf("shallow cloning repository %q to %q failed: %v", remote, localDir, err)
}
} else {
glog.V(5).Infof("Requested ref %q, performing full git clone and git checkout", ref)
if err := repo.Clone(localDir, remote); err != nil {
return "", fmt.Errorf("cloning repository %q to %q failed: %v", remote, localDir, err)
}
}
if len(ref) > 0 {
if err := repo.Checkout(localDir, ref); err != nil {
return "", fmt.Errorf("unable to checkout ref %q in %q repository: %v", ref, remote, err)
}
}
if len(contextDir) > 0 {
glog.V(5).Infof("Using context directory %q. The full source path is %q", contextDir, filepath.Join(localDir, contextDir))
}
return filepath.Join(localDir, contextDir), nil
}
|
[
"\"ProgramData\"",
"\"SystemRoot\""
] |
[] |
[
"SystemRoot",
"ProgramData"
] |
[]
|
["SystemRoot", "ProgramData"]
|
go
| 2 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.