file_name
large_stringlengths 4
140
| prefix
large_stringlengths 0
12.1k
| suffix
large_stringlengths 0
12k
| middle
large_stringlengths 0
7.51k
| fim_type
large_stringclasses 4
values |
|---|---|---|---|---|
index.ts | (v: T) => TResult | Promise<TResult>,
onRejected?: (reason: any) => Promise<never>,
): Promise<TResult> {
return this._promise.then<TResult>(onFulfilled, onRejected);
}
public catch<TResult>(onRejected?: (reason: any) => Promise<TResult>): Promise<TResult | T> {
return this._promise.catch(onRejected);
}
public finally(onFinally?: (() => void) | null): Promise<T> {
return this._promise.finally(onFinally);
}
// tslint:enable:promise-function-async
// tslint:enable:async-suffix
get [Symbol.toStringTag](): 'Promise' {
return this._promise[Symbol.toStringTag];
}
}
export class | {
protected _abiEncoderByFunctionSignature: AbiEncoderByFunctionSignature;
protected _web3Wrapper: Web3Wrapper;
public abi: ContractAbi;
public address: string;
public contractName: string;
public constructorArgs: any[] = [];
public _deployedBytecodeIfExists?: Buffer;
private _evmIfExists?: VM;
private _evmAccountIfExists?: Buffer;
protected static _formatABIDataItemList(
abis: DataItem[],
values: any[],
formatter: (type: string, value: any) => any,
): any {
return values.map((value: any, i: number) => formatABIDataItem(abis[i], value, formatter));
}
protected static _lowercaseAddress(type: string, value: string): string {
return type === 'address' ? value.toLowerCase() : value;
}
protected static _bigNumberToString(_type: string, value: any): any {
return BigNumber.isBigNumber(value) ? value.toString() : value;
}
protected static _lookupConstructorAbi(abi: ContractAbi): ConstructorAbi {
const constructorAbiIfExists = abi.find(
(abiDefinition: AbiDefinition) => abiDefinition.type === AbiType.Constructor,
// tslint:disable-next-line:no-unnecessary-type-assertion
) as ConstructorAbi | undefined;
if (constructorAbiIfExists !== undefined) {
return constructorAbiIfExists;
} else {
// If the constructor is not explicitly defined, it won't be included in the ABI. It is
// still callable however, so we construct what the ABI would look like were it to exist.
const defaultConstructorAbi: ConstructorAbi = {
type: AbiType.Constructor,
stateMutability: 'nonpayable',
payable: false,
inputs: [],
};
return defaultConstructorAbi;
}
}
protected static _throwIfCallResultIsRevertError(rawCallResult: string): void {
// Try to decode the call result as a revert error.
let revert: RevertError;
try {
revert = decodeBytesAsRevertError(rawCallResult);
} catch (err) {
// Can't decode it as a revert error, so assume it didn't revert.
return;
}
throw revert;
}
protected static _throwIfThrownErrorIsRevertError(error: Error): void {
// Try to decode a thrown error.
let revertError: RevertError;
try {
revertError = decodeThrownErrorAsRevertError(error);
} catch (err) {
// Can't decode it.
return;
}
// Re-cast StringRevertErrors as plain Errors for backwards-compatibility.
if (revertError instanceof StringRevertError) {
throw new Error(revertError.values.message as string);
}
throw revertError;
}
protected static _throwIfUnexpectedEmptyCallResult(rawCallResult: string, methodAbi: AbiEncoder.Method): void {
// With live nodes, we will receive an empty call result if:
// 1. The function has no return value.
// 2. The contract reverts without data.
// 3. The contract reverts with an invalid opcode (`assert(false)` or `invalid()`).
if (!rawCallResult || rawCallResult === '0x') {
const returnValueDataItem = methodAbi.getReturnValueDataItem();
if (returnValueDataItem.components === undefined || returnValueDataItem.components.length === 0) {
// Expected no result (which makes it hard to tell if the call reverted).
return;
}
throw new Error(`Function "${methodAbi.getSignature()}" reverted with no data`);
}
}
// Throws if the given arguments cannot be safely/correctly encoded based on
// the given inputAbi. An argument may not be considered safely encodeable
// if it overflows the corresponding Solidity type, there is a bug in the
// encoder, or the encoder performs unsafe type coercion.
public static strictArgumentEncodingCheck(inputAbi: DataItem[], args: any[]): string {
const abiEncoder = AbiEncoder.create(inputAbi);
const params = abiUtils.parseEthersParams(inputAbi);
const rawEncoded = abiEncoder.encode(args);
const rawDecoded = abiEncoder.decodeAsArray(rawEncoded);
for (let i = 0; i < rawDecoded.length; i++) {
const original = args[i];
const decoded = rawDecoded[i];
if (!abiUtils.isAbiDataEqual(params.names[i], params.types[i], original, decoded)) {
throw new Error(
`Cannot safely encode argument: ${params.names[i]} (${original}) of type ${
params.types[i]
}. (Possible type overflow or other encoding error)`,
);
}
}
return rawEncoded;
}
protected static async _applyDefaultsToContractTxDataAsync<T extends Partial<TxData | TxDataPayable>>(
txData: T,
estimateGasAsync?: (txData: T) => Promise<number>,
): Promise<TxData> {
const txDataWithDefaults = BaseContract._removeUndefinedProperties<T>(txData);
if (txDataWithDefaults.gas === undefined && estimateGasAsync !== undefined) {
txDataWithDefaults.gas = await estimateGasAsync(txDataWithDefaults);
}
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
return txDataWithDefaults as TxData;
}
protected static _assertCallParams(callData: Partial<CallData>, defaultBlock?: BlockParam): void {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
schemas.jsNumber,
]);
if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock);
}
}
private static _removeUndefinedProperties<T>(props: any): T {
const clonedProps = { ...props };
Object.keys(clonedProps).forEach(key => clonedProps[key] === undefined && delete clonedProps[key]);
return clonedProps;
}
protected _promiseWithTransactionHash(
txHashPromise: Promise<string>,
opts: AwaitTransactionSuccessOpts,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return this._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
opts.pollingIntervalMs,
opts.timeoutMs,
);
})(),
);
}
protected async _applyDefaultsToTxDataAsync<T extends Partial<TxData | TxDataPayable>>(
txData: T,
estimateGasAsync?: (txData: T) => Promise<number>,
): Promise<TxData> {
// Gas amount sourced with the following priorities:
// 1. Optional param passed in to public method call
// 2. Global config passed in at library instantiation
// 3. Gas estimate calculation + safety margin
// tslint:disable-next-line:no-object-literal-type-assertion
const txDataWithDefaults = {
to: this.address,
...this._web3Wrapper.getContractDefaults(),
...BaseContract._removeUndefinedProperties(txData),
} as T;
if (txDataWithDefaults.gas === undefined && estimateGasAsync !== undefined) {
txDataWithDefaults.gas = await estimateGasAsync(txDataWithDefaults);
}
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
return txDataWithDefaults as TxData;
}
protected async _evmExecAsync(encodedData: string): Promise<string> {
const encodedDataBytes = Buffer.from(encodedData.substr(2), 'hex');
const addressBuf = Buffer.from(this.address.substr(2), 'hex');
// should only run once, the first time it is called
if (this._evmIfExists === undefined) {
const vm = new VM({});
const psm = new PStateManager(vm.stateManager);
// create an account with 1 ETH
const accountPk = Buffer.from(ARBITRARY_PRIVATE_KEY, 'hex');
const accountAddress = util.privateToAddress(accountPk);
const account = new Account({ balance: 1e18 });
await psm.putAccount(accountAddress, account);
// 'deploy' the contract
if (this._deployedBytecodeIfExists === undefined | BaseContract | identifier_name |
index.ts | ContractEvent,
SendTransactionOpts,
AwaitTransactionSuccessOpts,
ContractFunctionObj,
ContractTxFunctionObj,
SubscriptionErrors,
} from './types';
export interface AbiEncoderByFunctionSignature {
[key: string]: AbiEncoder.Method;
}
const ARBITRARY_PRIVATE_KEY = 'e331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109';
// tslint:disable: max-classes-per-file
/**
* @dev A promise-compatible type that exposes a `txHash` field.
* Not used by BaseContract, but generated contracts will return it in
* `awaitTransactionSuccessAsync()`.
* Maybe there's a better place for this.
*/
export class PromiseWithTransactionHash<T> implements Promise<T> {
public readonly txHashPromise: Promise<string>;
private readonly _promise: Promise<T>;
constructor(txHashPromise: Promise<string>, promise: Promise<T>) {
this.txHashPromise = txHashPromise;
this._promise = promise;
}
// tslint:disable:promise-function-async
// tslint:disable:async-suffix
public then<TResult>(
onFulfilled?: (v: T) => TResult | Promise<TResult>,
onRejected?: (reason: any) => Promise<never>,
): Promise<TResult> {
return this._promise.then<TResult>(onFulfilled, onRejected);
}
public catch<TResult>(onRejected?: (reason: any) => Promise<TResult>): Promise<TResult | T> {
return this._promise.catch(onRejected);
}
public finally(onFinally?: (() => void) | null): Promise<T> {
return this._promise.finally(onFinally);
}
// tslint:enable:promise-function-async
// tslint:enable:async-suffix
get [Symbol.toStringTag](): 'Promise' {
return this._promise[Symbol.toStringTag];
}
}
export class BaseContract {
protected _abiEncoderByFunctionSignature: AbiEncoderByFunctionSignature;
protected _web3Wrapper: Web3Wrapper;
public abi: ContractAbi;
public address: string;
public contractName: string;
public constructorArgs: any[] = [];
public _deployedBytecodeIfExists?: Buffer;
private _evmIfExists?: VM;
private _evmAccountIfExists?: Buffer;
protected static _formatABIDataItemList(
abis: DataItem[],
values: any[],
formatter: (type: string, value: any) => any,
): any {
return values.map((value: any, i: number) => formatABIDataItem(abis[i], value, formatter));
}
protected static _lowercaseAddress(type: string, value: string): string {
return type === 'address' ? value.toLowerCase() : value;
}
protected static _bigNumberToString(_type: string, value: any): any {
return BigNumber.isBigNumber(value) ? value.toString() : value;
}
protected static _lookupConstructorAbi(abi: ContractAbi): ConstructorAbi {
const constructorAbiIfExists = abi.find(
(abiDefinition: AbiDefinition) => abiDefinition.type === AbiType.Constructor,
// tslint:disable-next-line:no-unnecessary-type-assertion
) as ConstructorAbi | undefined;
if (constructorAbiIfExists !== undefined) {
return constructorAbiIfExists;
} else {
// If the constructor is not explicitly defined, it won't be included in the ABI. It is
// still callable however, so we construct what the ABI would look like were it to exist.
const defaultConstructorAbi: ConstructorAbi = {
type: AbiType.Constructor,
stateMutability: 'nonpayable',
payable: false,
inputs: [],
};
return defaultConstructorAbi;
}
}
protected static _throwIfCallResultIsRevertError(rawCallResult: string): void {
// Try to decode the call result as a revert error.
let revert: RevertError;
try {
revert = decodeBytesAsRevertError(rawCallResult);
} catch (err) {
// Can't decode it as a revert error, so assume it didn't revert.
return;
}
throw revert;
}
protected static _throwIfThrownErrorIsRevertError(error: Error): void {
// Try to decode a thrown error.
let revertError: RevertError;
try {
revertError = decodeThrownErrorAsRevertError(error);
} catch (err) {
// Can't decode it.
return;
}
// Re-cast StringRevertErrors as plain Errors for backwards-compatibility.
if (revertError instanceof StringRevertError) {
throw new Error(revertError.values.message as string);
}
throw revertError;
}
protected static _throwIfUnexpectedEmptyCallResult(rawCallResult: string, methodAbi: AbiEncoder.Method): void {
// With live nodes, we will receive an empty call result if:
// 1. The function has no return value.
// 2. The contract reverts without data.
// 3. The contract reverts with an invalid opcode (`assert(false)` or `invalid()`).
if (!rawCallResult || rawCallResult === '0x') {
const returnValueDataItem = methodAbi.getReturnValueDataItem();
if (returnValueDataItem.components === undefined || returnValueDataItem.components.length === 0) {
// Expected no result (which makes it hard to tell if the call reverted).
return;
}
throw new Error(`Function "${methodAbi.getSignature()}" reverted with no data`);
}
}
// Throws if the given arguments cannot be safely/correctly encoded based on
// the given inputAbi. An argument may not be considered safely encodeable
// if it overflows the corresponding Solidity type, there is a bug in the
// encoder, or the encoder performs unsafe type coercion.
public static strictArgumentEncodingCheck(inputAbi: DataItem[], args: any[]): string {
const abiEncoder = AbiEncoder.create(inputAbi);
const params = abiUtils.parseEthersParams(inputAbi);
const rawEncoded = abiEncoder.encode(args);
const rawDecoded = abiEncoder.decodeAsArray(rawEncoded);
for (let i = 0; i < rawDecoded.length; i++) {
const original = args[i];
const decoded = rawDecoded[i];
if (!abiUtils.isAbiDataEqual(params.names[i], params.types[i], original, decoded)) {
throw new Error(
`Cannot safely encode argument: ${params.names[i]} (${original}) of type ${
params.types[i]
}. (Possible type overflow or other encoding error)`,
);
}
}
return rawEncoded;
}
protected static async _applyDefaultsToContractTxDataAsync<T extends Partial<TxData | TxDataPayable>>(
txData: T,
estimateGasAsync?: (txData: T) => Promise<number>,
): Promise<TxData> {
const txDataWithDefaults = BaseContract._removeUndefinedProperties<T>(txData);
if (txDataWithDefaults.gas === undefined && estimateGasAsync !== undefined) {
txDataWithDefaults.gas = await estimateGasAsync(txDataWithDefaults);
}
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
return txDataWithDefaults as TxData;
}
protected static _assertCallParams(callData: Partial<CallData>, defaultBlock?: BlockParam): void {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
schemas.jsNumber,
]);
if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock);
}
}
private static _removeUndefinedProperties<T>(props: any): T {
const clonedProps = { ...props };
Object.keys(clonedProps).forEach(key => clonedProps[key] === undefined && delete clonedProps[key]);
return clonedProps;
}
protected _promiseWithTransactionHash(
txHashPromise: Promise<string>,
opts: AwaitTransactionSuccessOpts,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return this._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
opts.pollingIntervalMs,
opts.timeoutMs,
);
})(),
);
}
protected async _applyDefaultsToTxDataAsync<T extends Partial<TxData | TxDataPayable>>(
txData: T,
estimateGasAsync?: (txData: T) => Promise<number>,
): Promise<TxData> {
// Gas amount sourced with the following priorities:
// 1. Optional param passed in to public method call
// 2. Global config passed in at library instantiation
// 3. Gas estimate calculation + safety margin
// tslint:disable-next-line:no-object-literal-type-assertion
const txDataWithDefaults = {
to: this.address,
...this._ | export { | random_line_split |
|
cluster.go | PgStorageSpec `json:replicastorage`
BackrestStorage PgStorageSpec `json:backreststorage`
// Resources behaves just like the "Requests" section of a Kubernetes
// container definition. You can set individual items such as "cpu" and
// "memory", e.g. "{ cpu: "0.5", memory: "2Gi" }"
Resources v1.ResourceList `json:"resources"`
// Limits stores the CPU/memory limits to use with PostgreSQL instances
//
// A long note on memory limits.
//
// We want to avoid the OOM killer coming for the PostgreSQL process or any
// of their backends per lots of guidance from the PostgreSQL documentation.
// Based on Kubernetes' behavior with limits, the best thing is to not set
// them. However, if they ever do set, we suggest that you have
// Request == Limit to get the Guaranteed QoS
//
// Guaranteed QoS prevents a backend from being first in line to be killed if
// the *Node* has memory pressure, but if there is, say
// a runaway client backend that causes the *Pod* to exceed its memory
// limit, a backend can still be killed by the OOM killer, which is not
// great.
//
// As such, given the choice, the preference is for the Pod to be evicted
// and have a failover event, vs. having an individual client backend killed
// and causing potential "bad things."
//
// For more info on PostgreSQL and Kubernetes memory management, see:
//
// https://www.postgresql.org/docs/current/kernel-resources.html#LINUX-MEMORY-OVERCOMMIT
// https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/#how-pods-with-resource-limits-are-run
Limits v1.ResourceList `json:"limits"`
// BackrestResources, if specified, contains the container request resources
// for the pgBackRest Deployment for this PostgreSQL cluster
BackrestResources v1.ResourceList `json:"backrestResources"`
// BackrestLimits, if specified, contains the container resource limits
// for the pgBackRest Deployment for this PostgreSQL cluster
BackrestLimits v1.ResourceList `json:"backrestLimits"`
// PgBouncer contains all of the settings to properly maintain a pgBouncer
// implementation
PgBouncer PgBouncerSpec `json:"pgBouncer"`
User string `json:"user"`
Database string `json:"database"`
Replicas string `json:"replicas"`
UserSecretName string `json:"usersecretname"`
RootSecretName string `json:"rootsecretname"`
PrimarySecretName string `json:"primarysecretname"`
CollectSecretName string `json:"collectSecretName"`
Status string `json:"status"`
CustomConfig string `json:"customconfig"`
UserLabels map[string]string `json:"userlabels"`
PodAntiAffinity PodAntiAffinitySpec `json:"podAntiAffinity"`
SyncReplication *bool `json:"syncReplication"`
BackrestS3Bucket string `json:"backrestS3Bucket"`
BackrestS3Region string `json:"backrestS3Region"`
BackrestS3Endpoint string `json:"backrestS3Endpoint"`
BackrestS3URIStyle string `json:"backrestS3URIStyle"`
BackrestS3VerifyTLS string `json:"backrestS3VerifyTLS"`
BackrestRepoPath string `json:"backrestRepoPath"`
TablespaceMounts map[string]PgStorageSpec `json:"tablespaceMounts"`
TLS TLSSpec `json:"tls"`
TLSOnly bool `json:"tlsOnly"`
Standby bool `json:"standby"`
Shutdown bool `json:"shutdown"`
PGDataSource PGDataSourceSpec `json:"pgDataSource"`
}
// PGDataSourceSpec defines the data source that should be used to populate the initial PGDATA
// directory when bootstrapping a new PostgreSQL cluster
// swagger:ignore
type PGDataSourceSpec struct {
RestoreFrom string `json:"restoreFrom"`
RestoreOpts string `json:"restoreOpts"`
}
// PgclusterList is the CRD that defines a Crunchy PG Cluster List
// swagger:ignore
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
type PgclusterList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata"`
Items []Pgcluster `json:"items"`
}
// PgclusterStatus is the CRD that defines PG Cluster Status
// swagger:ignore
type PgclusterStatus struct {
State PgclusterState `json:"state,omitempty"`
Message string `json:"message,omitempty"`
}
// PgclusterState is the crd that defines PG Cluster Stage
// swagger:ignore
type PgclusterState string
// PodAntiAffinityDeployment distinguishes between the different types of
// Deployments that can leverage PodAntiAffinity
type PodAntiAffinityDeployment int
// PodAntiAffinityType defines the different types of type of anti-affinity rules applied to pg
// clusters when utilizing the default pod anti-affinity rules provided by the PostgreSQL Operator,
// which are enabled for a new pg cluster by default. Valid Values include "required" for
// requiredDuringSchedulingIgnoredDuringExecution anti-affinity, "preferred" for
// preferredDuringSchedulingIgnoredDuringExecution anti-affinity, and "disabled" to disable the
// default pod anti-affinity rules for the pg cluster all together.
type PodAntiAffinityType string
// PodAntiAffinitySpec provides multiple configurations for how pod
// anti-affinity can be set.
// - "Default" is the default rule that applies to all Pods that are a part of
// the PostgreSQL cluster
// - "PgBackrest" applies just to the pgBackRest repository Pods in said
// Deployment
// - "PgBouncer" applies to just pgBouncer Pods in said Deployment
// swaggier:ignore
type PodAntiAffinitySpec struct {
Default PodAntiAffinityType `json:"default"`
PgBackRest PodAntiAffinityType `json:"pgBackRest"`
PgBouncer PodAntiAffinityType `json:"pgBouncer"`
}
// PgBouncerSpec is a struct that is used within the Cluster specification that
// provides the attributes for managing a PgBouncer implementation, including:
// - is it enabled?
// - what resources it should consume
// - the total number of replicas
type PgBouncerSpec struct {
// Replicas represents the total number of Pods to deploy with pgBouncer,
// which effectively enables/disables the pgBouncer.
//
// if it is set to 0 or less, it is disabled.
//
// if it is set to 1 or more, it is enabled
Replicas int32 `json:"replicas"`
// Resources, if specified, contains the container request resources
// for any pgBouncer Deployments that are part of a PostgreSQL cluster
Resources v1.ResourceList `json:"resources"`
// Limits, if specified, contains the container resource limits
// for any pgBouncer Deployments that are part of a PostgreSQL cluster
Limits v1.ResourceList `json:"limits"`
}
// Enabled returns true if the pgBouncer is enabled for the cluster, i.e. there
// is at least one replica set
func (s *PgBouncerSpec) Enabled() bool {
return s.Replicas > 0
}
// TLSSpec contains the information to set up a TLS-enabled PostgreSQL cluster
type TLSSpec struct {
// CASecret contains the name of the secret to use as the trusted CA for the
// TLSSecret
// This is our own format and should contain at least one key: "ca.crt"
// It can also contain a key "ca.crl" which is the certificate revocation list
CASecret string `json:"caSecret"`
// ReplicationTLSSecret contains the name of the secret that specifies a TLS
// keypair that can be used by the replication user (e.g. "primaryuser") to
// perform certificate based authentication between replicas.
// The keypair must be considered valid by the CA specified in the CASecret
ReplicationTLSSecret string `json:"replicationTLSSecret"`
// TLSSecret contains the name of the secret to use that contains the TLS
// keypair for the PostgreSQL server
// This follows the Kubernetes secret format ("kubernetes.io/tls") which has
// two keys: tls.crt and tls.key
TLSSecret string `json:"tlsSecret"`
}
// IsTLSEnabled returns true if the cluster is TLS enabled, i.e. both the TLS
// secret name and the CA secret name are available
func (t TLSSpec) IsTLSEnabled() bool {
return (t.TLSSecret != "" && t.CASecret != "")
}
const (
// PgclusterStateCreated ...
PgclusterStateCreated PgclusterState = "pgcluster Created"
// PgclusterStateProcessed ...
PgclusterStateProcessed PgclusterState = "pgcluster Processed"
// PgclusterStateInitialized ...
PgclusterStateInitialized PgclusterState = "pgcluster Initialized" | random_line_split |
||
cluster.go | badgerport"`
ExporterPort string `json:"exporterport"`
PrimaryStorage PgStorageSpec `json:primarystorage`
WALStorage PgStorageSpec `json:walstorage`
ArchiveStorage PgStorageSpec `json:archivestorage`
ReplicaStorage PgStorageSpec `json:replicastorage`
BackrestStorage PgStorageSpec `json:backreststorage`
// Resources behaves just like the "Requests" section of a Kubernetes
// container definition. You can set individual items such as "cpu" and
// "memory", e.g. "{ cpu: "0.5", memory: "2Gi" }"
Resources v1.ResourceList `json:"resources"`
// Limits stores the CPU/memory limits to use with PostgreSQL instances
//
// A long note on memory limits.
//
// We want to avoid the OOM killer coming for the PostgreSQL process or any
// of their backends per lots of guidance from the PostgreSQL documentation.
// Based on Kubernetes' behavior with limits, the best thing is to not set
// them. However, if they ever do set, we suggest that you have
// Request == Limit to get the Guaranteed QoS
//
// Guaranteed QoS prevents a backend from being first in line to be killed if
// the *Node* has memory pressure, but if there is, say
// a runaway client backend that causes the *Pod* to exceed its memory
// limit, a backend can still be killed by the OOM killer, which is not
// great.
//
// As such, given the choice, the preference is for the Pod to be evicted
// and have a failover event, vs. having an individual client backend killed
// and causing potential "bad things."
//
// For more info on PostgreSQL and Kubernetes memory management, see:
//
// https://www.postgresql.org/docs/current/kernel-resources.html#LINUX-MEMORY-OVERCOMMIT
// https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/#how-pods-with-resource-limits-are-run
Limits v1.ResourceList `json:"limits"`
// BackrestResources, if specified, contains the container request resources
// for the pgBackRest Deployment for this PostgreSQL cluster
BackrestResources v1.ResourceList `json:"backrestResources"`
// BackrestLimits, if specified, contains the container resource limits
// for the pgBackRest Deployment for this PostgreSQL cluster
BackrestLimits v1.ResourceList `json:"backrestLimits"`
// PgBouncer contains all of the settings to properly maintain a pgBouncer
// implementation
PgBouncer PgBouncerSpec `json:"pgBouncer"`
User string `json:"user"`
Database string `json:"database"`
Replicas string `json:"replicas"`
UserSecretName string `json:"usersecretname"`
RootSecretName string `json:"rootsecretname"`
PrimarySecretName string `json:"primarysecretname"`
CollectSecretName string `json:"collectSecretName"`
Status string `json:"status"`
CustomConfig string `json:"customconfig"`
UserLabels map[string]string `json:"userlabels"`
PodAntiAffinity PodAntiAffinitySpec `json:"podAntiAffinity"`
SyncReplication *bool `json:"syncReplication"`
BackrestS3Bucket string `json:"backrestS3Bucket"`
BackrestS3Region string `json:"backrestS3Region"`
BackrestS3Endpoint string `json:"backrestS3Endpoint"`
BackrestS3URIStyle string `json:"backrestS3URIStyle"`
BackrestS3VerifyTLS string `json:"backrestS3VerifyTLS"`
BackrestRepoPath string `json:"backrestRepoPath"`
TablespaceMounts map[string]PgStorageSpec `json:"tablespaceMounts"`
TLS TLSSpec `json:"tls"`
TLSOnly bool `json:"tlsOnly"`
Standby bool `json:"standby"`
Shutdown bool `json:"shutdown"`
PGDataSource PGDataSourceSpec `json:"pgDataSource"`
}
// PGDataSourceSpec defines the data source that should be used to populate the initial PGDATA
// directory when bootstrapping a new PostgreSQL cluster
// swagger:ignore
type PGDataSourceSpec struct {
RestoreFrom string `json:"restoreFrom"`
RestoreOpts string `json:"restoreOpts"`
}
// PgclusterList is the CRD that defines a Crunchy PG Cluster List
// swagger:ignore
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
type PgclusterList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata"`
Items []Pgcluster `json:"items"`
}
// PgclusterStatus is the CRD that defines PG Cluster Status
// swagger:ignore
type PgclusterStatus struct {
State PgclusterState `json:"state,omitempty"`
Message string `json:"message,omitempty"`
}
// PgclusterState is the crd that defines PG Cluster Stage
// swagger:ignore
type PgclusterState string
// PodAntiAffinityDeployment distinguishes between the different types of
// Deployments that can leverage PodAntiAffinity
type PodAntiAffinityDeployment int
// PodAntiAffinityType defines the different types of type of anti-affinity rules applied to pg
// clusters when utilizing the default pod anti-affinity rules provided by the PostgreSQL Operator,
// which are enabled for a new pg cluster by default. Valid Values include "required" for
// requiredDuringSchedulingIgnoredDuringExecution anti-affinity, "preferred" for
// preferredDuringSchedulingIgnoredDuringExecution anti-affinity, and "disabled" to disable the
// default pod anti-affinity rules for the pg cluster all together.
type PodAntiAffinityType string
// PodAntiAffinitySpec provides multiple configurations for how pod
// anti-affinity can be set.
// - "Default" is the default rule that applies to all Pods that are a part of
// the PostgreSQL cluster
// - "PgBackrest" applies just to the pgBackRest repository Pods in said
// Deployment
// - "PgBouncer" applies to just pgBouncer Pods in said Deployment
// swaggier:ignore
type PodAntiAffinitySpec struct {
Default PodAntiAffinityType `json:"default"`
PgBackRest PodAntiAffinityType `json:"pgBackRest"`
PgBouncer PodAntiAffinityType `json:"pgBouncer"`
}
// PgBouncerSpec is a struct that is used within the Cluster specification that
// provides the attributes for managing a PgBouncer implementation, including:
// - is it enabled?
// - what resources it should consume
// - the total number of replicas
type PgBouncerSpec struct {
// Replicas represents the total number of Pods to deploy with pgBouncer,
// which effectively enables/disables the pgBouncer.
//
// if it is set to 0 or less, it is disabled.
//
// if it is set to 1 or more, it is enabled
Replicas int32 `json:"replicas"`
// Resources, if specified, contains the container request resources
// for any pgBouncer Deployments that are part of a PostgreSQL cluster
Resources v1.ResourceList `json:"resources"`
// Limits, if specified, contains the container resource limits
// for any pgBouncer Deployments that are part of a PostgreSQL cluster
Limits v1.ResourceList `json:"limits"`
}
// Enabled returns true if the pgBouncer is enabled for the cluster, i.e. there
// is at least one replica set
func (s *PgBouncerSpec) Enabled() bool {
return s.Replicas > 0
}
// TLSSpec contains the information to set up a TLS-enabled PostgreSQL cluster
type TLSSpec struct {
// CASecret contains the name of the secret to use as the trusted CA for the
// TLSSecret
// This is our own format and should contain at least one key: "ca.crt"
// It can also contain a key "ca.crl" which is the certificate revocation list
CASecret string `json:"caSecret"`
// ReplicationTLSSecret contains the name of the secret that specifies a TLS
// keypair that can be used by the replication user (e.g. "primaryuser") to
// perform certificate based authentication between replicas.
// The keypair must be considered valid by the CA specified in the CASecret
ReplicationTLSSecret string `json:"replicationTLSSecret"`
// TLSSecret contains the name of the secret to use that contains the TLS
// keypair for the PostgreSQL server
// This follows the Kubernetes secret format ("kubernetes.io/tls") which has
// two keys: tls.crt and tls.key
TLSSecret string `json:"tlsSecret"`
}
// IsTLSEnabled returns true if the cluster is TLS enabled, i.e. both the TLS
// secret name and the CA secret name are available
func (t TLSSpec) IsTLSEnabled() bool | {
return (t.TLSSecret != "" && t.CASecret != "")
} | identifier_body |
|
cluster.go | Crunchy PG Cluster Spec
// swagger:ignore
type PgclusterSpec struct {
Namespace string `json:"namespace"`
Name string `json:"name"`
ClusterName string `json:"clustername"`
Policies string `json:"policies"`
CCPImage string `json:"ccpimage"`
CCPImageTag string `json:"ccpimagetag"`
CCPImagePrefix string `json:"ccpimageprefix"`
PGOImagePrefix string `json:"pgoimageprefix"`
Port string `json:"port"`
PGBadgerPort string `json:"pgbadgerport"`
ExporterPort string `json:"exporterport"`
PrimaryStorage PgStorageSpec `json:primarystorage`
WALStorage PgStorageSpec `json:walstorage`
ArchiveStorage PgStorageSpec `json:archivestorage`
ReplicaStorage PgStorageSpec `json:replicastorage`
BackrestStorage PgStorageSpec `json:backreststorage`
// Resources behaves just like the "Requests" section of a Kubernetes
// container definition. You can set individual items such as "cpu" and
// "memory", e.g. "{ cpu: "0.5", memory: "2Gi" }"
Resources v1.ResourceList `json:"resources"`
// Limits stores the CPU/memory limits to use with PostgreSQL instances
//
// A long note on memory limits.
//
// We want to avoid the OOM killer coming for the PostgreSQL process or any
// of their backends per lots of guidance from the PostgreSQL documentation.
// Based on Kubernetes' behavior with limits, the best thing is to not set
// them. However, if they ever do set, we suggest that you have
// Request == Limit to get the Guaranteed QoS
//
// Guaranteed QoS prevents a backend from being first in line to be killed if
// the *Node* has memory pressure, but if there is, say
// a runaway client backend that causes the *Pod* to exceed its memory
// limit, a backend can still be killed by the OOM killer, which is not
// great.
//
// As such, given the choice, the preference is for the Pod to be evicted
// and have a failover event, vs. having an individual client backend killed
// and causing potential "bad things."
//
// For more info on PostgreSQL and Kubernetes memory management, see:
//
// https://www.postgresql.org/docs/current/kernel-resources.html#LINUX-MEMORY-OVERCOMMIT
// https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/#how-pods-with-resource-limits-are-run
Limits v1.ResourceList `json:"limits"`
// BackrestResources, if specified, contains the container request resources
// for the pgBackRest Deployment for this PostgreSQL cluster
BackrestResources v1.ResourceList `json:"backrestResources"`
// BackrestLimits, if specified, contains the container resource limits
// for the pgBackRest Deployment for this PostgreSQL cluster
BackrestLimits v1.ResourceList `json:"backrestLimits"`
// PgBouncer contains all of the settings to properly maintain a pgBouncer
// implementation
PgBouncer PgBouncerSpec `json:"pgBouncer"`
User string `json:"user"`
Database string `json:"database"`
Replicas string `json:"replicas"`
UserSecretName string `json:"usersecretname"`
RootSecretName string `json:"rootsecretname"`
PrimarySecretName string `json:"primarysecretname"`
CollectSecretName string `json:"collectSecretName"`
Status string `json:"status"`
CustomConfig string `json:"customconfig"`
UserLabels map[string]string `json:"userlabels"`
PodAntiAffinity PodAntiAffinitySpec `json:"podAntiAffinity"`
SyncReplication *bool `json:"syncReplication"`
BackrestS3Bucket string `json:"backrestS3Bucket"`
BackrestS3Region string `json:"backrestS3Region"`
BackrestS3Endpoint string `json:"backrestS3Endpoint"`
BackrestS3URIStyle string `json:"backrestS3URIStyle"`
BackrestS3VerifyTLS string `json:"backrestS3VerifyTLS"`
BackrestRepoPath string `json:"backrestRepoPath"`
TablespaceMounts map[string]PgStorageSpec `json:"tablespaceMounts"`
TLS TLSSpec `json:"tls"`
TLSOnly bool `json:"tlsOnly"`
Standby bool `json:"standby"`
Shutdown bool `json:"shutdown"`
PGDataSource PGDataSourceSpec `json:"pgDataSource"`
}
// PGDataSourceSpec defines the data source that should be used to populate the initial PGDATA
// directory when bootstrapping a new PostgreSQL cluster
// swagger:ignore
type PGDataSourceSpec struct {
RestoreFrom string `json:"restoreFrom"`
RestoreOpts string `json:"restoreOpts"`
}
// PgclusterList is the CRD that defines a Crunchy PG Cluster List
// swagger:ignore
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
type PgclusterList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata"`
Items []Pgcluster `json:"items"`
}
// PgclusterStatus is the CRD that defines PG Cluster Status
// swagger:ignore
type PgclusterStatus struct {
State PgclusterState `json:"state,omitempty"`
Message string `json:"message,omitempty"`
}
// PgclusterState is the crd that defines PG Cluster Stage
// swagger:ignore
type PgclusterState string
// PodAntiAffinityDeployment distinguishes between the different types of
// Deployments that can leverage PodAntiAffinity
type PodAntiAffinityDeployment int
// PodAntiAffinityType defines the different types of type of anti-affinity rules applied to pg
// clusters when utilizing the default pod anti-affinity rules provided by the PostgreSQL Operator,
// which are enabled for a new pg cluster by default. Valid Values include "required" for
// requiredDuringSchedulingIgnoredDuringExecution anti-affinity, "preferred" for
// preferredDuringSchedulingIgnoredDuringExecution anti-affinity, and "disabled" to disable the
// default pod anti-affinity rules for the pg cluster all together.
type PodAntiAffinityType string
// PodAntiAffinitySpec provides multiple configurations for how pod
// anti-affinity can be set.
// - "Default" is the default rule that applies to all Pods that are a part of
// the PostgreSQL cluster
// - "PgBackrest" applies just to the pgBackRest repository Pods in said
// Deployment
// - "PgBouncer" applies to just pgBouncer Pods in said Deployment
// swaggier:ignore
type PodAntiAffinitySpec struct {
Default PodAntiAffinityType `json:"default"`
PgBackRest PodAntiAffinityType `json:"pgBackRest"`
PgBouncer PodAntiAffinityType `json:"pgBouncer"`
}
// PgBouncerSpec is a struct that is used within the Cluster specification that
// provides the attributes for managing a PgBouncer implementation, including:
// - is it enabled?
// - what resources it should consume
// - the total number of replicas
type PgBouncerSpec struct {
// Replicas represents the total number of Pods to deploy with pgBouncer,
// which effectively enables/disables the pgBouncer.
//
// if it is set to 0 or less, it is disabled.
//
// if it is set to 1 or more, it is enabled
Replicas int32 `json:"replicas"`
// Resources, if specified, contains the container request resources
// for any pgBouncer Deployments that are part of a PostgreSQL cluster
Resources v1.ResourceList `json:"resources"`
// Limits, if specified, contains the container resource limits
// for any pgBouncer Deployments that are part of a PostgreSQL cluster
Limits v1.ResourceList `json:"limits"`
}
// Enabled returns true if the pgBouncer is enabled for the cluster, i.e. there
// is at least one replica set
func (s *PgBouncerSpec) | () bool {
return s.Replicas > 0
}
// TLSSpec contains the information to set up a TLS-enabled PostgreSQL cluster
type TLSSpec struct {
// CASecret contains the name of the secret to use as the trusted CA for the
// TLSSecret
// This is our own format and should contain at least one key: "ca.crt"
// It can also contain a key "ca.crl" which is the certificate revocation list
CASecret string `json:"caSecret"`
// ReplicationTLSSecret contains the name of the secret that specifies a TLS
// keypair that can be used by the replication user (e.g. "primaryuser") to
// perform certificate based authentication between replicas.
// The keypair must be considered valid by the CA specified in the CASecret
ReplicationTLSSecret string `json:"replication | Enabled | identifier_name |
service.go | err != nil {
return errors.Wrap(err, "failed to process channels")
}
}
}
}
// RSSFeed generates RSS feed for given channel
func (s *Service) RSSFeed(fi FeedInfo) (string, error) | }
duration := ""
if entry.Duration > 0 {
duration = fmt.Sprintf("%d", entry.Duration)
}
items = append(items, rssfeed.Item{
Title: entry.Title,
Description: entry.Media.Description,
Link: entry.Link.Href,
PubDate: entry.Published.In(time.UTC).Format(time.RFC1123Z),
GUID: entry.ChannelID + "::" + entry.VideoID,
Author: entry.Author.Name,
Enclosure: rssfeed.Enclosure{
URL: fileURL,
Type: "audio/mpeg",
Length: fileSize,
},
Duration: duration,
DT: time.Now(),
})
}
rss := rssfeed.Rss2{
Version: "2.0",
NsItunes: "http://www.itunes.com/dtds/podcast-1.0.dtd",
NsMedia: "http://search.yahoo.com/mrss/",
ItemList: items,
Title: fi.Name,
Description: "generated by feed-master",
Link: entries[0].Author.URI,
PubDate: items[0].PubDate,
LastBuildDate: time.Now().Format(time.RFC1123Z),
Language: fi.Language,
ItunesAuthor: entries[0].Author.Name,
ItunesExplicit: "no",
}
// set image from channel as rss thumbnail
// TODO: we may want to load it locally in case if youtube doesn't like such remote usage of images
if image := entries[0].Media.Thumbnail.URL; image != "" {
rss.ItunesImage = &rssfeed.ItunesImg{URL: image}
rss.MediaThumbnail = &rssfeed.MediaThumbnail{URL: image}
}
if fi.Type == ytfeed.FTPlaylist {
rss.Link = "https://www.youtube.com/playlist?list=" + fi.ID
}
b, err := xml.MarshalIndent(&rss, "", " ")
if err != nil {
return "", errors.Wrap(err, "failed to marshal rss")
}
res := string(b)
// this hack to avoid having different items for marshal and unmarshal due to "itunes" namespace
res = strings.Replace(res, "<duration>", "<itunes:duration>", -1)
res = strings.Replace(res, "</duration>", "</itunes:duration>", -1)
return res, nil
}
// procChannels processes all channels, downloads audio, updates metadata and stores RSS
func (s *Service) procChannels(ctx context.Context) error {
var allStats stats
for _, feedInfo := range s.Feeds {
entries, err := s.ChannelService.Get(ctx, feedInfo.ID, feedInfo.Type)
if err != nil {
log.Printf("[WARN] failed to get channel entries for %s: %s", feedInfo.ID, err)
continue
}
log.Printf("[INFO] got %d entries for %s, limit to %d", len(entries), feedInfo.Name, s.keep(feedInfo))
changed, processed := false, 0
for i, entry := range entries {
// exit right away if context is done
select {
case <-ctx.Done():
return ctx.Err()
default:
}
allStats.entries++
if processed >= s.keep(feedInfo) {
break
}
isAllowed, err := s.isAllowed(entry, feedInfo)
if err != nil {
return errors.Wrapf(err, "failed to check if entry %s is relevant", entry.VideoID)
}
if !isAllowed {
log.Printf("[DEBUG] skipping filtered %s", entry.String())
allStats.ignored++
continue
}
ok, err := s.isNew(entry, feedInfo)
if err != nil {
return errors.Wrapf(err, "failed to check if entry %s exists", entry.VideoID)
}
if !ok {
allStats.skipped++
processed++
continue
}
// got new entry, but with very old timestamp. skip it if we have already reached max capacity
// (this is to eliminate the initial load) and this entry is older than the oldest one we have.
// Also marks it as processed as we don't want to process it again
oldestEntry := s.oldestEntry()
if entry.Published.Before(oldestEntry.Published) && s.countAllEntries() >= s.totalEntriesToKeep() {
allStats.ignored++
log.Printf("[INFO] skipping entry %s as it is older than the oldest one we have %s",
entry.String(), oldestEntry.String())
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
continue
}
log.Printf("[INFO] new entry [%d] %s, %s, %s, %s", i+1, entry.VideoID, entry.Title, feedInfo.Name, entry.String())
file, downErr := s.Downloader.Get(ctx, entry.VideoID, s.makeFileName(entry))
if downErr != nil {
allStats.ignored++
if downErr == ytfeed.ErrSkip { // downloader decided to skip this entry
log.Printf("[INFO] skipping %s", entry.String())
continue
}
log.Printf("[WARN] failed to download %s: %s", entry.VideoID, downErr)
continue
}
if short, duration := s.isShort(file); short {
allStats.ignored++
log.Printf("[INFO] skip short file %s (%v): %s, %s", file, duration, entry.VideoID, entry.String())
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
continue
}
// update metadata
if tagsErr := s.updateMp3Tags(file, entry, feedInfo); tagsErr != nil {
log.Printf("[WARN] failed to update metadata for %s: %s", entry.VideoID, tagsErr)
}
processed++
fsize := 0
if fi, err := os.Stat(file); err == nil {
fsize = int(fi.Size())
} else {
log.Printf("[WARN] failed to get file size for %s: %v", file, err)
}
log.Printf("[INFO] downloaded %s (%s) to %s, size: %d, channel: %+v", entry.VideoID, entry.Title, file, fsize, feedInfo)
entry = s.update(entry, file, feedInfo)
ok, saveErr := s.Store.Save(entry)
if saveErr != nil {
return errors.Wrapf(saveErr, "failed to save entry %+v", entry)
}
if !ok {
log.Printf("[WARN] attempt to save dup entry %+v", entry)
}
changed = true
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
allStats.added++
log.Printf("[INFO] saved %s (%s) to %s, channel: %+v", entry.VideoID, entry.Title, file, feedInfo)
}
allStats.processed += processed
if changed {
removed := s.removeOld(feedInfo)
allStats.removed += removed
// save rss feed to fs if there are new entries
rss, rssErr := s.RSSFeed(feedInfo)
if rssErr != nil {
log.Printf("[WARN] failed to generate rss for %s: %s", feedInfo.Name, rssErr)
} else {
if err := s.RSSFileStore.Save(feedInfo.ID, rss); err != nil {
log.Printf("[WARN] failed to save rss for %s: %s", feedInfo.Name, err)
}
}
}
}
log.Printf("[INFO] all channels processed - channels: %d, %s, lifetime: %d, feed size: %d",
len(s.Feeds), allStats.String(), s.Store.CountProcessed(), s.countAllEntries())
newestEntry | {
entries, err := s.Store.Load(fi.ID, s.keep(fi))
if err != nil {
return "", errors.Wrap(err, "failed to get channel entries")
}
if len(entries) == 0 {
return "", nil
}
items := []rssfeed.Item{}
for _, entry := range entries {
fileURL := s.RootURL + "/" + path.Base(entry.File)
var fileSize int
if fileInfo, fiErr := os.Stat(entry.File); fiErr != nil {
log.Printf("[WARN] failed to get file size for %s (%s %s): %v", entry.File, entry.VideoID, entry.Title, fiErr)
} else {
fileSize = int(fileInfo.Size()) | identifier_body |
service.go |
for _, f := range s.Feeds {
log.Printf("[INFO] youtube feed %+v", f)
}
tick := time.NewTicker(s.CheckDuration)
defer tick.Stop()
if err := s.procChannels(ctx); err != nil {
return errors.Wrap(err, "failed to process channels")
}
for {
select {
case <-ctx.Done():
return ctx.Err()
case <-tick.C:
if err := s.procChannels(ctx); err != nil {
return errors.Wrap(err, "failed to process channels")
}
}
}
}
// RSSFeed generates RSS feed for given channel
func (s *Service) RSSFeed(fi FeedInfo) (string, error) {
entries, err := s.Store.Load(fi.ID, s.keep(fi))
if err != nil {
return "", errors.Wrap(err, "failed to get channel entries")
}
if len(entries) == 0 {
return "", nil
}
items := []rssfeed.Item{}
for _, entry := range entries {
fileURL := s.RootURL + "/" + path.Base(entry.File)
var fileSize int
if fileInfo, fiErr := os.Stat(entry.File); fiErr != nil {
log.Printf("[WARN] failed to get file size for %s (%s %s): %v", entry.File, entry.VideoID, entry.Title, fiErr)
} else {
fileSize = int(fileInfo.Size())
}
duration := ""
if entry.Duration > 0 {
duration = fmt.Sprintf("%d", entry.Duration)
}
items = append(items, rssfeed.Item{
Title: entry.Title,
Description: entry.Media.Description,
Link: entry.Link.Href,
PubDate: entry.Published.In(time.UTC).Format(time.RFC1123Z),
GUID: entry.ChannelID + "::" + entry.VideoID,
Author: entry.Author.Name,
Enclosure: rssfeed.Enclosure{
URL: fileURL,
Type: "audio/mpeg",
Length: fileSize,
},
Duration: duration,
DT: time.Now(),
})
}
rss := rssfeed.Rss2{
Version: "2.0",
NsItunes: "http://www.itunes.com/dtds/podcast-1.0.dtd",
NsMedia: "http://search.yahoo.com/mrss/",
ItemList: items,
Title: fi.Name,
Description: "generated by feed-master",
Link: entries[0].Author.URI,
PubDate: items[0].PubDate,
LastBuildDate: time.Now().Format(time.RFC1123Z),
Language: fi.Language,
ItunesAuthor: entries[0].Author.Name,
ItunesExplicit: "no",
}
// set image from channel as rss thumbnail
// TODO: we may want to load it locally in case if youtube doesn't like such remote usage of images
if image := entries[0].Media.Thumbnail.URL; image != "" {
rss.ItunesImage = &rssfeed.ItunesImg{URL: image}
rss.MediaThumbnail = &rssfeed.MediaThumbnail{URL: image}
}
if fi.Type == ytfeed.FTPlaylist {
rss.Link = "https://www.youtube.com/playlist?list=" + fi.ID
}
b, err := xml.MarshalIndent(&rss, "", " ")
if err != nil {
return "", errors.Wrap(err, "failed to marshal rss")
}
res := string(b)
// this hack to avoid having different items for marshal and unmarshal due to "itunes" namespace
res = strings.Replace(res, "<duration>", "<itunes:duration>", -1)
res = strings.Replace(res, "</duration>", "</itunes:duration>", -1)
return res, nil
}
// procChannels processes all channels, downloads audio, updates metadata and stores RSS
func (s *Service) procChannels(ctx context.Context) error {
var allStats stats
for _, feedInfo := range s.Feeds {
entries, err := s.ChannelService.Get(ctx, feedInfo.ID, feedInfo.Type)
if err != nil {
log.Printf("[WARN] failed to get channel entries for %s: %s", feedInfo.ID, err)
continue
}
log.Printf("[INFO] got %d entries for %s, limit to %d", len(entries), feedInfo.Name, s.keep(feedInfo))
changed, processed := false, 0
for i, entry := range entries {
// exit right away if context is done
select {
case <-ctx.Done():
return ctx.Err()
default:
}
allStats.entries++
if processed >= s.keep(feedInfo) {
break
}
isAllowed, err := s.isAllowed(entry, feedInfo)
if err != nil {
return errors.Wrapf(err, "failed to check if entry %s is relevant", entry.VideoID)
}
if !isAllowed {
log.Printf("[DEBUG] skipping filtered %s", entry.String())
allStats.ignored++
continue
}
ok, err := s.isNew(entry, feedInfo)
if err != nil {
return errors.Wrapf(err, "failed to check if entry %s exists", entry.VideoID)
}
if !ok {
allStats.skipped++
processed++
continue
}
// got new entry, but with very old timestamp. skip it if we have already reached max capacity
// (this is to eliminate the initial load) and this entry is older than the oldest one we have.
// Also marks it as processed as we don't want to process it again
oldestEntry := s.oldestEntry()
if entry.Published.Before(oldestEntry.Published) && s.countAllEntries() >= s.totalEntriesToKeep() {
allStats.ignored++
log.Printf("[INFO] skipping entry %s as it is older than the oldest one we have %s",
entry.String(), oldestEntry.String())
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
continue
}
log.Printf("[INFO] new entry [%d] %s, %s, %s, %s", i+1, entry.VideoID, entry.Title, feedInfo.Name, entry.String())
file, downErr := s.Downloader.Get(ctx, entry.VideoID, s.makeFileName(entry))
if downErr != nil {
allStats.ignored++
if downErr == ytfeed.ErrSkip { // downloader decided to skip this entry
log.Printf("[INFO] skipping %s", entry.String())
continue
}
log.Printf("[WARN] failed to download %s: %s", entry.VideoID, downErr)
continue
}
if short, duration := s.isShort(file); short {
allStats.ignored++
log.Printf("[INFO] skip short file %s (%v): %s, %s", file, duration, entry.VideoID, entry.String())
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
continue
}
// update metadata
if tagsErr := s.updateMp3Tags(file, entry, feedInfo); tagsErr != nil {
log.Printf("[WARN] failed to update metadata for %s: %s", entry.VideoID, tagsErr)
}
processed++
fsize := 0
if fi, err := os.Stat(file); err == nil {
fsize = int(fi.Size())
} else {
log.Printf("[WARN] failed to get file size for %s: %v", file, err)
}
log.Printf("[INFO] downloaded %s (%s) to %s, size: %d, channel: %+v", entry.VideoID, entry.Title, file, fsize, feedInfo)
entry = s.update(entry, file, feedInfo)
ok, saveErr := s.Store.Save(entry)
if saveErr != nil {
return errors.Wrapf(saveErr, "failed to save entry %+v", entry)
}
if !ok {
log.Printf("[WARN] attempt to save dup entry %+v", entry)
}
changed = true
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
allStats.added++
log.Printf("[INFO] saved %s (%s) to %s, channel: %+v", entry.VideoID, entry.Title, file, feedInfo)
}
allStats.processed += processed
if changed {
removed := s.removeOld(feedInfo)
allStats.removed += removed
// save rss feed to fs if there are new entries
rss, rssErr := s.RSSFeed(feedInfo)
if rssErr != nil {
log.Printf("[WARN] failed to generate rss for %s: %s", | {
log.Printf("[DEBUG] skip youtube episodes shorter than %v", s.SkipShorts)
} | conditional_block |
|
service.go | INFO] new entry [%d] %s, %s, %s, %s", i+1, entry.VideoID, entry.Title, feedInfo.Name, entry.String())
file, downErr := s.Downloader.Get(ctx, entry.VideoID, s.makeFileName(entry))
if downErr != nil {
allStats.ignored++
if downErr == ytfeed.ErrSkip { // downloader decided to skip this entry
log.Printf("[INFO] skipping %s", entry.String())
continue
}
log.Printf("[WARN] failed to download %s: %s", entry.VideoID, downErr)
continue
}
if short, duration := s.isShort(file); short {
allStats.ignored++
log.Printf("[INFO] skip short file %s (%v): %s, %s", file, duration, entry.VideoID, entry.String())
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
continue
}
// update metadata
if tagsErr := s.updateMp3Tags(file, entry, feedInfo); tagsErr != nil {
log.Printf("[WARN] failed to update metadata for %s: %s", entry.VideoID, tagsErr)
}
processed++
fsize := 0
if fi, err := os.Stat(file); err == nil {
fsize = int(fi.Size())
} else {
log.Printf("[WARN] failed to get file size for %s: %v", file, err)
}
log.Printf("[INFO] downloaded %s (%s) to %s, size: %d, channel: %+v", entry.VideoID, entry.Title, file, fsize, feedInfo)
entry = s.update(entry, file, feedInfo)
ok, saveErr := s.Store.Save(entry)
if saveErr != nil {
return errors.Wrapf(saveErr, "failed to save entry %+v", entry)
}
if !ok {
log.Printf("[WARN] attempt to save dup entry %+v", entry)
}
changed = true
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
allStats.added++
log.Printf("[INFO] saved %s (%s) to %s, channel: %+v", entry.VideoID, entry.Title, file, feedInfo)
}
allStats.processed += processed
if changed {
removed := s.removeOld(feedInfo)
allStats.removed += removed
// save rss feed to fs if there are new entries
rss, rssErr := s.RSSFeed(feedInfo)
if rssErr != nil {
log.Printf("[WARN] failed to generate rss for %s: %s", feedInfo.Name, rssErr)
} else {
if err := s.RSSFileStore.Save(feedInfo.ID, rss); err != nil {
log.Printf("[WARN] failed to save rss for %s: %s", feedInfo.Name, err)
}
}
}
}
log.Printf("[INFO] all channels processed - channels: %d, %s, lifetime: %d, feed size: %d",
len(s.Feeds), allStats.String(), s.Store.CountProcessed(), s.countAllEntries())
newestEntry := s.newestEntry()
log.Printf("[INFO] last entry: %s", newestEntry.String())
return nil
}
// StoreRSS saves RSS feed to file
func (s *Service) StoreRSS(chanID, rss string) error {
return s.RSSFileStore.Save(chanID, rss)
}
// RemoveEntry deleted entry from store. Doesn't removes file
func (s *Service) RemoveEntry(entry ytfeed.Entry) error {
if err := s.Store.ResetProcessed(entry); err != nil {
return errors.Wrapf(err, "failed to reset processed entry %s", entry.VideoID)
}
if err := s.Store.Remove(entry); err != nil {
return errors.Wrapf(err, "failed to remove entry %s", entry.VideoID)
}
return nil
}
// isNew checks if entry already processed
func (s *Service) isNew(entry ytfeed.Entry, fi FeedInfo) (ok bool, err error) {
// check if entry already exists in store
// this method won't work after migration to locally altered published ts but have to stay for now
// to avoid false-positives on old entries what never got set with SetProcessed
exists, exErr := s.Store.Exist(entry)
if err != nil {
return false, errors.Wrapf(exErr, "failed to check if entry %s exists", entry.VideoID)
}
if exists {
return false, nil
}
// check if we already processed this entry.
// this is needed to avoid infinite get/remove loop when the original feed is updated in place.
// after migration to locally altered published ts, it is also the primary way to detect already processed entries
found, _, procErr := s.Store.CheckProcessed(entry)
if procErr != nil {
log.Printf("[WARN] can't get processed status for %s, %+v", entry.VideoID, fi)
}
if procErr == nil && found {
return false, nil
}
return true, nil
}
// isAllowed checks if entry matches all filters for the channel feed
func (s *Service) isAllowed(entry ytfeed.Entry, fi FeedInfo) (ok bool, err error) {
matchedIncludeFilter := true
if fi.Filter.Include != "" {
matchedIncludeFilter, err = regexp.MatchString(fi.Filter.Include, entry.Title)
if err != nil {
return false, errors.Wrapf(err, "failed to check if entry %s matches include filter", entry.VideoID)
}
}
matchedExcludeFilter := false
if fi.Filter.Exclude != "" {
matchedExcludeFilter, err = regexp.MatchString(fi.Filter.Exclude, entry.Title)
if err != nil {
return false, errors.Wrapf(err, "failed to check if entry %s matches exclude filter", entry.VideoID)
}
}
return matchedIncludeFilter && !matchedExcludeFilter, nil
}
func (s *Service) isShort(file string) (bool, time.Duration) {
if s.SkipShorts.Seconds() > 0 {
// skip shorts if duration is less than SkipShorts
duration := s.DurationService.File(file)
if duration > 0 && duration < int(s.SkipShorts.Seconds()) {
return true, time.Duration(duration) * time.Second
}
}
return false, 0
}
// update sets entry file name and reset published ts
func (s *Service) update(entry ytfeed.Entry, file string, fi FeedInfo) ytfeed.Entry {
entry.File = file
// only reset time if published not too long ago
// this is done to avoid initial set of entries added with a new channel to the top of the feed
if time.Since(entry.Published) < time.Hour*24 {
log.Printf("[DEBUG] reset published time for %s, from %s to %s (%v), %s",
entry.VideoID, entry.Published.Format(time.RFC3339), time.Now().Format(time.RFC3339),
time.Since(entry.Published), entry.String())
entry.Published = time.Now() // reset published ts to prevent possible out-of-order entries
} else {
log.Printf("[DEBUG] keep published time for %s, %s", entry.VideoID, entry.Published.Format(time.RFC3339))
}
if !strings.Contains(entry.Title, fi.Name) { // if title doesn't contains channel name add it
entry.Title = fi.Name + ": " + entry.Title
}
entry.Duration = s.DurationService.File(file)
log.Printf("[DEBUG] updated entry: %s", entry.String())
return entry
}
// removeOld deletes old entries from store and corresponding files
func (s *Service) removeOld(fi FeedInfo) int {
removed := 0
keep := s.keep(fi)
files, err := s.Store.RemoveOld(fi.ID, keep+1)
if err != nil { // even with error we get a list of files to remove
log.Printf("[WARN] failed to remove some old meta data for %s, %v", fi.ID, err)
}
for _, f := range files {
if e := os.Remove(f); e != nil {
log.Printf("[WARN] failed to remove file %s: %v", f, e)
continue
}
removed++
log.Printf("[INFO] removed %s for %s (%s)", f, fi.ID, fi.Name)
}
return removed
}
func (s *Service) keep(fi FeedInfo) int {
keep := s.KeepPerChannel
if fi.Keep > 0 {
keep = fi.Keep
}
return keep
}
func (s *Service) makeFileName(entry ytfeed.Entry) string {
h := sha1.New()
if _, err := h.Write([]byte(entry.UID())); err != nil {
return uuid.New().String()
}
return fmt.Sprintf("%x", h.Sum(nil))
}
// totalEntriesToKeep returns total number of entries to keep, summing all channels' keep values
func (s *Service) | totalEntriesToKeep | identifier_name |
|
service.go | return errors.Wrapf(err, "failed to check if entry %s is relevant", entry.VideoID)
}
if !isAllowed {
log.Printf("[DEBUG] skipping filtered %s", entry.String())
allStats.ignored++
continue
}
ok, err := s.isNew(entry, feedInfo)
if err != nil {
return errors.Wrapf(err, "failed to check if entry %s exists", entry.VideoID)
}
if !ok {
allStats.skipped++
processed++
continue
}
// got new entry, but with very old timestamp. skip it if we have already reached max capacity
// (this is to eliminate the initial load) and this entry is older than the oldest one we have.
// Also marks it as processed as we don't want to process it again
oldestEntry := s.oldestEntry()
if entry.Published.Before(oldestEntry.Published) && s.countAllEntries() >= s.totalEntriesToKeep() {
allStats.ignored++
log.Printf("[INFO] skipping entry %s as it is older than the oldest one we have %s",
entry.String(), oldestEntry.String())
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
continue
}
log.Printf("[INFO] new entry [%d] %s, %s, %s, %s", i+1, entry.VideoID, entry.Title, feedInfo.Name, entry.String())
file, downErr := s.Downloader.Get(ctx, entry.VideoID, s.makeFileName(entry))
if downErr != nil {
allStats.ignored++
if downErr == ytfeed.ErrSkip { // downloader decided to skip this entry
log.Printf("[INFO] skipping %s", entry.String())
continue
}
log.Printf("[WARN] failed to download %s: %s", entry.VideoID, downErr)
continue
}
if short, duration := s.isShort(file); short {
allStats.ignored++
log.Printf("[INFO] skip short file %s (%v): %s, %s", file, duration, entry.VideoID, entry.String())
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
continue
}
// update metadata
if tagsErr := s.updateMp3Tags(file, entry, feedInfo); tagsErr != nil {
log.Printf("[WARN] failed to update metadata for %s: %s", entry.VideoID, tagsErr)
}
processed++
fsize := 0
if fi, err := os.Stat(file); err == nil {
fsize = int(fi.Size())
} else {
log.Printf("[WARN] failed to get file size for %s: %v", file, err)
}
log.Printf("[INFO] downloaded %s (%s) to %s, size: %d, channel: %+v", entry.VideoID, entry.Title, file, fsize, feedInfo)
entry = s.update(entry, file, feedInfo)
ok, saveErr := s.Store.Save(entry)
if saveErr != nil {
return errors.Wrapf(saveErr, "failed to save entry %+v", entry)
}
if !ok {
log.Printf("[WARN] attempt to save dup entry %+v", entry)
}
changed = true
if procErr := s.Store.SetProcessed(entry); procErr != nil {
log.Printf("[WARN] failed to set processed status for %s: %v", entry.VideoID, procErr)
}
allStats.added++
log.Printf("[INFO] saved %s (%s) to %s, channel: %+v", entry.VideoID, entry.Title, file, feedInfo)
}
allStats.processed += processed
if changed {
removed := s.removeOld(feedInfo)
allStats.removed += removed
// save rss feed to fs if there are new entries
rss, rssErr := s.RSSFeed(feedInfo)
if rssErr != nil {
log.Printf("[WARN] failed to generate rss for %s: %s", feedInfo.Name, rssErr)
} else {
if err := s.RSSFileStore.Save(feedInfo.ID, rss); err != nil {
log.Printf("[WARN] failed to save rss for %s: %s", feedInfo.Name, err)
}
}
}
}
log.Printf("[INFO] all channels processed - channels: %d, %s, lifetime: %d, feed size: %d",
len(s.Feeds), allStats.String(), s.Store.CountProcessed(), s.countAllEntries())
newestEntry := s.newestEntry()
log.Printf("[INFO] last entry: %s", newestEntry.String())
return nil
}
// StoreRSS saves RSS feed to file
func (s *Service) StoreRSS(chanID, rss string) error {
return s.RSSFileStore.Save(chanID, rss)
}
// RemoveEntry deleted entry from store. Doesn't removes file
func (s *Service) RemoveEntry(entry ytfeed.Entry) error {
if err := s.Store.ResetProcessed(entry); err != nil {
return errors.Wrapf(err, "failed to reset processed entry %s", entry.VideoID)
}
if err := s.Store.Remove(entry); err != nil {
return errors.Wrapf(err, "failed to remove entry %s", entry.VideoID)
}
return nil
}
// isNew checks if entry already processed
func (s *Service) isNew(entry ytfeed.Entry, fi FeedInfo) (ok bool, err error) {
// check if entry already exists in store
// this method won't work after migration to locally altered published ts but have to stay for now
// to avoid false-positives on old entries what never got set with SetProcessed
exists, exErr := s.Store.Exist(entry)
if err != nil {
return false, errors.Wrapf(exErr, "failed to check if entry %s exists", entry.VideoID)
}
if exists {
return false, nil
}
// check if we already processed this entry.
// this is needed to avoid infinite get/remove loop when the original feed is updated in place.
// after migration to locally altered published ts, it is also the primary way to detect already processed entries
found, _, procErr := s.Store.CheckProcessed(entry)
if procErr != nil {
log.Printf("[WARN] can't get processed status for %s, %+v", entry.VideoID, fi)
}
if procErr == nil && found {
return false, nil
}
return true, nil
}
// isAllowed checks if entry matches all filters for the channel feed
func (s *Service) isAllowed(entry ytfeed.Entry, fi FeedInfo) (ok bool, err error) {
matchedIncludeFilter := true
if fi.Filter.Include != "" {
matchedIncludeFilter, err = regexp.MatchString(fi.Filter.Include, entry.Title)
if err != nil {
return false, errors.Wrapf(err, "failed to check if entry %s matches include filter", entry.VideoID)
}
}
matchedExcludeFilter := false
if fi.Filter.Exclude != "" {
matchedExcludeFilter, err = regexp.MatchString(fi.Filter.Exclude, entry.Title)
if err != nil {
return false, errors.Wrapf(err, "failed to check if entry %s matches exclude filter", entry.VideoID)
}
}
return matchedIncludeFilter && !matchedExcludeFilter, nil
}
func (s *Service) isShort(file string) (bool, time.Duration) {
if s.SkipShorts.Seconds() > 0 {
// skip shorts if duration is less than SkipShorts
duration := s.DurationService.File(file)
if duration > 0 && duration < int(s.SkipShorts.Seconds()) {
return true, time.Duration(duration) * time.Second
}
}
return false, 0
}
// update sets entry file name and reset published ts
func (s *Service) update(entry ytfeed.Entry, file string, fi FeedInfo) ytfeed.Entry {
entry.File = file
// only reset time if published not too long ago
// this is done to avoid initial set of entries added with a new channel to the top of the feed
if time.Since(entry.Published) < time.Hour*24 {
log.Printf("[DEBUG] reset published time for %s, from %s to %s (%v), %s",
entry.VideoID, entry.Published.Format(time.RFC3339), time.Now().Format(time.RFC3339),
time.Since(entry.Published), entry.String())
entry.Published = time.Now() // reset published ts to prevent possible out-of-order entries
} else {
log.Printf("[DEBUG] keep published time for %s, %s", entry.VideoID, entry.Published.Format(time.RFC3339))
}
if !strings.Contains(entry.Title, fi.Name) { // if title doesn't contains channel name add it
entry.Title = fi.Name + ": " + entry.Title
}
entry.Duration = s.DurationService.File(file) | log.Printf("[DEBUG] updated entry: %s", entry.String()) | random_line_split |
|
mod.rs | _mem: usize,
show_gc: bool,
show_allocates: bool,
show_heap_map: bool,
show_free_list: bool,
}
impl<'a> IntoIterator for &'a Memory {
type Item = usize;
type IntoIter = MemoryIntoIterator<'a>;
fn into_iter(self) -> Self::IntoIter {
MemoryIntoIterator {
mem: self,
scan: 0,
free: 0,
}
}
}
pub struct MemoryIntoIterator<'a> {
mem: &'a Memory,
scan: usize,
free: usize,
}
impl<'a> Iterator for MemoryIntoIterator<'a> {
type Item = usize;
fn next(&mut self) -> Option<Self::Item> {
if self.scan == 0 {
self.scan = 1;
self.free = self.mem.head;
} else {
self.scan = self.mem.next_object_in_heap(self.scan);
}
while self.scan == self.free {
self.scan = self.mem.next_object_in_heap(self.free);
self.free = self.mem.get_fl_next(self.free);
}
if self.scan >= MAX_MEMORY_SLOTS - 1 {
return None;
} else {
return Some(self.scan);
}
}
}
#[cfg(feature = "dynamic_mem")]
fn im() -> Mem {
return vec![0; MAX_MEMORY_SLOTS];
}
#[cfg(not(feature = "dynamic_mem"))]
fn im() -> Mem {
return [0; MAX_MEMORY_SLOTS];
}
impl Memory {
pub fn initialze_memory() -> Memory {
let mut mem = Memory {
head: 1,
mem: im(),
mark_bits: [0; MARK_BITS],
roots: Vec::new(),
gc_count: 0,
allocates: 0,
lastgc_live_mem: 0,
lastgc_free_mem: 0,
last_gc_ms: 0,
total_gc_ms: 0,
show_gc: false,
show_allocates: false,
show_heap_map: false,
show_free_list: false,
};
mem.set_size(0, MAX_MEMORY_SLOTS); // magic memory at zero is heap_size
mem.set_size(mem.head, MAX_MEMORY_SLOTS - 2); // set initial object size as all heap
mem.set_fl_next(mem.head, 0);
mem
}
// objects API
// allocate_object (size) --- size is number of indexable slots
// add/remote_root () --- add to or remove from gc root set.
// element_size() - number of indexable slots - get_size() - OBJECT_HEADER_SLOTS
// at_put - store into object slot at index
// at -- fetch object slot at index
pub fn allocate_object(&mut self, unrounded_size: usize) -> usize {
self.allocates += 1;
let mut result = self.allocate_object_nocompress(unrounded_size);
if result == 0 {
self.gc();
result = self.allocate_object_nocompress(unrounded_size);
if result == 0 {
self.print_freelist();
self.print_heap();
panic!("out of memory");
}
}
result
}
pub fn live_objects(&self) -> MemoryIntoIterator {
return self.into_iter();
}
pub fn add_root(&mut self, obj: usize) {
self.roots.push(obj);
}
pub fn remove_root(&mut self, obj: usize) {
for i in 0..self.roots.len() {
if obj == self.roots[i] {
self.roots.remove(i);
return;
}
}
}
pub fn at_put(&mut self, obj: usize, index: usize, value: usize) {
let slots = self.mem[obj];
let base = obj+OBJECT_HEADER_SLOTS;
let object =&mut self.mem[ base.. base + slots ];
object[index] = value;
}
pub fn at(&self, obj: usize, index: usize) -> usize {
let slots = self.mem[obj];
let base = obj+OBJECT_HEADER_SLOTS;
let object =&self.mem[ base.. base + slots ];
return object[index];
}
pub fn element_size(&self, obj: usize) -> usize {
return self.mem[obj] - OBJECT_HEADER_SLOTS;
}
pub fn enable_show_heap_map(&mut self, enabled: bool) {
self.show_heap_map = enabled;
}
pub fn enable_show_freelist(&mut self, enabled: bool) {
self.show_free_list = enabled;
}
pub fn enable_show_gc(&mut self, enabled: bool) {
self.show_gc = enabled;
}
pub fn enable_show_allocates(&mut self, enabled: bool) {
self.show_allocates = enabled;
}
fn rounded_size(unrounded_size: usize) -> usize {
(unrounded_size + 1) & !(1) // rounded to 2
}
fn get_size(&self, obj: usize) -> usize {
return self.mem[obj];
}
fn set_size(&mut self, obj: usize, size: usize) {
self.mem[obj] = size;
}
fn next_object_in_heap(&self, obj: usize) -> usize {
return obj + self.get_size(obj);
}
//free list is linked off the first slot
fn get_fl_next(&self, obj: usize) -> usize {
return self.mem[obj + 1];
}
fn | (&mut self, obj: usize, next: usize) {
self.mem[obj + 1] = next;
}
fn mark_object(&mut self, obj: usize) {
self.mark_bits[obj / MARK_BITS_PER_SLOT] |= 1 << (obj % MARK_BITS_PER_SLOT);
}
fn unmark_object(&mut self, obj: usize) {
self.mark_bits[obj / MARK_BITS_PER_SLOT] &= !(1 << (obj % MARK_BITS_PER_SLOT));
}
fn is_marked(&self, obj: usize) -> bool {
(self.mark_bits[obj / MARK_BITS_PER_SLOT] & (1 << (obj % MARK_BITS_PER_SLOT))) != 0
}
fn allocate_object_nocompress(&mut self, unrounded_size: usize) -> usize {
let size = Memory::rounded_size(unrounded_size + OBJECT_HEADER_SLOTS);
let mut free = self.head;
while free != 0 {
let avail = self.get_size(free);
if avail > size {
let newsize = avail - size;
if newsize < 2 {
panic!("remaining size is less than 2");
}
// shrink current free to smaller size
self.set_size(free, newsize);
// new object is on the end of current free object
let new_object = free + newsize;
self.set_size(new_object, size);
for index in 0..self.element_size(new_object) {
self.at_put(new_object, index, 0);
}
if self.show_allocates {
println!(
"Success: allocate_object returning -> {} size {}",
new_object, size
);
}
if self.head != free {
if self.show_allocates {
println!("Reset head past intermediate free blocks \n");
let mut show = self.head;
while show != free {
println!("Abandon {} size {}\n", show, self.get_size(show));
show = self.get_fl_next(show);
}
}
self.head = free;
}
return new_object;
}
free = self.get_fl_next(free);
}
0
}
pub fn gc(&mut self) {
let start = SystemTime::now();
for i in 0..self.roots.len() {
self.mark_and_scan(self.roots[i]);
}
self.sweep();
self.gc_count += 1;
if self.show_gc {
self.print_gc_stats();
}
match start.elapsed() {
Ok(elapsed) => {
self.last_gc_ms = elapsed.as_millis();
self.total_gc_ms += self.last_gc_ms;
}
Err(e) => {
println!("Error: {:?}", e);
}
}
}
fn sweep(&mut self) {
let mut scan = 1;
self.head = 0;
let mut tail = self.head;
self.lastgc_free_mem = 0;
self.lastgc_live_mem = 0;
while scan < MAX_MEMORY_SLOTS - 1 {
if self.is_marked(scan) {
self.unmark_object(scan);
self.lastgc_live_mem += self.get_size(scan);
} else {
self.lastgc_free_mem += self.get_size(scan);
if tail == 0 {
self.head = scan;
self.set_fl_next(scan, 0);
tail = scan;
} else {
if self.next_object_in_heap(tail) == scan {
self.set_size(tail, self.get_size(tail) + self.get_size(scan));
} else {
self.set_fl_next(tail, scan);
self.set_fl_next(scan, 0);
tail = scan;
}
}
}
scan = self.next_object_in_heap(scan);
}
if self.show_free_list {
self.print_freelist();
}
if self.show_heap_map {
self.print_heap();
}
}
fn mark_and_scan(&mut | set_fl_next | identifier_name |
mod.rs | #[cfg(not(feature="dynamic_mem"))]
const MAX_MEMORY_SLOTS: usize = 1024 * 128;
type Bits = u128;
const MARK_BITS_PER_SLOT: usize = mem::size_of::<Bits>();
const MARK_BITS: usize = MAX_MEMORY_SLOTS / MARK_BITS_PER_SLOT;
#[cfg(feature="dynamic_mem")]
type Mem = Vec<usize>;
#[cfg(not(feature="dynamic_mem"))]
type Mem = [usize; MAX_MEMORY_SLOTS] ;
pub const OBJECT_HEADER_SLOTS: usize = 1;
pub struct Memory {
head: usize,
mem: Mem,
mark_bits: [u128; MARK_BITS],
roots: Vec<usize>,
gc_count: usize,
allocates: usize,
last_gc_ms: u128,
total_gc_ms: u128,
lastgc_live_mem: usize,
lastgc_free_mem: usize,
show_gc: bool,
show_allocates: bool,
show_heap_map: bool,
show_free_list: bool,
}
impl<'a> IntoIterator for &'a Memory {
type Item = usize;
type IntoIter = MemoryIntoIterator<'a>;
fn into_iter(self) -> Self::IntoIter {
MemoryIntoIterator {
mem: self,
scan: 0,
free: 0,
}
}
}
pub struct MemoryIntoIterator<'a> {
mem: &'a Memory,
scan: usize,
free: usize,
}
impl<'a> Iterator for MemoryIntoIterator<'a> {
type Item = usize;
fn next(&mut self) -> Option<Self::Item> {
if self.scan == 0 {
self.scan = 1;
self.free = self.mem.head;
} else {
self.scan = self.mem.next_object_in_heap(self.scan);
}
while self.scan == self.free {
self.scan = self.mem.next_object_in_heap(self.free);
self.free = self.mem.get_fl_next(self.free);
}
if self.scan >= MAX_MEMORY_SLOTS - 1 {
return None;
} else {
return Some(self.scan);
}
}
}
#[cfg(feature = "dynamic_mem")]
fn im() -> Mem {
return vec![0; MAX_MEMORY_SLOTS];
}
#[cfg(not(feature = "dynamic_mem"))]
fn im() -> Mem {
return [0; MAX_MEMORY_SLOTS];
}
impl Memory {
pub fn initialze_memory() -> Memory {
let mut mem = Memory {
head: 1,
mem: im(),
mark_bits: [0; MARK_BITS],
roots: Vec::new(),
gc_count: 0,
allocates: 0,
lastgc_live_mem: 0,
lastgc_free_mem: 0,
last_gc_ms: 0,
total_gc_ms: 0,
show_gc: false,
show_allocates: false,
show_heap_map: false,
show_free_list: false,
};
mem.set_size(0, MAX_MEMORY_SLOTS); // magic memory at zero is heap_size
mem.set_size(mem.head, MAX_MEMORY_SLOTS - 2); // set initial object size as all heap
mem.set_fl_next(mem.head, 0);
mem
}
// objects API
// allocate_object (size) --- size is number of indexable slots
// add/remote_root () --- add to or remove from gc root set.
// element_size() - number of indexable slots - get_size() - OBJECT_HEADER_SLOTS
// at_put - store into object slot at index
// at -- fetch object slot at index
pub fn allocate_object(&mut self, unrounded_size: usize) -> usize {
self.allocates += 1;
let mut result = self.allocate_object_nocompress(unrounded_size);
if result == 0 {
self.gc();
result = self.allocate_object_nocompress(unrounded_size);
if result == 0 {
self.print_freelist();
self.print_heap();
panic!("out of memory");
}
}
result
}
pub fn live_objects(&self) -> MemoryIntoIterator {
return self.into_iter();
}
pub fn add_root(&mut self, obj: usize) {
self.roots.push(obj);
}
pub fn remove_root(&mut self, obj: usize) {
for i in 0..self.roots.len() {
if obj == self.roots[i] {
self.roots.remove(i);
return;
}
}
}
pub fn at_put(&mut self, obj: usize, index: usize, value: usize) {
let slots = self.mem[obj];
let base = obj+OBJECT_HEADER_SLOTS;
let object =&mut self.mem[ base.. base + slots ];
object[index] = value;
}
pub fn at(&self, obj: usize, index: usize) -> usize {
let slots = self.mem[obj];
let base = obj+OBJECT_HEADER_SLOTS;
let object =&self.mem[ base.. base + slots ];
return object[index];
}
pub fn element_size(&self, obj: usize) -> usize {
return self.mem[obj] - OBJECT_HEADER_SLOTS;
}
pub fn enable_show_heap_map(&mut self, enabled: bool) {
self.show_heap_map = enabled;
}
pub fn enable_show_freelist(&mut self, enabled: bool) {
self.show_free_list = enabled;
}
pub fn enable_show_gc(&mut self, enabled: bool) {
self.show_gc = enabled;
}
pub fn enable_show_allocates(&mut self, enabled: bool) {
self.show_allocates = enabled;
}
fn rounded_size(unrounded_size: usize) -> usize {
(unrounded_size + 1) & !(1) // rounded to 2
}
fn get_size(&self, obj: usize) -> usize {
return self.mem[obj];
}
fn set_size(&mut self, obj: usize, size: usize) {
self.mem[obj] = size;
}
fn next_object_in_heap(&self, obj: usize) -> usize {
return obj + self.get_size(obj);
}
//free list is linked off the first slot
fn get_fl_next(&self, obj: usize) -> usize {
return self.mem[obj + 1];
}
fn set_fl_next(&mut self, obj: usize, next: usize) {
self.mem[obj + 1] = next;
}
fn mark_object(&mut self, obj: usize) {
self.mark_bits[obj / MARK_BITS_PER_SLOT] |= 1 << (obj % MARK_BITS_PER_SLOT);
}
fn unmark_object(&mut self, obj: usize) {
self.mark_bits[obj / MARK_BITS_PER_SLOT] &= !(1 << (obj % MARK_BITS_PER_SLOT));
}
fn is_marked(&self, obj: usize) -> bool {
(self.mark_bits[obj / MARK_BITS_PER_SLOT] & (1 << (obj % MARK_BITS_PER_SLOT))) != 0
}
fn allocate_object_nocompress(&mut self, unrounded_size: usize) -> usize {
let size = Memory::rounded_size(unrounded_size + OBJECT_HEADER_SLOTS);
let mut free = self.head;
while free != 0 {
let avail = self.get_size(free);
if avail > size {
let newsize = avail - size;
if newsize < 2 {
panic!("remaining size is less than 2");
}
// shrink current free to smaller size
self.set_size(free, newsize);
// new object is on the end of current free object
let new_object = free + newsize;
self.set_size(new_object, size);
for index in 0..self.element_size(new_object) {
self.at_put(new_object, index, 0);
}
if self.show_allocates {
println!(
"Success: allocate_object returning -> {} size {}",
new_object, size
);
}
if self.head != free {
if self.show_allocates {
println!("Reset head past intermediate free blocks \n");
let mut show = self.head;
while show != free {
println!("Abandon {} size {}\n", show, self.get_size(show));
show = self.get_fl_next(show);
}
}
self.head = free;
}
return new_object;
}
free = self.get_fl_next(free);
}
0
}
pub fn gc(&mut self) {
let start = SystemTime::now();
for i in 0..self.roots.len() {
self.mark_and_scan(self.roots[i]);
}
self.sweep();
self.gc_count += 1;
if self.show_gc {
self.print_gc_stats();
}
match start.elapsed() {
Ok(elapsed) => {
self.last_gc_ms = elapsed.as_millis();
self.total_gc_ms += self.last_gc_ms;
}
Err(e) => {
println!("Error: {:?}", e);
}
}
}
fn sweep(&mut self) {
let mut scan = 1;
self.head = 0;
let mut tail = self.head;
|
#[cfg(feature="dynamic_mem")]
const MAX_MEMORY_SLOTS: usize = 1024 * 1024 * 2; | random_line_split |
|
mod.rs | _free_list: bool,
}
impl<'a> IntoIterator for &'a Memory {
type Item = usize;
type IntoIter = MemoryIntoIterator<'a>;
fn into_iter(self) -> Self::IntoIter {
MemoryIntoIterator {
mem: self,
scan: 0,
free: 0,
}
}
}
pub struct MemoryIntoIterator<'a> {
mem: &'a Memory,
scan: usize,
free: usize,
}
impl<'a> Iterator for MemoryIntoIterator<'a> {
type Item = usize;
fn next(&mut self) -> Option<Self::Item> {
if self.scan == 0 {
self.scan = 1;
self.free = self.mem.head;
} else {
self.scan = self.mem.next_object_in_heap(self.scan);
}
while self.scan == self.free {
self.scan = self.mem.next_object_in_heap(self.free);
self.free = self.mem.get_fl_next(self.free);
}
if self.scan >= MAX_MEMORY_SLOTS - 1 {
return None;
} else {
return Some(self.scan);
}
}
}
#[cfg(feature = "dynamic_mem")]
fn im() -> Mem {
return vec![0; MAX_MEMORY_SLOTS];
}
#[cfg(not(feature = "dynamic_mem"))]
fn im() -> Mem {
return [0; MAX_MEMORY_SLOTS];
}
impl Memory {
pub fn initialze_memory() -> Memory {
let mut mem = Memory {
head: 1,
mem: im(),
mark_bits: [0; MARK_BITS],
roots: Vec::new(),
gc_count: 0,
allocates: 0,
lastgc_live_mem: 0,
lastgc_free_mem: 0,
last_gc_ms: 0,
total_gc_ms: 0,
show_gc: false,
show_allocates: false,
show_heap_map: false,
show_free_list: false,
};
mem.set_size(0, MAX_MEMORY_SLOTS); // magic memory at zero is heap_size
mem.set_size(mem.head, MAX_MEMORY_SLOTS - 2); // set initial object size as all heap
mem.set_fl_next(mem.head, 0);
mem
}
// objects API
// allocate_object (size) --- size is number of indexable slots
// add/remote_root () --- add to or remove from gc root set.
// element_size() - number of indexable slots - get_size() - OBJECT_HEADER_SLOTS
// at_put - store into object slot at index
// at -- fetch object slot at index
pub fn allocate_object(&mut self, unrounded_size: usize) -> usize {
self.allocates += 1;
let mut result = self.allocate_object_nocompress(unrounded_size);
if result == 0 {
self.gc();
result = self.allocate_object_nocompress(unrounded_size);
if result == 0 {
self.print_freelist();
self.print_heap();
panic!("out of memory");
}
}
result
}
pub fn live_objects(&self) -> MemoryIntoIterator {
return self.into_iter();
}
pub fn add_root(&mut self, obj: usize) {
self.roots.push(obj);
}
pub fn remove_root(&mut self, obj: usize) {
for i in 0..self.roots.len() {
if obj == self.roots[i] {
self.roots.remove(i);
return;
}
}
}
pub fn at_put(&mut self, obj: usize, index: usize, value: usize) {
let slots = self.mem[obj];
let base = obj+OBJECT_HEADER_SLOTS;
let object =&mut self.mem[ base.. base + slots ];
object[index] = value;
}
pub fn at(&self, obj: usize, index: usize) -> usize {
let slots = self.mem[obj];
let base = obj+OBJECT_HEADER_SLOTS;
let object =&self.mem[ base.. base + slots ];
return object[index];
}
pub fn element_size(&self, obj: usize) -> usize {
return self.mem[obj] - OBJECT_HEADER_SLOTS;
}
pub fn enable_show_heap_map(&mut self, enabled: bool) {
self.show_heap_map = enabled;
}
pub fn enable_show_freelist(&mut self, enabled: bool) {
self.show_free_list = enabled;
}
pub fn enable_show_gc(&mut self, enabled: bool) {
self.show_gc = enabled;
}
pub fn enable_show_allocates(&mut self, enabled: bool) {
self.show_allocates = enabled;
}
fn rounded_size(unrounded_size: usize) -> usize {
(unrounded_size + 1) & !(1) // rounded to 2
}
fn get_size(&self, obj: usize) -> usize {
return self.mem[obj];
}
fn set_size(&mut self, obj: usize, size: usize) {
self.mem[obj] = size;
}
fn next_object_in_heap(&self, obj: usize) -> usize {
return obj + self.get_size(obj);
}
//free list is linked off the first slot
fn get_fl_next(&self, obj: usize) -> usize {
return self.mem[obj + 1];
}
fn set_fl_next(&mut self, obj: usize, next: usize) {
self.mem[obj + 1] = next;
}
fn mark_object(&mut self, obj: usize) {
self.mark_bits[obj / MARK_BITS_PER_SLOT] |= 1 << (obj % MARK_BITS_PER_SLOT);
}
fn unmark_object(&mut self, obj: usize) {
self.mark_bits[obj / MARK_BITS_PER_SLOT] &= !(1 << (obj % MARK_BITS_PER_SLOT));
}
fn is_marked(&self, obj: usize) -> bool {
(self.mark_bits[obj / MARK_BITS_PER_SLOT] & (1 << (obj % MARK_BITS_PER_SLOT))) != 0
}
fn allocate_object_nocompress(&mut self, unrounded_size: usize) -> usize {
let size = Memory::rounded_size(unrounded_size + OBJECT_HEADER_SLOTS);
let mut free = self.head;
while free != 0 {
let avail = self.get_size(free);
if avail > size {
let newsize = avail - size;
if newsize < 2 {
panic!("remaining size is less than 2");
}
// shrink current free to smaller size
self.set_size(free, newsize);
// new object is on the end of current free object
let new_object = free + newsize;
self.set_size(new_object, size);
for index in 0..self.element_size(new_object) {
self.at_put(new_object, index, 0);
}
if self.show_allocates {
println!(
"Success: allocate_object returning -> {} size {}",
new_object, size
);
}
if self.head != free {
if self.show_allocates {
println!("Reset head past intermediate free blocks \n");
let mut show = self.head;
while show != free {
println!("Abandon {} size {}\n", show, self.get_size(show));
show = self.get_fl_next(show);
}
}
self.head = free;
}
return new_object;
}
free = self.get_fl_next(free);
}
0
}
pub fn gc(&mut self) {
let start = SystemTime::now();
for i in 0..self.roots.len() {
self.mark_and_scan(self.roots[i]);
}
self.sweep();
self.gc_count += 1;
if self.show_gc {
self.print_gc_stats();
}
match start.elapsed() {
Ok(elapsed) => {
self.last_gc_ms = elapsed.as_millis();
self.total_gc_ms += self.last_gc_ms;
}
Err(e) => {
println!("Error: {:?}", e);
}
}
}
fn sweep(&mut self) {
let mut scan = 1;
self.head = 0;
let mut tail = self.head;
self.lastgc_free_mem = 0;
self.lastgc_live_mem = 0;
while scan < MAX_MEMORY_SLOTS - 1 {
if self.is_marked(scan) {
self.unmark_object(scan);
self.lastgc_live_mem += self.get_size(scan);
} else {
self.lastgc_free_mem += self.get_size(scan);
if tail == 0 {
self.head = scan;
self.set_fl_next(scan, 0);
tail = scan;
} else {
if self.next_object_in_heap(tail) == scan {
self.set_size(tail, self.get_size(tail) + self.get_size(scan));
} else {
self.set_fl_next(tail, scan);
self.set_fl_next(scan, 0);
tail = scan;
}
}
}
scan = self.next_object_in_heap(scan);
}
if self.show_free_list {
self.print_freelist();
}
if self.show_heap_map {
self.print_heap();
}
}
fn mark_and_scan(&mut self, object: usize) {
if object == 0 || self.is_marked(object) | {
return;
} | conditional_block |
|
utils.py | ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## define possible strategies
if how == "binarizer":
strategy = lambda x: pd.get_dummies(x)
elif how == "ordinal":
enc = OrdinalEncoder()
strategy = lambda x: pd.DataFrame(enc.fit_transform(x), columns = x.columns)
else:
print("strategy not implemented (yet!). Using pandas.get_dummies() instead!")
strategy = lambda x: pd.get_dummies(x)
cols = []
## go through all remaining columns, check if 'object' features exist
for column in columns:
if pd.api.types.is_string_dtype(df[column]):
cols.append(column)
## get all other columns from data
other_columns = list(set(df.columns) - set(cols))
## get both subdatasets - the encoded one and the remaining original one
encoded_data_raw = strategy(df[cols])
data_raw = df[other_columns]
## merge both subdatasets
encoded_data = pd.concat([encoded_data_raw, data_raw], axis = 1)
return encoded_data
def check_nan(data:pd.Series) -> bool:
'''
checks whether given data contains NaN's
Parameters:
- data: data to check [pandas.Series], can also be pandas.DataFrame
Returns:
- nan's: True, if data contains NaN's, otherwise False [Boolean]
'''
## make sure not to overwrite given data
df = data.copy()
if (not type(df) == pd.DataFrame) and (not type(df) == pd.Series):
print("data is no pandas.DataFrame, no check for NaN's done")
return False
if type(df) == pd.DataFrame:
return data.isna().sum().sum().astype(bool)
return data.isna().sum().astype(bool)
def add_nan(data:pd.DataFrame, amount:float = 0.05) -> pd.DataFrame:
'''
taking the given DataFrame and randomly adds the given amount of NaN's into it
Parameters:
- data: given data to add NaN's to [pandas.DataFrame]
- amount: desired amount of NaN's [Float, default = 0.05]
Returns:
- nan_data: data containing desired amount of NaN's [pandas.DataFrame]
'''
## set a numpy array with <amount> number of `True`s in the shape of data
nan_array = np.random.random(data.shape) < amount
## mask every element in 'data' with an NaN, when that element in 'nan_array' is set to True
nan_data = data.mask(nan_array)
return nan_data
def check_numeric(data:pd.DataFrame, ignore_columns:list = []) -> pd.DataFrame:
'''
function that converts all columns in DataFrame into numeric ones. Deletes all columns where `pandas.to_numeric()` fails (as they seem to be Strings)
Parameters:
- data: DataFrame with all different kinds of column types [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame with converted columns and without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
if type(df) == pd.Series:
num_df = pd.to_numeric(df, errors = "coerce")
if num_df.isna().sum() > 0:
print("data cannot be converted to numerical data, you have to encode it")
return df
return num_df
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## iterate over all columns, convert them to numeric ones (float or int)
for col in tqdm(columns, desc="make all columns numerical"):
## if error, then fill with NaN
df[col] = pd.to_numeric(df[col], errors="coerce")
## drop all columns that contain NaN's
df = df.dropna(axis=1)
return df
def iter_columns(data:pd.DataFrame, columns:list, trait:str) -> str:
'''
iterator, going over all columns in DataFrame, checking their content for desired trait
Parameters:
- data: DataFrame to iterate over [pandas.DataFrame]
- columns: columns to check [List]
- trait: what shall the column be checked for. Possible values [String]
- Unique: check for unique values per column, returns columns consisting of the same value over all samples --> 'unique'
Returns:
- col: column that contains only one different value [String]
'''
## iterate over all given columns
for col in tqdm(columns, desc=f"handle {trait}'s'"):
## check for Unique's
if trait == "unique":
## check if column contains more than one different value
if data[col].unique().__len__() == 1:
## if yes, return that column
yield col
def handle_nans(data:pd.DataFrame, strategy:str = "null", ignore_columns:list = []) -> pd.DataFrame:
'''
function that drops all columns (=features) that only contain one different value
Parameters:
- data: DataFrame [pandas.DataFrame]
- strategy: strategy to fill in the dataset. Possible values are [String]
- 0: fill all with Zero --> 'null' = default
- Mean: fill all with mean of respective feature --> 'mean'
- Median: fill all with median of respective feature --> 'median'
- Max: fill all with max of respective feature --> 'max'
- Min: fill all with min of respective feature --> 'min'
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is data contains NaN's
if not check_nan(df):
print("no NaN's inside data")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## init columns to drop
cols = []
## check strategy, calculate filling value(s)
if strategy == "null":
value = [0 for _ in range(columns.__len__())]
elif strategy == "mean":
value = df[columns].mean()
elif strategy == "median":
value = df[columns].median()
elif strategy == "min":
value = df[columns].min()
elif strategy == "max":
value = df[columns].max()
else:
print("strategy not implemented (yet). Filling with 0")
value = [0 for _ in range(columns.__len__())]
df = df.fillna(dict(zip(columns, value)))
## drop columns that ONLY contain NaN's, no matter what 'ignore_columns' says
df = df.dropna(how = "all", axis = 1)
return df
def handle_uniques(data:pd.DataFrame, ignore_columns:list = []) -> pd.DataFrame:
'''
function that handles all columns (=features) that only contain one different value by dropping them --> they do not contain helpful (any) information
Parameters:
- data: DataFrame [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## init columns to drop
cols = []
## make sure not to overwrite given data
df = data.copy()
for col in iter_columns(df, columns, "unique"):
cols.append(col)
df = df.drop(cols, axis=1)
return df
def drop_features(data:pd.DataFrame, columns:list = []) -> pd.DataFrame:
'''
function that drops all columns are given by `columns`
Parameters:
- data: DataFrame with time columns [pandas.DataFrame]
- columns: List of columns that shall be deleted [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data or the given columns
cols = columns.copy()
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
print("data is no pandas.DataFrame, cannot be further processed")
return df
df = df.drop(cols, axis=1)
return df
def flatten(X:np.array) -> np.array:
| '''
flattens a 3D array into 2D array
Parameters:
- X: a 3D array with shape samples x width x height [numpy.array]
Returns:
- flattened_X: 2D array with shape sample x width*height [numpy.array]
'''
flattened_X = X.reshape(X.shape[0], -1)
return flattened_X | identifier_body |
|
utils.py | def check_nan(data:pd.Series) -> bool:
'''
checks whether given data contains NaN's
Parameters:
- data: data to check [pandas.Series], can also be pandas.DataFrame
Returns:
- nan's: True, if data contains NaN's, otherwise False [Boolean]
'''
## make sure not to overwrite given data
df = data.copy()
if (not type(df) == pd.DataFrame) and (not type(df) == pd.Series):
print("data is no pandas.DataFrame, no check for NaN's done")
return False
if type(df) == pd.DataFrame:
return data.isna().sum().sum().astype(bool)
return data.isna().sum().astype(bool)
def add_nan(data:pd.DataFrame, amount:float = 0.05) -> pd.DataFrame:
'''
taking the given DataFrame and randomly adds the given amount of NaN's into it
Parameters:
- data: given data to add NaN's to [pandas.DataFrame]
- amount: desired amount of NaN's [Float, default = 0.05]
Returns:
- nan_data: data containing desired amount of NaN's [pandas.DataFrame]
'''
## set a numpy array with <amount> number of `True`s in the shape of data
nan_array = np.random.random(data.shape) < amount
## mask every element in 'data' with an NaN, when that element in 'nan_array' is set to True
nan_data = data.mask(nan_array)
return nan_data
def check_numeric(data:pd.DataFrame, ignore_columns:list = []) -> pd.DataFrame:
'''
function that converts all columns in DataFrame into numeric ones. Deletes all columns where `pandas.to_numeric()` fails (as they seem to be Strings)
Parameters:
- data: DataFrame with all different kinds of column types [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame with converted columns and without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
if type(df) == pd.Series:
num_df = pd.to_numeric(df, errors = "coerce")
if num_df.isna().sum() > 0:
print("data cannot be converted to numerical data, you have to encode it")
return df
return num_df
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## iterate over all columns, convert them to numeric ones (float or int)
for col in tqdm(columns, desc="make all columns numerical"):
## if error, then fill with NaN
df[col] = pd.to_numeric(df[col], errors="coerce")
## drop all columns that contain NaN's
df = df.dropna(axis=1)
return df
def iter_columns(data:pd.DataFrame, columns:list, trait:str) -> str:
'''
iterator, going over all columns in DataFrame, checking their content for desired trait
Parameters:
- data: DataFrame to iterate over [pandas.DataFrame]
- columns: columns to check [List]
- trait: what shall the column be checked for. Possible values [String]
- Unique: check for unique values per column, returns columns consisting of the same value over all samples --> 'unique'
Returns:
- col: column that contains only one different value [String]
'''
## iterate over all given columns
for col in tqdm(columns, desc=f"handle {trait}'s'"):
## check for Unique's
if trait == "unique":
## check if column contains more than one different value
if data[col].unique().__len__() == 1:
## if yes, return that column
yield col
def handle_nans(data:pd.DataFrame, strategy:str = "null", ignore_columns:list = []) -> pd.DataFrame:
'''
function that drops all columns (=features) that only contain one different value
Parameters:
- data: DataFrame [pandas.DataFrame]
- strategy: strategy to fill in the dataset. Possible values are [String]
- 0: fill all with Zero --> 'null' = default
- Mean: fill all with mean of respective feature --> 'mean'
- Median: fill all with median of respective feature --> 'median'
- Max: fill all with max of respective feature --> 'max'
- Min: fill all with min of respective feature --> 'min'
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is data contains NaN's
if not check_nan(df):
print("no NaN's inside data")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## init columns to drop
cols = []
## check strategy, calculate filling value(s)
if strategy == "null":
value = [0 for _ in range(columns.__len__())]
elif strategy == "mean":
value = df[columns].mean()
elif strategy == "median":
value = df[columns].median()
elif strategy == "min":
value = df[columns].min()
elif strategy == "max":
value = df[columns].max()
else:
print("strategy not implemented (yet). Filling with 0")
value = [0 for _ in range(columns.__len__())]
df = df.fillna(dict(zip(columns, value)))
## drop columns that ONLY contain NaN's, no matter what 'ignore_columns' says
df = df.dropna(how = "all", axis = 1)
return df
def handle_uniques(data:pd.DataFrame, ignore_columns:list = []) -> pd.DataFrame:
'''
function that handles all columns (=features) that only contain one different value by dropping them --> they do not contain helpful (any) information
Parameters:
- data: DataFrame [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## init columns to drop
cols = []
## make sure not to overwrite given data
df = data.copy()
for col in iter_columns(df, columns, "unique"):
cols.append(col)
df = df.drop(cols, axis=1)
return df
def drop_features(data:pd.DataFrame, columns:list = []) -> pd.DataFrame:
'''
function that drops all columns are given by `columns`
Parameters:
- data: DataFrame with time columns [pandas.DataFrame]
- columns: List of columns that shall be deleted [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data or the given columns
cols = columns.copy()
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
print("data is no pandas.DataFrame, cannot be further processed")
return df
df = df.drop(cols, axis=1)
return df
def flatten(X:np.array) -> np.array:
'''
flattens a 3D array into 2D array
Parameters:
- X: a 3D array with shape samples x width x height [numpy.array]
Returns:
- flattened_X: 2D array with shape sample x width*height [numpy.array]
'''
flattened_X = X.reshape(X.shape[0], -1)
return flattened_X
def iter_scale(X:np.array, scaler:object) -> np.array:
'''
iterates over fiven X, scales given 3D array using given (trained) scaler
Parameters:
- X: 3D array with shape samples x length x features [numpy.array]
- scaler: scaler object, e.g., sklearn.preprocessing.StandardScaler, sklearn.preprocessing.normalize [object]
Returns:
- scaled_X: scaled 3D array of same shape [numpy.array]
'''
## copy X to make sure not to overwrite the original data
scaled_X = X.copy()
for X_to_scale in tqdm(scaled_X):
yield scaler.transform(X_to_scale.reshape(1, -1)).reshape(X_to_scale.shape)
def pca(X:np.array, y:np.array) -> (np.array, np.array):
''' | plots a scatter showing the transformed dataset (if it is 2D) with different coloring for the different classes
Parameters:
- X: Array containing the original x values [numpy.array]
- y: Array containing the labels [numpy.array]
Returns: | random_line_split |
|
utils.py | List of columns that shall be ignored [List, default = []]
- how: strategy to encode. The following are possible [String]
- Binarize: every unique value gets own column, filled with 0's and 1's, using pandas.get_dummies() --> 'binarizer' = Default
- OrdinalEncoder: unique values get replaced by increasing number (same amount of features) using sklearn's OrdinalEncoder --> 'ordinal'
Returns:
- encoded_data: encoded DataFrame [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
if type(df) == pd.Series:
df = pd.DataFrame(data)
df.columns = ["Series_Data"]
else:
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## define possible strategies
if how == "binarizer":
strategy = lambda x: pd.get_dummies(x)
elif how == "ordinal":
enc = OrdinalEncoder()
strategy = lambda x: pd.DataFrame(enc.fit_transform(x), columns = x.columns)
else:
print("strategy not implemented (yet!). Using pandas.get_dummies() instead!")
strategy = lambda x: pd.get_dummies(x)
cols = []
## go through all remaining columns, check if 'object' features exist
for column in columns:
if pd.api.types.is_string_dtype(df[column]):
cols.append(column)
## get all other columns from data
other_columns = list(set(df.columns) - set(cols))
## get both subdatasets - the encoded one and the remaining original one
encoded_data_raw = strategy(df[cols])
data_raw = df[other_columns]
## merge both subdatasets
encoded_data = pd.concat([encoded_data_raw, data_raw], axis = 1)
return encoded_data
def check_nan(data:pd.Series) -> bool:
'''
checks whether given data contains NaN's
Parameters:
- data: data to check [pandas.Series], can also be pandas.DataFrame
Returns:
- nan's: True, if data contains NaN's, otherwise False [Boolean]
'''
## make sure not to overwrite given data
df = data.copy()
if (not type(df) == pd.DataFrame) and (not type(df) == pd.Series):
print("data is no pandas.DataFrame, no check for NaN's done")
return False
if type(df) == pd.DataFrame:
return data.isna().sum().sum().astype(bool)
return data.isna().sum().astype(bool)
def add_nan(data:pd.DataFrame, amount:float = 0.05) -> pd.DataFrame:
'''
taking the given DataFrame and randomly adds the given amount of NaN's into it
Parameters:
- data: given data to add NaN's to [pandas.DataFrame]
- amount: desired amount of NaN's [Float, default = 0.05]
Returns:
- nan_data: data containing desired amount of NaN's [pandas.DataFrame]
'''
## set a numpy array with <amount> number of `True`s in the shape of data
nan_array = np.random.random(data.shape) < amount
## mask every element in 'data' with an NaN, when that element in 'nan_array' is set to True
nan_data = data.mask(nan_array)
return nan_data
def check_numeric(data:pd.DataFrame, ignore_columns:list = []) -> pd.DataFrame:
'''
function that converts all columns in DataFrame into numeric ones. Deletes all columns where `pandas.to_numeric()` fails (as they seem to be Strings)
Parameters:
- data: DataFrame with all different kinds of column types [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame with converted columns and without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
if type(df) == pd.Series:
num_df = pd.to_numeric(df, errors = "coerce")
if num_df.isna().sum() > 0:
print("data cannot be converted to numerical data, you have to encode it")
return df
return num_df
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## iterate over all columns, convert them to numeric ones (float or int)
for col in tqdm(columns, desc="make all columns numerical"):
## if error, then fill with NaN
df[col] = pd.to_numeric(df[col], errors="coerce")
## drop all columns that contain NaN's
df = df.dropna(axis=1)
return df
def iter_columns(data:pd.DataFrame, columns:list, trait:str) -> str:
'''
iterator, going over all columns in DataFrame, checking their content for desired trait
Parameters:
- data: DataFrame to iterate over [pandas.DataFrame]
- columns: columns to check [List]
- trait: what shall the column be checked for. Possible values [String]
- Unique: check for unique values per column, returns columns consisting of the same value over all samples --> 'unique'
Returns:
- col: column that contains only one different value [String]
'''
## iterate over all given columns
for col in tqdm(columns, desc=f"handle {trait}'s'"):
## check for Unique's
if trait == "unique":
## check if column contains more than one different value
if data[col].unique().__len__() == 1:
## if yes, return that column
yield col
def handle_nans(data:pd.DataFrame, strategy:str = "null", ignore_columns:list = []) -> pd.DataFrame:
'''
function that drops all columns (=features) that only contain one different value
Parameters:
- data: DataFrame [pandas.DataFrame]
- strategy: strategy to fill in the dataset. Possible values are [String]
- 0: fill all with Zero --> 'null' = default
- Mean: fill all with mean of respective feature --> 'mean'
- Median: fill all with median of respective feature --> 'median'
- Max: fill all with max of respective feature --> 'max'
- Min: fill all with min of respective feature --> 'min'
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is data contains NaN's
if not check_nan(df):
print("no NaN's inside data")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## init columns to drop
cols = []
## check strategy, calculate filling value(s)
if strategy == "null":
|
elif strategy == "mean":
value = df[columns].mean()
elif strategy == "median":
value = df[columns].median()
elif strategy == "min":
value = df[columns].min()
elif strategy == "max":
value = df[columns].max()
else:
print("strategy not implemented (yet). Filling with 0")
value = [0 for _ in range(columns.__len__())]
df = df.fillna(dict(zip(columns, value)))
## drop columns that ONLY contain NaN's, no matter what 'ignore_columns' says
df = df.dropna(how = "all", axis = 1)
return df
def handle_uniques(data:pd.DataFrame, ignore_columns:list = []) -> pd.DataFrame:
'''
function that handles all columns (=features) that only contain one different value by dropping them --> they do not contain helpful (any) information
Parameters:
- data: DataFrame [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## init columns to drop
cols = []
## make sure not to overwrite given data
df = data.copy()
for col in iter_columns(df, columns, "unique"):
cols.append(col)
df = df.drop(cols, axis=1)
return df
def drop_features(data:pd.DataFrame, columns:list = []) -> pd.DataFrame:
'''
function that drops all columns are given by `columns`
Parameters:
- data: DataFrame with time columns [pandas.DataFrame]
- | value = [0 for _ in range(columns.__len__())] | conditional_block |
utils.py | (data:pd.DataFrame, approach:str = "reuse") -> pd.DataFrame:
'''
function to balance the appearance of samples from different classes -> tackle distribution shift
Parameters:
- data: data with distribution shift [pandas.DataFrame]
- approach: strategy to tackle the distribution shift. Possible values are [String]
- reusing minor class samples --> 'reuse' = default
- mixing both approaches by using the size of the median common class --> "mix"
- constraining the number of major class samples --> 'constrain'
Returns:
- df: data without distribution shift [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## get all labels that exist
labels = data.loc[:, "Label"]
## get appearances of each label
counted_labels = Counter(labels).most_common()
## get max num of samples (valid for all classes)
if approach == "reuse":
## take appearance value of most common label
sample_size = counted_labels[0][1]
elif approach == "mix":
sample_size = counted_labels[int(counted_labels.__len__()*0.5)][1]
elif approach == "constrain":
## take appearance value of least common label
sample_size = counted_labels[-1][1]
else:
print("approach not implemented (yet)! Using 'resue' instead!")
## take appearance value of most common label
sample_size = counted_labels[0][1]
## take a 'subset' or 'superset' of every class
sampled_data = [df[df.Label == label].sample(n = sample_size, replace = True) for label in np.unique(labels)]
## return merged data
return pd.concat(sampled_data).reset_index(drop = True)
def encode_objects(data:pd.DataFrame, ignore_columns:list = [], how:str = "binarizer") -> pd.DataFrame:
'''
goes through given dataset, encodes all object columns into numerical data
Parameters:
- data: DataFrame to anaylse [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
- how: strategy to encode. The following are possible [String]
- Binarize: every unique value gets own column, filled with 0's and 1's, using pandas.get_dummies() --> 'binarizer' = Default
- OrdinalEncoder: unique values get replaced by increasing number (same amount of features) using sklearn's OrdinalEncoder --> 'ordinal'
Returns:
- encoded_data: encoded DataFrame [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
if type(df) == pd.Series:
df = pd.DataFrame(data)
df.columns = ["Series_Data"]
else:
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## define possible strategies
if how == "binarizer":
strategy = lambda x: pd.get_dummies(x)
elif how == "ordinal":
enc = OrdinalEncoder()
strategy = lambda x: pd.DataFrame(enc.fit_transform(x), columns = x.columns)
else:
print("strategy not implemented (yet!). Using pandas.get_dummies() instead!")
strategy = lambda x: pd.get_dummies(x)
cols = []
## go through all remaining columns, check if 'object' features exist
for column in columns:
if pd.api.types.is_string_dtype(df[column]):
cols.append(column)
## get all other columns from data
other_columns = list(set(df.columns) - set(cols))
## get both subdatasets - the encoded one and the remaining original one
encoded_data_raw = strategy(df[cols])
data_raw = df[other_columns]
## merge both subdatasets
encoded_data = pd.concat([encoded_data_raw, data_raw], axis = 1)
return encoded_data
def check_nan(data:pd.Series) -> bool:
'''
checks whether given data contains NaN's
Parameters:
- data: data to check [pandas.Series], can also be pandas.DataFrame
Returns:
- nan's: True, if data contains NaN's, otherwise False [Boolean]
'''
## make sure not to overwrite given data
df = data.copy()
if (not type(df) == pd.DataFrame) and (not type(df) == pd.Series):
print("data is no pandas.DataFrame, no check for NaN's done")
return False
if type(df) == pd.DataFrame:
return data.isna().sum().sum().astype(bool)
return data.isna().sum().astype(bool)
def add_nan(data:pd.DataFrame, amount:float = 0.05) -> pd.DataFrame:
'''
taking the given DataFrame and randomly adds the given amount of NaN's into it
Parameters:
- data: given data to add NaN's to [pandas.DataFrame]
- amount: desired amount of NaN's [Float, default = 0.05]
Returns:
- nan_data: data containing desired amount of NaN's [pandas.DataFrame]
'''
## set a numpy array with <amount> number of `True`s in the shape of data
nan_array = np.random.random(data.shape) < amount
## mask every element in 'data' with an NaN, when that element in 'nan_array' is set to True
nan_data = data.mask(nan_array)
return nan_data
def check_numeric(data:pd.DataFrame, ignore_columns:list = []) -> pd.DataFrame:
'''
function that converts all columns in DataFrame into numeric ones. Deletes all columns where `pandas.to_numeric()` fails (as they seem to be Strings)
Parameters:
- data: DataFrame with all different kinds of column types [pandas.DataFrame]
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame with converted columns and without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is pandas.DataFrame
if not type(df) == pd.DataFrame:
if type(df) == pd.Series:
num_df = pd.to_numeric(df, errors = "coerce")
if num_df.isna().sum() > 0:
print("data cannot be converted to numerical data, you have to encode it")
return df
return num_df
print("data is no pandas.DataFrame, cannot be further processed")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## iterate over all columns, convert them to numeric ones (float or int)
for col in tqdm(columns, desc="make all columns numerical"):
## if error, then fill with NaN
df[col] = pd.to_numeric(df[col], errors="coerce")
## drop all columns that contain NaN's
df = df.dropna(axis=1)
return df
def iter_columns(data:pd.DataFrame, columns:list, trait:str) -> str:
'''
iterator, going over all columns in DataFrame, checking their content for desired trait
Parameters:
- data: DataFrame to iterate over [pandas.DataFrame]
- columns: columns to check [List]
- trait: what shall the column be checked for. Possible values [String]
- Unique: check for unique values per column, returns columns consisting of the same value over all samples --> 'unique'
Returns:
- col: column that contains only one different value [String]
'''
## iterate over all given columns
for col in tqdm(columns, desc=f"handle {trait}'s'"):
## check for Unique's
if trait == "unique":
## check if column contains more than one different value
if data[col].unique().__len__() == 1:
## if yes, return that column
yield col
def handle_nans(data:pd.DataFrame, strategy:str = "null", ignore_columns:list = []) -> pd.DataFrame:
'''
function that drops all columns (=features) that only contain one different value
Parameters:
- data: DataFrame [pandas.DataFrame]
- strategy: strategy to fill in the dataset. Possible values are [String]
- 0: fill all with Zero --> 'null' = default
- Mean: fill all with mean of respective feature --> 'mean'
- Median: fill all with median of respective feature --> 'median'
- Max: fill all with max of respective feature --> 'max'
- Min: fill all with min of respective feature --> 'min'
- ignore_columns: List of columns that shall be ignored [List, default = []]
Returns:
- df: DataFrame without deleted columns [pandas.DataFrame]
'''
## make sure not to overwrite given data
df = data.copy()
## check if data is data contains NaN's
if not check_nan(df):
print("no NaN's inside data")
return df
## remaining columns that shall be checked (all - ignore_columns)
columns = list(set(df.columns) - set(ignore_columns))
## init columns to drop
cols = []
## check strategy, calculate filling value(s)
if strategy == "null | tackle_distribution_shift | identifier_name |
|
models.go | exported.
ReleasePolicy *KeyReleasePolicy
// Application specific metadata in the form of key-value pairs.
Tags map[string]*string
}
// DeletedKey - A DeletedKey consisting of a WebKey plus its Attributes and deletion info
type DeletedKey struct {
// The key management attributes.
Attributes *KeyAttributes
// The Json web key.
Key *JSONWebKey
// The url of the recovery object, used to identify and recover the deleted key.
RecoveryID *string
// The policy rules under which the key can be exported.
ReleasePolicy *KeyReleasePolicy
// Application specific metadata in the form of key-value pairs.
Tags map[string]*string
// READ-ONLY; The time when the key was deleted, in UTC
DeletedDate *time.Time
// READ-ONLY; True if the key's lifetime is managed by key vault. If this is a key backing a certificate, then managed will
// be true.
Managed *bool
// READ-ONLY; The time when the key is scheduled to be purged, in UTC
ScheduledPurgeDate *time.Time
}
// DeletedKeyProperties - The deleted key item containing the deleted key metadata and information about deletion.
type DeletedKeyProperties struct {
// The key management attributes.
Attributes *KeyAttributes
// Key identifier.
KID *ID
// The url of the recovery object, used to identify and recover the deleted key.
RecoveryID *string
// Application specific metadata in the form of key-value pairs.
Tags map[string]*string
// READ-ONLY; The time when the key was deleted, in UTC
DeletedDate *time.Time
// READ-ONLY; True if the key's lifetime is managed by key vault. If this is a key backing a certificate, then managed will
// be true.
Managed *bool
// READ-ONLY; The time when the key is scheduled to be purged, in UTC
ScheduledPurgeDate *time.Time
}
// DeletedKeyPropertiesListResult - A list of keys that have been deleted in this vault.
type DeletedKeyPropertiesListResult struct {
// READ-ONLY; The URL to get the next set of deleted keys.
NextLink *string
// READ-ONLY; A response message containing a list of deleted keys in the vault along with a link to the next page of deleted
// keys
Value []*DeletedKeyProperties
}
// GetRandomBytesParameters - The get random bytes request object.
type GetRandomBytesParameters struct {
// REQUIRED; The requested number of random bytes.
Count *int32
}
// ImportKeyParameters - The key import parameters.
type ImportKeyParameters struct {
// REQUIRED; The Json web key
Key *JSONWebKey
// Whether to import as a hardware key (HSM) or software key.
HSM *bool
// The key management attributes.
KeyAttributes *KeyAttributes
// The policy rules under which the key can be exported.
ReleasePolicy *KeyReleasePolicy
// Application specific metadata in the form of key-value pairs.
Tags map[string]*string
}
// JSONWebKey - As of http://tools.ietf.org/html/draft-ietf-jose-json-web-key-18
type JSONWebKey struct {
// Elliptic curve name.
Crv *CurveName
// RSA private exponent, or the D component of an EC private key.
D []byte
// RSA private key parameter.
DP []byte
// RSA private key parameter.
DQ []byte
// RSA public exponent.
E []byte
// Symmetric key.
K []byte
// Key identifier.
KID *ID
KeyOps []*KeyOperation
// JsonWebKey Key Type (kty), as defined in https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40.
Kty *KeyType
// RSA modulus.
N []byte
// RSA secret prime.
P []byte
// RSA secret prime, with p < q.
Q []byte
// RSA private key parameter.
QI []byte
// Protected Key, used with 'Bring Your Own Key'.
T []byte
// X component of an EC public key.
X []byte
// Y component of an EC public key.
Y []byte
}
// KeyAttributes - The attributes of a key managed by the key vault service.
type KeyAttributes struct {
// Determines whether the object is enabled.
Enabled *bool
// Expiry date in UTC.
Expires *time.Time
// Indicates if the private key can be exported. Release policy must be provided when creating the first version of an exportable
// key.
Exportable *bool
// Not before date in UTC.
NotBefore *time.Time
// READ-ONLY; Creation time in UTC.
Created *time.Time
// READ-ONLY; softDelete data retention days. Value should be >=7 and <=90 when softDelete enabled, otherwise 0.
RecoverableDays *int32
// READ-ONLY; Reflects the deletion recovery level currently in effect for keys in the current vault. If it contains 'Purgeable'
// the key can be permanently deleted by a privileged user; otherwise, only the system
// can purge the key, at the end of the retention interval.
RecoveryLevel *string
// READ-ONLY; Last updated time in UTC.
Updated *time.Time
}
// KeyBundle - A KeyBundle consisting of a WebKey plus its attributes.
type KeyBundle struct {
// The key management attributes.
Attributes *KeyAttributes
// The Json web key.
Key *JSONWebKey
// The policy rules under which the key can be exported.
ReleasePolicy *KeyReleasePolicy
// Application specific metadata in the form of key-value pairs.
Tags map[string]*string
// READ-ONLY; True if the key's lifetime is managed by key vault. If this is a key backing a certificate, then managed will
// be true.
Managed *bool
}
// KeyOperationParameters - The key operations parameters.
type KeyOperationParameters struct {
// REQUIRED; algorithm identifier
Algorithm *EncryptionAlgorithm
// REQUIRED
Value []byte
// Additional data to authenticate but not encrypt/decrypt when using authenticated crypto algorithms.
AdditionalAuthenticatedData []byte
// The tag to authenticate when performing decryption with an authenticated algorithm.
AuthenticationTag []byte
// Cryptographically random, non-repeating initialization vector for symmetric algorithms.
IV []byte
}
// KeyOperationResult - The key operation result.
type KeyOperationResult struct {
// READ-ONLY
AdditionalAuthenticatedData []byte
// READ-ONLY
AuthenticationTag []byte
// READ-ONLY
IV []byte
// READ-ONLY; Key identifier
KID *ID
// READ-ONLY
Result []byte
}
// KeyProperties - The key item containing key metadata.
type KeyProperties struct {
// The key management attributes.
Attributes *KeyAttributes
// Key identifier.
KID *ID
// Application specific metadata in the form of key-value pairs.
Tags map[string]*string
// READ-ONLY; True if the key's lifetime is managed by key vault. If this is a key backing a certificate, then managed will
// be true.
Managed *bool
}
// KeyPropertiesListResult - The key list result.
type KeyPropertiesListResult struct {
// READ-ONLY; The URL to get the next set of keys.
NextLink *string
// READ-ONLY; A response message containing a list of keys in the key vault along with a link to the next page of keys.
Value []*KeyProperties
}
// KeyReleasePolicy - The policy rules under which the key can be exported.
type KeyReleasePolicy struct {
// Content type and version of key release policy
ContentType *string
// Blob encoding the policy rules under which the key can be released. Blob must be base64 URL encoded.
EncodedPolicy []byte
// Defines the mutability state of the policy. Once marked immutable, this flag cannot be reset and the policy cannot be changed
// under any circumstances.
Immutable *bool
}
// KeyReleaseResult - The release result, containing the released key.
type KeyReleaseResult struct {
// READ-ONLY; A signed object containing the released key.
Value *string
}
// KeyRotationPolicy - Management policy for a key.
type KeyRotationPolicy struct {
// The key rotation policy attributes.
Attributes *KeyRotationPolicyAttributes
// Actions that will be performed by Key Vault over the lifetime of a key. For preview, lifetimeActions can only have two
// items at maximum: one for rotate, one for notify. Notification time would be
// default to 30 days before expiry and it is not configurable.
LifetimeActions []*LifetimeAction
// READ-ONLY; The key policy id.
ID *string
}
// KeyRotationPolicyAttributes - The key rotation policy attributes.
type KeyRotationPolicyAttributes struct {
// The expiryTime will be applied on the new key version. It should be at least 28 days. It will be in ISO 8601 Format. Examples:
// 90 days: P90D, 3 months: P3M, 48 hours: PT48H, 1 year and 10 days: P1Y10D | ExpiryTime *string
// READ-ONLY; The key rotation policy created time in UTC. | random_line_split |
|
stateful.go | state will then be the set of rules used for matching
// until another Push or Pop is encountered.
func Push(state string) Action {
return ActionPush{state}
}
type include struct{ state string }
func (i include) applyAction(lexer *Lexer, groups []string) error { panic("should not be called") }
func (i include) applyRules(state string, rule int, rules compiledRules) error {
includedRules, ok := rules[i.state]
if !ok {
return fmt.Errorf("invalid include state %q", i.state)
}
clone := make([]compiledRule, len(includedRules))
copy(clone, includedRules)
rules[state] = append(rules[state][:rule], append(clone, rules[state][rule+1:]...)...) // nolint: makezero
return nil
}
// Include rules from another state in this one.
func Include(state string) Rule {
return Rule{Action: include{state}}
}
// Definition is the lexer.Definition.
type Definition struct {
rules compiledRules
symbols map[string]rune
// Map of key->*regexp.Regexp
backrefCache sync.Map
initialState string
}
// MustSimple creates a new lexer definition based on a single state described by `rules`.
// panics if the rules trigger an error
func MustSimple(rules []Rule, options ...Option) *Definition {
def, err := NewSimple(rules, options...)
if err != nil {
panic(err)
}
return def
}
// Must creates a new stateful lexer and panics if it is incorrect.
func Must(rules Rules, options ...Option) *Definition {
def, err := New(rules, options...)
if err != nil {
panic(err)
}
return def
}
// NewSimple creates a new stateful lexer with a single "Root" state.
func NewSimple(rules []Rule, options ...Option) (*Definition, error) {
return New(Rules{"Root": rules}, options...)
}
// New constructs a new stateful lexer from rules.
func New(rules Rules, options ...Option) (*Definition, error) {
compiled := compiledRules{}
for key, set := range rules {
for i, rule := range set {
pattern := "^(?:" + rule.Pattern + ")"
var (
re *regexp.Regexp
err error
)
var match = backrefReplace.FindStringSubmatch(rule.Pattern)
if match == nil || len(match[1])%2 == 0 {
re, err = regexp.Compile(pattern)
if err != nil {
return nil, fmt.Errorf("%s.%d: %s", key, i, err)
}
}
compiled[key] = append(compiled[key], compiledRule{
Rule: rule,
ignore: len(rule.Name) > 0 && unicode.IsLower(rune(rule.Name[0])),
RE: re,
})
}
}
restart:
for state, rules := range compiled {
for i, rule := range rules {
if action, ok := rule.Action.(RulesAction); ok {
if err := action.applyRules(state, i, compiled); err != nil {
return nil, fmt.Errorf("%s.%d: %s", state, i, err)
}
goto restart
}
}
}
keys := make([]string, 0, len(compiled))
for key := range compiled {
keys = append(keys, key)
}
symbols := map[string]rune{
"EOF": lexer.EOF,
}
sort.Strings(keys)
duplicates := map[string]compiledRule{}
rn := lexer.EOF - 1
for _, key := range keys {
for i, rule := range compiled[key] {
if dup, ok := duplicates[rule.Name]; ok && rule.Pattern != dup.Pattern {
panic(fmt.Sprintf("duplicate key %q with different patterns %q != %q", rule.Name, rule.Pattern, dup.Pattern))
}
duplicates[rule.Name] = rule
compiled[key][i] = rule
symbols[rule.Name] = rn
rn--
}
}
d := &Definition{
initialState: "Root",
rules: compiled,
symbols: symbols,
}
for _, option := range options {
option(d)
}
return d, nil
}
// Rules returns the user-provided Rules used to construct the lexer.
func (d *Definition) Rules() Rules {
out := Rules{}
for state, rules := range d.rules {
for _, rule := range rules {
out[state] = append(out[state], rule.Rule)
}
}
return out
}
func (d *Definition) LexString(filename string, s string) (lexer.Lexer, error) { // nolint: golint
return &Lexer{
def: d,
data: s,
stack: []lexerState{{name: d.initialState}},
pos: lexer.Position{
Filename: filename,
Line: 1,
Column: 1,
},
}, nil
}
func (d *Definition) Lex(filename string, r io.Reader) (lexer.Lexer, error) { // nolint: golint
w := &strings.Builder{}
_, err := io.Copy(w, r)
if err != nil {
return nil, err
}
return d.LexString(filename, w.String())
}
func (d *Definition) Symbols() map[string]rune { // nolint: golint
return d.symbols
}
type lexerState struct {
name string
groups []string
}
// Lexer implementation.
type Lexer struct {
stack []lexerState
def *Definition
data string
pos lexer.Position
}
func (l *Lexer) Next() (lexer.Token, error) { // nolint: golint
parent := l.stack[len(l.stack)-1]
rules := l.def.rules[parent.name]
next:
for len(l.data) > 0 {
var (
rule *compiledRule
match []int
)
for _, candidate := range rules {
// Special case "Return()".
if candidate.Rule == ReturnRule {
l.stack = l.stack[:len(l.stack)-1]
parent = l.stack[len(l.stack)-1]
rules = l.def.rules[parent.name]
continue next
}
re, err := l.getPattern(candidate)
if err != nil {
return lexer.Token{}, participle.Wrapf(l.pos, err, "rule %q", candidate.Name)
}
match = re.FindStringSubmatchIndex(l.data)
if match != nil {
rule = &candidate // nolint
break
}
}
if match == nil || rule == nil {
sample := []rune(l.data)
if len(sample) > 16 {
sample = append(sample[:16], []rune("...")...)
}
return lexer.Token{}, participle.Errorf(l.pos, "invalid input text %q", string(sample))
}
if rule.Action != nil {
groups := make([]string, 0, len(match)/2)
for i := 0; i < len(match); i += 2 {
groups = append(groups, l.data[match[i]:match[i+1]])
}
if err := rule.Action.applyAction(l, groups); err != nil {
return lexer.Token{}, participle.Errorf(l.pos, "rule %q: %s", rule.Name, err)
}
} else if match[0] == match[1] {
return lexer.Token{}, participle.Errorf(l.pos, "rule %q did not match any input", rule.Name)
}
span := l.data[match[0]:match[1]]
l.data = l.data[match[1]:]
// l.groups = groups
// Update position.
pos := l.pos
l.pos.Offset += match[1]
lines := strings.Count(span, "\n")
l.pos.Line += lines
// Update column.
if lines == 0 {
l.pos.Column += utf8.RuneCountInString(span)
} else {
l.pos.Column = utf8.RuneCountInString(span[strings.LastIndex(span, "\n"):])
}
if rule.ignore {
parent = l.stack[len(l.stack)-1]
rules = l.def.rules[parent.name]
continue
}
return lexer.Token{
Type: l.def.symbols[rule.Name],
Value: span,
Pos: pos,
}, nil
}
return lexer.EOFToken(l.pos), nil
}
func (l *Lexer) getPattern(candidate compiledRule) (*regexp.Regexp, error) | {
if candidate.RE != nil {
return candidate.RE, nil
}
// We don't have a compiled RE. This means there are back-references
// that need to be substituted first.
parent := l.stack[len(l.stack)-1]
key := candidate.Pattern + "\000" + strings.Join(parent.groups, "\000")
cached, ok := l.def.backrefCache.Load(key)
if ok {
return cached.(*regexp.Regexp), nil
}
var (
re *regexp.Regexp
err error
)
pattern := backrefReplace.ReplaceAllStringFunc(candidate.Pattern, func(s string) string {
var rematch = backrefReplace.FindStringSubmatch(s) | identifier_body |
|
stateful.go | "
"github.com/alecthomas/participle/v2"
"github.com/alecthomas/participle/v2/lexer"
)
var (
backrefReplace = regexp.MustCompile(`(\\+)(\d)`)
)
// Option for modifying how the Lexer works.
type Option func(d *Definition)
// InitialState overrides the default initial state of "Root".
func InitialState(state string) Option {
return func(d *Definition) {
d.initialState = state
}
}
// A Rule matching input and possibly changing state.
type Rule struct {
Name string
Pattern string
Action Action
}
// Rules grouped by name.
type Rules map[string][]Rule
// compiledRule is a Rule with its pattern compiled.
type compiledRule struct {
Rule
ignore bool
RE *regexp.Regexp
}
// compiledRules grouped by name.
type compiledRules map[string][]compiledRule
// A Action is applied when a rule matches.
type Action interface {
// Actions are responsible for validating the match. ie. if they consumed any input.
applyAction(lexer *Lexer, groups []string) error
}
// RulesAction is an optional interface that Actions can implement.
//
// It is applied during rule construction to mutate the rule map.
type RulesAction interface {
applyRules(state string, rule int, rules compiledRules) error
}
// ActionPop pops to the previous state when the Rule matches. |
func (p ActionPop) applyAction(lexer *Lexer, groups []string) error {
if groups[0] == "" {
return errors.New("did not consume any input")
}
lexer.stack = lexer.stack[:len(lexer.stack)-1]
return nil
}
// Pop to the previous state.
func Pop() Action {
return ActionPop{}
}
// ReturnRule signals the lexer to return immediately.
var ReturnRule = Rule{"returnToParent", "", nil}
// Return to the parent state.
//
// Useful as the last rule in a sub-state.
func Return() Rule { return ReturnRule }
// ActionPush pushes the current state and switches to "State" when the Rule matches.
type ActionPush struct{ State string }
func (p ActionPush) applyAction(lexer *Lexer, groups []string) error {
if groups[0] == "" {
return errors.New("did not consume any input")
}
lexer.stack = append(lexer.stack, lexerState{name: p.State, groups: groups})
return nil
}
// Push to the given state.
//
// The target state will then be the set of rules used for matching
// until another Push or Pop is encountered.
func Push(state string) Action {
return ActionPush{state}
}
type include struct{ state string }
func (i include) applyAction(lexer *Lexer, groups []string) error { panic("should not be called") }
func (i include) applyRules(state string, rule int, rules compiledRules) error {
includedRules, ok := rules[i.state]
if !ok {
return fmt.Errorf("invalid include state %q", i.state)
}
clone := make([]compiledRule, len(includedRules))
copy(clone, includedRules)
rules[state] = append(rules[state][:rule], append(clone, rules[state][rule+1:]...)...) // nolint: makezero
return nil
}
// Include rules from another state in this one.
func Include(state string) Rule {
return Rule{Action: include{state}}
}
// Definition is the lexer.Definition.
type Definition struct {
rules compiledRules
symbols map[string]rune
// Map of key->*regexp.Regexp
backrefCache sync.Map
initialState string
}
// MustSimple creates a new lexer definition based on a single state described by `rules`.
// panics if the rules trigger an error
func MustSimple(rules []Rule, options ...Option) *Definition {
def, err := NewSimple(rules, options...)
if err != nil {
panic(err)
}
return def
}
// Must creates a new stateful lexer and panics if it is incorrect.
func Must(rules Rules, options ...Option) *Definition {
def, err := New(rules, options...)
if err != nil {
panic(err)
}
return def
}
// NewSimple creates a new stateful lexer with a single "Root" state.
func NewSimple(rules []Rule, options ...Option) (*Definition, error) {
return New(Rules{"Root": rules}, options...)
}
// New constructs a new stateful lexer from rules.
func New(rules Rules, options ...Option) (*Definition, error) {
compiled := compiledRules{}
for key, set := range rules {
for i, rule := range set {
pattern := "^(?:" + rule.Pattern + ")"
var (
re *regexp.Regexp
err error
)
var match = backrefReplace.FindStringSubmatch(rule.Pattern)
if match == nil || len(match[1])%2 == 0 {
re, err = regexp.Compile(pattern)
if err != nil {
return nil, fmt.Errorf("%s.%d: %s", key, i, err)
}
}
compiled[key] = append(compiled[key], compiledRule{
Rule: rule,
ignore: len(rule.Name) > 0 && unicode.IsLower(rune(rule.Name[0])),
RE: re,
})
}
}
restart:
for state, rules := range compiled {
for i, rule := range rules {
if action, ok := rule.Action.(RulesAction); ok {
if err := action.applyRules(state, i, compiled); err != nil {
return nil, fmt.Errorf("%s.%d: %s", state, i, err)
}
goto restart
}
}
}
keys := make([]string, 0, len(compiled))
for key := range compiled {
keys = append(keys, key)
}
symbols := map[string]rune{
"EOF": lexer.EOF,
}
sort.Strings(keys)
duplicates := map[string]compiledRule{}
rn := lexer.EOF - 1
for _, key := range keys {
for i, rule := range compiled[key] {
if dup, ok := duplicates[rule.Name]; ok && rule.Pattern != dup.Pattern {
panic(fmt.Sprintf("duplicate key %q with different patterns %q != %q", rule.Name, rule.Pattern, dup.Pattern))
}
duplicates[rule.Name] = rule
compiled[key][i] = rule
symbols[rule.Name] = rn
rn--
}
}
d := &Definition{
initialState: "Root",
rules: compiled,
symbols: symbols,
}
for _, option := range options {
option(d)
}
return d, nil
}
// Rules returns the user-provided Rules used to construct the lexer.
func (d *Definition) Rules() Rules {
out := Rules{}
for state, rules := range d.rules {
for _, rule := range rules {
out[state] = append(out[state], rule.Rule)
}
}
return out
}
func (d *Definition) LexString(filename string, s string) (lexer.Lexer, error) { // nolint: golint
return &Lexer{
def: d,
data: s,
stack: []lexerState{{name: d.initialState}},
pos: lexer.Position{
Filename: filename,
Line: 1,
Column: 1,
},
}, nil
}
func (d *Definition) Lex(filename string, r io.Reader) (lexer.Lexer, error) { // nolint: golint
w := &strings.Builder{}
_, err := io.Copy(w, r)
if err != nil {
return nil, err
}
return d.LexString(filename, w.String())
}
func (d *Definition) Symbols() map[string]rune { // nolint: golint
return d.symbols
}
type lexerState struct {
name string
groups []string
}
// Lexer implementation.
type Lexer struct {
stack []lexerState
def *Definition
data string
pos lexer.Position
}
func (l *Lexer) Next() (lexer.Token, error) { // nolint: golint
parent := l.stack[len(l.stack)-1]
rules := l.def.rules[parent.name]
next:
for len(l.data) > 0 {
var (
rule *compiledRule
match []int
)
for _, candidate := range rules {
// Special case "Return()".
if candidate.Rule == ReturnRule {
l.stack = l.stack[:len(l.stack)-1]
parent = l.stack[len(l.stack)-1]
rules = l.def.rules[parent.name]
continue next
}
re, err := l.getPattern(candidate)
if err != nil {
return lexer.Token{}, participle.Wrapf(l.pos, err, "rule %q", candidate.Name)
}
match = re.FindStringSubmatchIndex(l.data)
if match != nil {
rule = &candidate // nolint
break
}
}
if match == nil || rule == nil {
sample := []rune(l.data)
if len(sample) > 16 {
sample = append(sample[:16], []rune("...")...)
}
return lexer.Token{}, participle.Errorf(l.pos, "invalid input text %q", string(sample))
| type ActionPop struct{} | random_line_split |
stateful.go | "
"github.com/alecthomas/participle/v2"
"github.com/alecthomas/participle/v2/lexer"
)
var (
backrefReplace = regexp.MustCompile(`(\\+)(\d)`)
)
// Option for modifying how the Lexer works.
type Option func(d *Definition)
// InitialState overrides the default initial state of "Root".
func InitialState(state string) Option {
return func(d *Definition) {
d.initialState = state
}
}
// A Rule matching input and possibly changing state.
type Rule struct {
Name string
Pattern string
Action Action
}
// Rules grouped by name.
type Rules map[string][]Rule
// compiledRule is a Rule with its pattern compiled.
type compiledRule struct {
Rule
ignore bool
RE *regexp.Regexp
}
// compiledRules grouped by name.
type compiledRules map[string][]compiledRule
// A Action is applied when a rule matches.
type Action interface {
// Actions are responsible for validating the match. ie. if they consumed any input.
applyAction(lexer *Lexer, groups []string) error
}
// RulesAction is an optional interface that Actions can implement.
//
// It is applied during rule construction to mutate the rule map.
type RulesAction interface {
applyRules(state string, rule int, rules compiledRules) error
}
// ActionPop pops to the previous state when the Rule matches.
type ActionPop struct{}
func (p ActionPop) applyAction(lexer *Lexer, groups []string) error {
if groups[0] == "" {
return errors.New("did not consume any input")
}
lexer.stack = lexer.stack[:len(lexer.stack)-1]
return nil
}
// Pop to the previous state.
func Pop() Action {
return ActionPop{}
}
// ReturnRule signals the lexer to return immediately.
var ReturnRule = Rule{"returnToParent", "", nil}
// Return to the parent state.
//
// Useful as the last rule in a sub-state.
func Return() Rule { return ReturnRule }
// ActionPush pushes the current state and switches to "State" when the Rule matches.
type ActionPush struct{ State string }
func (p ActionPush) applyAction(lexer *Lexer, groups []string) error {
if groups[0] == "" {
return errors.New("did not consume any input")
}
lexer.stack = append(lexer.stack, lexerState{name: p.State, groups: groups})
return nil
}
// Push to the given state.
//
// The target state will then be the set of rules used for matching
// until another Push or Pop is encountered.
func Push(state string) Action {
return ActionPush{state}
}
type include struct{ state string }
func (i include) applyAction(lexer *Lexer, groups []string) error { panic("should not be called") }
func (i include) applyRules(state string, rule int, rules compiledRules) error {
includedRules, ok := rules[i.state]
if !ok {
return fmt.Errorf("invalid include state %q", i.state)
}
clone := make([]compiledRule, len(includedRules))
copy(clone, includedRules)
rules[state] = append(rules[state][:rule], append(clone, rules[state][rule+1:]...)...) // nolint: makezero
return nil
}
// Include rules from another state in this one.
func Include(state string) Rule {
return Rule{Action: include{state}}
}
// Definition is the lexer.Definition.
type Definition struct {
rules compiledRules
symbols map[string]rune
// Map of key->*regexp.Regexp
backrefCache sync.Map
initialState string
}
// MustSimple creates a new lexer definition based on a single state described by `rules`.
// panics if the rules trigger an error
func MustSimple(rules []Rule, options ...Option) *Definition {
def, err := NewSimple(rules, options...)
if err != nil {
panic(err)
}
return def
}
// Must creates a new stateful lexer and panics if it is incorrect.
func Must(rules Rules, options ...Option) *Definition {
def, err := New(rules, options...)
if err != nil {
panic(err)
}
return def
}
// NewSimple creates a new stateful lexer with a single "Root" state.
func NewSimple(rules []Rule, options ...Option) (*Definition, error) {
return New(Rules{"Root": rules}, options...)
}
// New constructs a new stateful lexer from rules.
func New(rules Rules, options ...Option) (*Definition, error) {
compiled := compiledRules{}
for key, set := range rules {
for i, rule := range set {
pattern := "^(?:" + rule.Pattern + ")"
var (
re *regexp.Regexp
err error
)
var match = backrefReplace.FindStringSubmatch(rule.Pattern)
if match == nil || len(match[1])%2 == 0 {
re, err = regexp.Compile(pattern)
if err != nil {
return nil, fmt.Errorf("%s.%d: %s", key, i, err)
}
}
compiled[key] = append(compiled[key], compiledRule{
Rule: rule,
ignore: len(rule.Name) > 0 && unicode.IsLower(rune(rule.Name[0])),
RE: re,
})
}
}
restart:
for state, rules := range compiled {
for i, rule := range rules {
if action, ok := rule.Action.(RulesAction); ok {
if err := action.applyRules(state, i, compiled); err != nil {
return nil, fmt.Errorf("%s.%d: %s", state, i, err)
}
goto restart
}
}
}
keys := make([]string, 0, len(compiled))
for key := range compiled {
keys = append(keys, key)
}
symbols := map[string]rune{
"EOF": lexer.EOF,
}
sort.Strings(keys)
duplicates := map[string]compiledRule{}
rn := lexer.EOF - 1
for _, key := range keys {
for i, rule := range compiled[key] {
if dup, ok := duplicates[rule.Name]; ok && rule.Pattern != dup.Pattern {
panic(fmt.Sprintf("duplicate key %q with different patterns %q != %q", rule.Name, rule.Pattern, dup.Pattern))
}
duplicates[rule.Name] = rule
compiled[key][i] = rule
symbols[rule.Name] = rn
rn--
}
}
d := &Definition{
initialState: "Root",
rules: compiled,
symbols: symbols,
}
for _, option := range options {
option(d)
}
return d, nil
}
// Rules returns the user-provided Rules used to construct the lexer.
func (d *Definition) Rules() Rules {
out := Rules{}
for state, rules := range d.rules {
for _, rule := range rules {
out[state] = append(out[state], rule.Rule)
}
}
return out
}
func (d *Definition) LexString(filename string, s string) (lexer.Lexer, error) { // nolint: golint
return &Lexer{
def: d,
data: s,
stack: []lexerState{{name: d.initialState}},
pos: lexer.Position{
Filename: filename,
Line: 1,
Column: 1,
},
}, nil
}
func (d *Definition) Lex(filename string, r io.Reader) (lexer.Lexer, error) { // nolint: golint
w := &strings.Builder{}
_, err := io.Copy(w, r)
if err != nil {
return nil, err
}
return d.LexString(filename, w.String())
}
func (d *Definition) | () map[string]rune { // nolint: golint
return d.symbols
}
type lexerState struct {
name string
groups []string
}
// Lexer implementation.
type Lexer struct {
stack []lexerState
def *Definition
data string
pos lexer.Position
}
func (l *Lexer) Next() (lexer.Token, error) { // nolint: golint
parent := l.stack[len(l.stack)-1]
rules := l.def.rules[parent.name]
next:
for len(l.data) > 0 {
var (
rule *compiledRule
match []int
)
for _, candidate := range rules {
// Special case "Return()".
if candidate.Rule == ReturnRule {
l.stack = l.stack[:len(l.stack)-1]
parent = l.stack[len(l.stack)-1]
rules = l.def.rules[parent.name]
continue next
}
re, err := l.getPattern(candidate)
if err != nil {
return lexer.Token{}, participle.Wrapf(l.pos, err, "rule %q", candidate.Name)
}
match = re.FindStringSubmatchIndex(l.data)
if match != nil {
rule = &candidate // nolint
break
}
}
if match == nil || rule == nil {
sample := []rune(l.data)
if len(sample) > 16 {
sample = append(sample[:16], []rune("...")...)
}
return lexer.Token{}, participle.Errorf(l.pos, "invalid input text %q", string(sample))
| Symbols | identifier_name |
stateful.go | "
"github.com/alecthomas/participle/v2"
"github.com/alecthomas/participle/v2/lexer"
)
var (
backrefReplace = regexp.MustCompile(`(\\+)(\d)`)
)
// Option for modifying how the Lexer works.
type Option func(d *Definition)
// InitialState overrides the default initial state of "Root".
func InitialState(state string) Option {
return func(d *Definition) {
d.initialState = state
}
}
// A Rule matching input and possibly changing state.
type Rule struct {
Name string
Pattern string
Action Action
}
// Rules grouped by name.
type Rules map[string][]Rule
// compiledRule is a Rule with its pattern compiled.
type compiledRule struct {
Rule
ignore bool
RE *regexp.Regexp
}
// compiledRules grouped by name.
type compiledRules map[string][]compiledRule
// A Action is applied when a rule matches.
type Action interface {
// Actions are responsible for validating the match. ie. if they consumed any input.
applyAction(lexer *Lexer, groups []string) error
}
// RulesAction is an optional interface that Actions can implement.
//
// It is applied during rule construction to mutate the rule map.
type RulesAction interface {
applyRules(state string, rule int, rules compiledRules) error
}
// ActionPop pops to the previous state when the Rule matches.
type ActionPop struct{}
func (p ActionPop) applyAction(lexer *Lexer, groups []string) error {
if groups[0] == "" {
return errors.New("did not consume any input")
}
lexer.stack = lexer.stack[:len(lexer.stack)-1]
return nil
}
// Pop to the previous state.
func Pop() Action {
return ActionPop{}
}
// ReturnRule signals the lexer to return immediately.
var ReturnRule = Rule{"returnToParent", "", nil}
// Return to the parent state.
//
// Useful as the last rule in a sub-state.
func Return() Rule { return ReturnRule }
// ActionPush pushes the current state and switches to "State" when the Rule matches.
type ActionPush struct{ State string }
func (p ActionPush) applyAction(lexer *Lexer, groups []string) error {
if groups[0] == "" |
lexer.stack = append(lexer.stack, lexerState{name: p.State, groups: groups})
return nil
}
// Push to the given state.
//
// The target state will then be the set of rules used for matching
// until another Push or Pop is encountered.
func Push(state string) Action {
return ActionPush{state}
}
type include struct{ state string }
func (i include) applyAction(lexer *Lexer, groups []string) error { panic("should not be called") }
func (i include) applyRules(state string, rule int, rules compiledRules) error {
includedRules, ok := rules[i.state]
if !ok {
return fmt.Errorf("invalid include state %q", i.state)
}
clone := make([]compiledRule, len(includedRules))
copy(clone, includedRules)
rules[state] = append(rules[state][:rule], append(clone, rules[state][rule+1:]...)...) // nolint: makezero
return nil
}
// Include rules from another state in this one.
func Include(state string) Rule {
return Rule{Action: include{state}}
}
// Definition is the lexer.Definition.
type Definition struct {
rules compiledRules
symbols map[string]rune
// Map of key->*regexp.Regexp
backrefCache sync.Map
initialState string
}
// MustSimple creates a new lexer definition based on a single state described by `rules`.
// panics if the rules trigger an error
func MustSimple(rules []Rule, options ...Option) *Definition {
def, err := NewSimple(rules, options...)
if err != nil {
panic(err)
}
return def
}
// Must creates a new stateful lexer and panics if it is incorrect.
func Must(rules Rules, options ...Option) *Definition {
def, err := New(rules, options...)
if err != nil {
panic(err)
}
return def
}
// NewSimple creates a new stateful lexer with a single "Root" state.
func NewSimple(rules []Rule, options ...Option) (*Definition, error) {
return New(Rules{"Root": rules}, options...)
}
// New constructs a new stateful lexer from rules.
func New(rules Rules, options ...Option) (*Definition, error) {
compiled := compiledRules{}
for key, set := range rules {
for i, rule := range set {
pattern := "^(?:" + rule.Pattern + ")"
var (
re *regexp.Regexp
err error
)
var match = backrefReplace.FindStringSubmatch(rule.Pattern)
if match == nil || len(match[1])%2 == 0 {
re, err = regexp.Compile(pattern)
if err != nil {
return nil, fmt.Errorf("%s.%d: %s", key, i, err)
}
}
compiled[key] = append(compiled[key], compiledRule{
Rule: rule,
ignore: len(rule.Name) > 0 && unicode.IsLower(rune(rule.Name[0])),
RE: re,
})
}
}
restart:
for state, rules := range compiled {
for i, rule := range rules {
if action, ok := rule.Action.(RulesAction); ok {
if err := action.applyRules(state, i, compiled); err != nil {
return nil, fmt.Errorf("%s.%d: %s", state, i, err)
}
goto restart
}
}
}
keys := make([]string, 0, len(compiled))
for key := range compiled {
keys = append(keys, key)
}
symbols := map[string]rune{
"EOF": lexer.EOF,
}
sort.Strings(keys)
duplicates := map[string]compiledRule{}
rn := lexer.EOF - 1
for _, key := range keys {
for i, rule := range compiled[key] {
if dup, ok := duplicates[rule.Name]; ok && rule.Pattern != dup.Pattern {
panic(fmt.Sprintf("duplicate key %q with different patterns %q != %q", rule.Name, rule.Pattern, dup.Pattern))
}
duplicates[rule.Name] = rule
compiled[key][i] = rule
symbols[rule.Name] = rn
rn--
}
}
d := &Definition{
initialState: "Root",
rules: compiled,
symbols: symbols,
}
for _, option := range options {
option(d)
}
return d, nil
}
// Rules returns the user-provided Rules used to construct the lexer.
func (d *Definition) Rules() Rules {
out := Rules{}
for state, rules := range d.rules {
for _, rule := range rules {
out[state] = append(out[state], rule.Rule)
}
}
return out
}
func (d *Definition) LexString(filename string, s string) (lexer.Lexer, error) { // nolint: golint
return &Lexer{
def: d,
data: s,
stack: []lexerState{{name: d.initialState}},
pos: lexer.Position{
Filename: filename,
Line: 1,
Column: 1,
},
}, nil
}
func (d *Definition) Lex(filename string, r io.Reader) (lexer.Lexer, error) { // nolint: golint
w := &strings.Builder{}
_, err := io.Copy(w, r)
if err != nil {
return nil, err
}
return d.LexString(filename, w.String())
}
func (d *Definition) Symbols() map[string]rune { // nolint: golint
return d.symbols
}
type lexerState struct {
name string
groups []string
}
// Lexer implementation.
type Lexer struct {
stack []lexerState
def *Definition
data string
pos lexer.Position
}
func (l *Lexer) Next() (lexer.Token, error) { // nolint: golint
parent := l.stack[len(l.stack)-1]
rules := l.def.rules[parent.name]
next:
for len(l.data) > 0 {
var (
rule *compiledRule
match []int
)
for _, candidate := range rules {
// Special case "Return()".
if candidate.Rule == ReturnRule {
l.stack = l.stack[:len(l.stack)-1]
parent = l.stack[len(l.stack)-1]
rules = l.def.rules[parent.name]
continue next
}
re, err := l.getPattern(candidate)
if err != nil {
return lexer.Token{}, participle.Wrapf(l.pos, err, "rule %q", candidate.Name)
}
match = re.FindStringSubmatchIndex(l.data)
if match != nil {
rule = &candidate // nolint
break
}
}
if match == nil || rule == nil {
sample := []rune(l.data)
if len(sample) > 16 {
sample = append(sample[:16], []rune("...")...)
}
return lexer.Token{}, participle.Errorf(l.pos, "invalid input text %q", string(sample | {
return errors.New("did not consume any input")
} | conditional_block |
gaiatools.py | rometric_n_good_obs_al,astrometric_n_bad_obs_al,"+\
"astrometric_gof_al,astrometric_chi2_al,astrometric_excess_noise,astrometric_excess_noise_sig,"+\
"astrometric_params_solved,astrometric_primary_flag,astrometric_weight_al,"+\
"astrometric_pseudo_colour,astrometric_pseudo_colour_error,"+\
"mean_varpi_factor_al,astrometric_matched_observations,visibility_periods_used,"+\
"astrometric_sigma5d_max,frame_rotator_object_type,matched_observations"
cols_phot = "phot_g_mean_mag,phot_bp_mean_mag,phot_rp_mean_mag,phot_variable_flag"
ecol_phot = "phot_g_mean_flux,phot_bp_mean_flux,phot_rp_mean_flux,"+\
"phot_g_mean_flux_error,phot_g_mean_flux_over_error,"+\
"phot_bp_mean_flux_error,phot_bp_mean_flux_over_error,"+\
"phot_rp_mean_flux_error,phot_rp_mean_flux_over_error"
qual_phot = "phot_g_n_obs,phot_bp_n_obs,phot_rp_n_obs,phot_bp_rp_excess_factor,phot_proc_mode"
cols_redd = "bp_rp,bp_g,g_rp,a_g_val,e_bp_min_rp_val,"+\
"a_g_percentile_lower,a_g_percentile_upper,"+\
"e_bp_min_rp_percentile_lower,e_bp_min_rp_percentile_upper"
cols_spec = "radial_velocity,radial_velocity_error"
qual_spec = "rv_template_teff,rv_template_logg,rv_template_fe_h,rv_nb_transits"
cols_star = "teff_val,radius_val,lum_val"
ecol_star = "teff_percentile_lower,teff_percentile_upper,"+\
"radius_percentile_lower,radius_percentile_upper,"+\
"lum_percentile_lower,lum_percentile_upper"
cols_rave = ""
ecol_rave = ""
all_columns = ",".join(["source_id", cols_astrometry, ecol_astrometry, qual_astrometry,
cols_phot, ecol_phot, qual_phot, cols_redd, cols_spec, qual_spec, cols_star, ecol_star])
## This is a full set of things that I think will be useful
full_columns = ",".join(["source_id", cols_astrometry, ecol_astrometry,
cols_phot, ecol_phot, cols_redd, cols_spec, qual_spec, cols_star, ecol_star])
## This is a minimal set of things that I think will be useful
default_columns = ",".join(["source_id",cols_astrometry,ecol_astrometry,
cols_phot, cols_spec, cols_star])
def create_source_query_from_ids(ids, columns=default_columns,
source="gaiaedr3.gaia_source"):
out = "SELECT {} FROM {} WHERE ".format(
columns, source)
idstrs = " or ".join(["source_id = {}".format(x) for x in ids])
out += idstrs
return out
def create_source_query_from(coords, radius=1*u.arcsec,
columns=default_columns,
source="gaiaedr3.gaia_source",
Nmax=None):
"""
Generate a string selecting specific list of coordinates.
Built from https://gist.github.com/mfouesneau/b6b25ed645eab9da4710153fcf9a4cb8
"""
N = len(coords)
if Nmax is None: Nmax = 2*N
out = "SELECT TOP {} {} FROM {} WHERE ".format(
Nmax, columns, source)
def _make_contains_str(c):
cstr = "CONTAINS(POINT('ICRS',{0:}.ra,{0:}.dec),CIRCLE('ICRS',{1:},{2:},{3:}))=1".format(
source, c.ra.deg, c.dec.deg, radius.to("deg").value)
return cstr
cstrs = map(_make_contains_str, coords)
out += " or ".join(cstrs)
return out
def create_samples(Nsamp,mu,cov):
Nstars,Nparams = mu.shape
assert Nstars == len(cov)
assert Nparams == cov.shape[1]
output = np.zeros((Nsamp*Nstars, Nparams))
for i in range(Nstars):
i1 = Nsamp*i
i2 = Nsamp*(i+1)
output[i1:i2,:] = np.random.multivariate_normal(mu[i,:],cov[i,:,:],Nsamp)
output = output.reshape(Nstars, Nsamp, Nparams)
return output
def get_gc_frame():
v_sun = coord.CartesianDifferential([11.1, 250, 7.25]*u.km/u.s)
#gc_frame = coord.Galactocentric(galcen_distance=8.3*u.kpc,
# z_sun=0*u.pc,
# galcen_v_sun=v_sun)
gc_frame = coord.Galactocentric()
return gc_frame
def get_gccoo_w0(coo):
gc_frame = get_gc_frame()
gccoo = coo.transform_to(gc_frame)
w0 = gd.PhaseSpacePosition(gccoo.data)
return gccoo, w0
def get_orbit_params(orbits):
N = orbits.shape[1]
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
rp, ra = orbit.pericenter(), orbit.apocenter()
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def get_orbit_params_fast(orbits):
try:
N = orbits.shape[1]
except IndexError:
orbit = orbits
r = np.sqrt(np.sum(orbits.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
return u.Quantity(rp), u.Quantity(ra), u.Quantity((ra-rp)/(ra+rp))
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
r = np.sqrt(np.sum(orbit.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def calc_vtan_error(pmra, pmdec, parallax):
d = u.kpc / parallax.value
pmra = pmra.to(u.rad/u.yr, u.dimensionless_angles())
pmdec= pmdec.to(u.rad/u.yr, u.dimensionless_angles())
vtan = d * np.sqrt(pmra**2 + pmdec**2)
vtan = vtan.to(u.km/u.s, u.dimensionless_angles())
return vtan
def avgstd(x,ignore_nan=False, axis=None):
mean = np.nanmean if ignore_nan else np.mean
stdev = np.nanstd if ignore_nan else np.std
kws = {}
if axis is not None: kws['axis'] = axis
mu = mean(x,**kws)
sig = stdev(x,**kws)
return np.vstack([mu,sig]).T
def medscat(x,sigma=2,ignore_nan=False, axis=None, for_errorbar_plot=False):
percentile = np.nanpercentile if ignore_nan else np.percentile
pdict = {1:[16,50,84],2:[5,50,95],3:[.1,50,99.9]}
assert sigma in pdict
kws = {}
if axis is not None: kws['axis'] = axis
p1,p2,p3 = percentile(x, pdict[sigma], **kws)
e1 = p1-p2
e2 = p3-p2
if for_errorbar_plot:
e1 = -e1
return p2, np.stack([e1,e2])
return np.stack([e1,p2,e2])
def modefinder(x, bins="auto", dropna=True):
"""
Estimates the mode of a sample of points.
Assumes a unimodal system.
Take a histogram of the data and return the bin with the largest value.
TODO If an initial value is specified, find the local maximum closest to that value.
"""
if dropna: |
h,x = np.histogram(x, bins=bins)
xm = (x[1:]+x[:-1])/2.
ix = np.argmax(h)
return xm[ix]
def get_finite(x,y):
""" Get x and y that are both finite """
finite = np.logical_and(np.isfinite(x), np.isfinite(y))
xf = x[finite]; yf = y[finite]
return xf, yf
def fit_spline(x, y, **kwargs):
""" A simple wrapper to scipy.interpolate.UnivariateSpline (remove nan, sort x) """
xf, yf = get_finite(x,y)
| x = x[np.isfinite(x)] | conditional_block |
gaiatools.py | rometric_n_good_obs_al,astrometric_n_bad_obs_al,"+\
"astrometric_gof_al,astrometric_chi2_al,astrometric_excess_noise,astrometric_excess_noise_sig,"+\
"astrometric_params_solved,astrometric_primary_flag,astrometric_weight_al,"+\
"astrometric_pseudo_colour,astrometric_pseudo_colour_error,"+\
"mean_varpi_factor_al,astrometric_matched_observations,visibility_periods_used,"+\
"astrometric_sigma5d_max,frame_rotator_object_type,matched_observations"
cols_phot = "phot_g_mean_mag,phot_bp_mean_mag,phot_rp_mean_mag,phot_variable_flag"
ecol_phot = "phot_g_mean_flux,phot_bp_mean_flux,phot_rp_mean_flux,"+\
"phot_g_mean_flux_error,phot_g_mean_flux_over_error,"+\
"phot_bp_mean_flux_error,phot_bp_mean_flux_over_error,"+\
"phot_rp_mean_flux_error,phot_rp_mean_flux_over_error"
qual_phot = "phot_g_n_obs,phot_bp_n_obs,phot_rp_n_obs,phot_bp_rp_excess_factor,phot_proc_mode"
cols_redd = "bp_rp,bp_g,g_rp,a_g_val,e_bp_min_rp_val,"+\
"a_g_percentile_lower,a_g_percentile_upper,"+\
"e_bp_min_rp_percentile_lower,e_bp_min_rp_percentile_upper"
cols_spec = "radial_velocity,radial_velocity_error"
qual_spec = "rv_template_teff,rv_template_logg,rv_template_fe_h,rv_nb_transits"
cols_star = "teff_val,radius_val,lum_val"
ecol_star = "teff_percentile_lower,teff_percentile_upper,"+\
"radius_percentile_lower,radius_percentile_upper,"+\
"lum_percentile_lower,lum_percentile_upper"
cols_rave = ""
ecol_rave = ""
all_columns = ",".join(["source_id", cols_astrometry, ecol_astrometry, qual_astrometry,
cols_phot, ecol_phot, qual_phot, cols_redd, cols_spec, qual_spec, cols_star, ecol_star])
## This is a full set of things that I think will be useful
full_columns = ",".join(["source_id", cols_astrometry, ecol_astrometry,
cols_phot, ecol_phot, cols_redd, cols_spec, qual_spec, cols_star, ecol_star])
## This is a minimal set of things that I think will be useful
default_columns = ",".join(["source_id",cols_astrometry,ecol_astrometry,
cols_phot, cols_spec, cols_star])
def create_source_query_from_ids(ids, columns=default_columns,
source="gaiaedr3.gaia_source"):
out = "SELECT {} FROM {} WHERE ".format(
columns, source)
idstrs = " or ".join(["source_id = {}".format(x) for x in ids])
out += idstrs
return out
def create_source_query_from(coords, radius=1*u.arcsec,
columns=default_columns,
source="gaiaedr3.gaia_source",
Nmax=None):
"""
Generate a string selecting specific list of coordinates.
Built from https://gist.github.com/mfouesneau/b6b25ed645eab9da4710153fcf9a4cb8
"""
N = len(coords)
if Nmax is None: Nmax = 2*N
out = "SELECT TOP {} {} FROM {} WHERE ".format(
Nmax, columns, source)
def | (c):
cstr = "CONTAINS(POINT('ICRS',{0:}.ra,{0:}.dec),CIRCLE('ICRS',{1:},{2:},{3:}))=1".format(
source, c.ra.deg, c.dec.deg, radius.to("deg").value)
return cstr
cstrs = map(_make_contains_str, coords)
out += " or ".join(cstrs)
return out
def create_samples(Nsamp,mu,cov):
Nstars,Nparams = mu.shape
assert Nstars == len(cov)
assert Nparams == cov.shape[1]
output = np.zeros((Nsamp*Nstars, Nparams))
for i in range(Nstars):
i1 = Nsamp*i
i2 = Nsamp*(i+1)
output[i1:i2,:] = np.random.multivariate_normal(mu[i,:],cov[i,:,:],Nsamp)
output = output.reshape(Nstars, Nsamp, Nparams)
return output
def get_gc_frame():
v_sun = coord.CartesianDifferential([11.1, 250, 7.25]*u.km/u.s)
#gc_frame = coord.Galactocentric(galcen_distance=8.3*u.kpc,
# z_sun=0*u.pc,
# galcen_v_sun=v_sun)
gc_frame = coord.Galactocentric()
return gc_frame
def get_gccoo_w0(coo):
gc_frame = get_gc_frame()
gccoo = coo.transform_to(gc_frame)
w0 = gd.PhaseSpacePosition(gccoo.data)
return gccoo, w0
def get_orbit_params(orbits):
N = orbits.shape[1]
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
rp, ra = orbit.pericenter(), orbit.apocenter()
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def get_orbit_params_fast(orbits):
try:
N = orbits.shape[1]
except IndexError:
orbit = orbits
r = np.sqrt(np.sum(orbits.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
return u.Quantity(rp), u.Quantity(ra), u.Quantity((ra-rp)/(ra+rp))
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
r = np.sqrt(np.sum(orbit.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def calc_vtan_error(pmra, pmdec, parallax):
d = u.kpc / parallax.value
pmra = pmra.to(u.rad/u.yr, u.dimensionless_angles())
pmdec= pmdec.to(u.rad/u.yr, u.dimensionless_angles())
vtan = d * np.sqrt(pmra**2 + pmdec**2)
vtan = vtan.to(u.km/u.s, u.dimensionless_angles())
return vtan
def avgstd(x,ignore_nan=False, axis=None):
mean = np.nanmean if ignore_nan else np.mean
stdev = np.nanstd if ignore_nan else np.std
kws = {}
if axis is not None: kws['axis'] = axis
mu = mean(x,**kws)
sig = stdev(x,**kws)
return np.vstack([mu,sig]).T
def medscat(x,sigma=2,ignore_nan=False, axis=None, for_errorbar_plot=False):
percentile = np.nanpercentile if ignore_nan else np.percentile
pdict = {1:[16,50,84],2:[5,50,95],3:[.1,50,99.9]}
assert sigma in pdict
kws = {}
if axis is not None: kws['axis'] = axis
p1,p2,p3 = percentile(x, pdict[sigma], **kws)
e1 = p1-p2
e2 = p3-p2
if for_errorbar_plot:
e1 = -e1
return p2, np.stack([e1,e2])
return np.stack([e1,p2,e2])
def modefinder(x, bins="auto", dropna=True):
"""
Estimates the mode of a sample of points.
Assumes a unimodal system.
Take a histogram of the data and return the bin with the largest value.
TODO If an initial value is specified, find the local maximum closest to that value.
"""
if dropna: x = x[np.isfinite(x)]
h,x = np.histogram(x, bins=bins)
xm = (x[1:]+x[:-1])/2.
ix = np.argmax(h)
return xm[ix]
def get_finite(x,y):
""" Get x and y that are both finite """
finite = np.logical_and(np.isfinite(x), np.isfinite(y))
xf = x[finite]; yf = y[finite]
return xf, yf
def fit_spline(x, y, **kwargs):
""" A simple wrapper to scipy.interpolate.UnivariateSpline (remove nan, sort x) """
xf, yf = get_finite(x,y)
| _make_contains_str | identifier_name |
gaiatools.py | rometric_n_good_obs_al,astrometric_n_bad_obs_al,"+\
"astrometric_gof_al,astrometric_chi2_al,astrometric_excess_noise,astrometric_excess_noise_sig,"+\
"astrometric_params_solved,astrometric_primary_flag,astrometric_weight_al,"+\
"astrometric_pseudo_colour,astrometric_pseudo_colour_error,"+\
"mean_varpi_factor_al,astrometric_matched_observations,visibility_periods_used,"+\
"astrometric_sigma5d_max,frame_rotator_object_type,matched_observations"
cols_phot = "phot_g_mean_mag,phot_bp_mean_mag,phot_rp_mean_mag,phot_variable_flag"
ecol_phot = "phot_g_mean_flux,phot_bp_mean_flux,phot_rp_mean_flux,"+\
"phot_g_mean_flux_error,phot_g_mean_flux_over_error,"+\
"phot_bp_mean_flux_error,phot_bp_mean_flux_over_error,"+\
"phot_rp_mean_flux_error,phot_rp_mean_flux_over_error"
qual_phot = "phot_g_n_obs,phot_bp_n_obs,phot_rp_n_obs,phot_bp_rp_excess_factor,phot_proc_mode"
cols_redd = "bp_rp,bp_g,g_rp,a_g_val,e_bp_min_rp_val,"+\
"a_g_percentile_lower,a_g_percentile_upper,"+\
"e_bp_min_rp_percentile_lower,e_bp_min_rp_percentile_upper"
cols_spec = "radial_velocity,radial_velocity_error"
qual_spec = "rv_template_teff,rv_template_logg,rv_template_fe_h,rv_nb_transits"
cols_star = "teff_val,radius_val,lum_val"
ecol_star = "teff_percentile_lower,teff_percentile_upper,"+\
"radius_percentile_lower,radius_percentile_upper,"+\
"lum_percentile_lower,lum_percentile_upper"
cols_rave = ""
ecol_rave = ""
all_columns = ",".join(["source_id", cols_astrometry, ecol_astrometry, qual_astrometry,
cols_phot, ecol_phot, qual_phot, cols_redd, cols_spec, qual_spec, cols_star, ecol_star])
## This is a full set of things that I think will be useful
full_columns = ",".join(["source_id", cols_astrometry, ecol_astrometry,
cols_phot, ecol_phot, cols_redd, cols_spec, qual_spec, cols_star, ecol_star])
## This is a minimal set of things that I think will be useful
default_columns = ",".join(["source_id",cols_astrometry,ecol_astrometry,
cols_phot, cols_spec, cols_star])
def create_source_query_from_ids(ids, columns=default_columns,
source="gaiaedr3.gaia_source"):
out = "SELECT {} FROM {} WHERE ".format(
columns, source)
idstrs = " or ".join(["source_id = {}".format(x) for x in ids])
out += idstrs
return out
def create_source_query_from(coords, radius=1*u.arcsec,
columns=default_columns,
source="gaiaedr3.gaia_source",
Nmax=None):
"""
Generate a string selecting specific list of coordinates.
Built from https://gist.github.com/mfouesneau/b6b25ed645eab9da4710153fcf9a4cb8
"""
N = len(coords)
if Nmax is None: Nmax = 2*N
out = "SELECT TOP {} {} FROM {} WHERE ".format(
Nmax, columns, source)
def _make_contains_str(c):
cstr = "CONTAINS(POINT('ICRS',{0:}.ra,{0:}.dec),CIRCLE('ICRS',{1:},{2:},{3:}))=1".format(
source, c.ra.deg, c.dec.deg, radius.to("deg").value)
return cstr
cstrs = map(_make_contains_str, coords)
out += " or ".join(cstrs)
return out
def create_samples(Nsamp,mu,cov):
Nstars,Nparams = mu.shape
assert Nstars == len(cov)
assert Nparams == cov.shape[1]
output = np.zeros((Nsamp*Nstars, Nparams))
for i in range(Nstars):
i1 = Nsamp*i
i2 = Nsamp*(i+1)
output[i1:i2,:] = np.random.multivariate_normal(mu[i,:],cov[i,:,:],Nsamp)
output = output.reshape(Nstars, Nsamp, Nparams)
return output
def get_gc_frame():
v_sun = coord.CartesianDifferential([11.1, 250, 7.25]*u.km/u.s)
#gc_frame = coord.Galactocentric(galcen_distance=8.3*u.kpc,
# z_sun=0*u.pc,
# galcen_v_sun=v_sun)
gc_frame = coord.Galactocentric()
return gc_frame
def get_gccoo_w0(coo):
gc_frame = get_gc_frame()
gccoo = coo.transform_to(gc_frame)
w0 = gd.PhaseSpacePosition(gccoo.data)
return gccoo, w0
def get_orbit_params(orbits):
N = orbits.shape[1]
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
rp, ra = orbit.pericenter(), orbit.apocenter()
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def get_orbit_params_fast(orbits):
try:
N = orbits.shape[1]
except IndexError:
orbit = orbits
r = np.sqrt(np.sum(orbits.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
return u.Quantity(rp), u.Quantity(ra), u.Quantity((ra-rp)/(ra+rp))
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
r = np.sqrt(np.sum(orbit.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def calc_vtan_error(pmra, pmdec, parallax):
d = u.kpc / parallax.value
pmra = pmra.to(u.rad/u.yr, u.dimensionless_angles())
pmdec= pmdec.to(u.rad/u.yr, u.dimensionless_angles())
vtan = d * np.sqrt(pmra**2 + pmdec**2)
vtan = vtan.to(u.km/u.s, u.dimensionless_angles())
return vtan
| stdev = np.nanstd if ignore_nan else np.std
kws = {}
if axis is not None: kws['axis'] = axis
mu = mean(x,**kws)
sig = stdev(x,**kws)
return np.vstack([mu,sig]).T
def medscat(x,sigma=2,ignore_nan=False, axis=None, for_errorbar_plot=False):
percentile = np.nanpercentile if ignore_nan else np.percentile
pdict = {1:[16,50,84],2:[5,50,95],3:[.1,50,99.9]}
assert sigma in pdict
kws = {}
if axis is not None: kws['axis'] = axis
p1,p2,p3 = percentile(x, pdict[sigma], **kws)
e1 = p1-p2
e2 = p3-p2
if for_errorbar_plot:
e1 = -e1
return p2, np.stack([e1,e2])
return np.stack([e1,p2,e2])
def modefinder(x, bins="auto", dropna=True):
"""
Estimates the mode of a sample of points.
Assumes a unimodal system.
Take a histogram of the data and return the bin with the largest value.
TODO If an initial value is specified, find the local maximum closest to that value.
"""
if dropna: x = x[np.isfinite(x)]
h,x = np.histogram(x, bins=bins)
xm = (x[1:]+x[:-1])/2.
ix = np.argmax(h)
return xm[ix]
def get_finite(x,y):
""" Get x and y that are both finite """
finite = np.logical_and(np.isfinite(x), np.isfinite(y))
xf = x[finite]; yf = y[finite]
return xf, yf
def fit_spline(x, y, **kwargs):
""" A simple wrapper to scipy.interpolate.UnivariateSpline (remove nan, sort x) """
xf, yf = get_finite(x,y)
| def avgstd(x,ignore_nan=False, axis=None):
mean = np.nanmean if ignore_nan else np.mean | random_line_split |
gaiatools.py | ICRS',{1:},{2:},{3:}))=1".format(
source, c.ra.deg, c.dec.deg, radius.to("deg").value)
return cstr
cstrs = map(_make_contains_str, coords)
out += " or ".join(cstrs)
return out
def create_samples(Nsamp,mu,cov):
Nstars,Nparams = mu.shape
assert Nstars == len(cov)
assert Nparams == cov.shape[1]
output = np.zeros((Nsamp*Nstars, Nparams))
for i in range(Nstars):
i1 = Nsamp*i
i2 = Nsamp*(i+1)
output[i1:i2,:] = np.random.multivariate_normal(mu[i,:],cov[i,:,:],Nsamp)
output = output.reshape(Nstars, Nsamp, Nparams)
return output
def get_gc_frame():
v_sun = coord.CartesianDifferential([11.1, 250, 7.25]*u.km/u.s)
#gc_frame = coord.Galactocentric(galcen_distance=8.3*u.kpc,
# z_sun=0*u.pc,
# galcen_v_sun=v_sun)
gc_frame = coord.Galactocentric()
return gc_frame
def get_gccoo_w0(coo):
gc_frame = get_gc_frame()
gccoo = coo.transform_to(gc_frame)
w0 = gd.PhaseSpacePosition(gccoo.data)
return gccoo, w0
def get_orbit_params(orbits):
N = orbits.shape[1]
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
rp, ra = orbit.pericenter(), orbit.apocenter()
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def get_orbit_params_fast(orbits):
try:
N = orbits.shape[1]
except IndexError:
orbit = orbits
r = np.sqrt(np.sum(orbits.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
return u.Quantity(rp), u.Quantity(ra), u.Quantity((ra-rp)/(ra+rp))
pers = []
apos = []
eccs = []
for i in range(N):
orbit = orbits[:,i]
r = np.sqrt(np.sum(orbit.xyz**2,axis=0))
rp, ra = np.min(r), np.max(r)
pers.append(rp)
apos.append(ra)
eccs.append((ra - rp) / (ra + rp))
return u.Quantity(pers), u.Quantity(apos), u.Quantity(eccs)
def calc_vtan_error(pmra, pmdec, parallax):
d = u.kpc / parallax.value
pmra = pmra.to(u.rad/u.yr, u.dimensionless_angles())
pmdec= pmdec.to(u.rad/u.yr, u.dimensionless_angles())
vtan = d * np.sqrt(pmra**2 + pmdec**2)
vtan = vtan.to(u.km/u.s, u.dimensionless_angles())
return vtan
def avgstd(x,ignore_nan=False, axis=None):
mean = np.nanmean if ignore_nan else np.mean
stdev = np.nanstd if ignore_nan else np.std
kws = {}
if axis is not None: kws['axis'] = axis
mu = mean(x,**kws)
sig = stdev(x,**kws)
return np.vstack([mu,sig]).T
def medscat(x,sigma=2,ignore_nan=False, axis=None, for_errorbar_plot=False):
percentile = np.nanpercentile if ignore_nan else np.percentile
pdict = {1:[16,50,84],2:[5,50,95],3:[.1,50,99.9]}
assert sigma in pdict
kws = {}
if axis is not None: kws['axis'] = axis
p1,p2,p3 = percentile(x, pdict[sigma], **kws)
e1 = p1-p2
e2 = p3-p2
if for_errorbar_plot:
e1 = -e1
return p2, np.stack([e1,e2])
return np.stack([e1,p2,e2])
def modefinder(x, bins="auto", dropna=True):
"""
Estimates the mode of a sample of points.
Assumes a unimodal system.
Take a histogram of the data and return the bin with the largest value.
TODO If an initial value is specified, find the local maximum closest to that value.
"""
if dropna: x = x[np.isfinite(x)]
h,x = np.histogram(x, bins=bins)
xm = (x[1:]+x[:-1])/2.
ix = np.argmax(h)
return xm[ix]
def get_finite(x,y):
""" Get x and y that are both finite """
finite = np.logical_and(np.isfinite(x), np.isfinite(y))
xf = x[finite]; yf = y[finite]
return xf, yf
def fit_spline(x, y, **kwargs):
""" A simple wrapper to scipy.interpolate.UnivariateSpline (remove nan, sort x) """
xf, yf = get_finite(x,y)
iisort = np.argsort(xf)
return interpolate.UnivariateSpline(xf[iisort],yf[iisort], **kwargs)
def bin_medscat(x, y, percentiles=[5,50,95], for_errorbar_plot=False, dropna=True, bins="auto", **kwargs):
"""
Histogram x into bins.
Then in those bins, take percentiles of y.
"""
if dropna: x, y = get_finite(x, y)
h, xe = np.histogram(x, bins=bins, **kwargs)
xout = (xe[1:]+xe[:-1])/2.
indices = np.digitize(x, xe)
yout = np.zeros((len(xe)-1,len(percentiles)))+np.nan
for ix in np.unique(indices):
# Skip things outside the bin range
if ix >= len(yout): continue
# Percentile in this bin
ii = ix==indices
yout[ix,:] = np.percentile(y[ii], percentiles)
if for_errorbar_plot:
e1 = yout[:,1] - yout[:,0]
e2 = yout[:,2] - yout[:,1]
return xout, yout[:,1], [e1,e2]
return xout, yout
def calculate_actions(w0,pot=gp.MilkyWayPotential(), dt=0.5, n_steps=10000, full_output=False):
""" Approximate actions following https://github.com/adrn/gala/blob/master/docs/dynamics/actionangle.rst """
assert len(w0.shape)==0
w = gp.Hamiltonian(pot).integrate_orbit(w0, dt=dt, n_steps=n_steps)
toy_potential = gd.fit_isochrone(w)
toy_actions, toy_angles, toy_freqs = toy_potential.action_angle(w)
with warnings.catch_warnings(record=True):
warnings.simplefilter("ignore")
result = gd.find_actions(w, N_max=8, toy_potential=toy_potential)
if full_output: return result, w
return result["actions"]
def query_and_match(coo, match_radius=1, columns=full_columns):
"""
Query gaia given coordinates
Return a table that is sorted, and an array saying which rows actually matched an object in gaia
"""
from pyia import GaiaDataNew
query = create_source_query_from(coo, columns=columns)
gaia = GaiaDataNew.from_query(query)
gcoo = SkyCoord(gaia.ra, gaia.dec)
idx, d2d, _ = coo.match_to_catalog_sky(gcoo)
iimatch = d2d.arcsec < match_radius
gtab = gaia.data[idx]
if iimatch.sum() != len(gtab):
print("Warning: only matched {}/{} stars".format(iimatch.sum(),len(gtab)))
return gtab, iimatch
def query_and_match_sourceid(source_ids, match_radius=1, columns=full_columns):
| """
Query gaia given source_ids
Return a table in the order of the source_ids
"""
from pyia import GaiaDataNew
unique_arr, indexes = np.unique(source_ids, return_inverse=True)
assert len(unique_arr) == len(source_ids), "Not all IDs are unique"
query = create_source_query_from_ids(source_ids, columns=columns)
gaia = GaiaDataNew.from_query(query)
# Sort by source id, find indices, then resort
gdat = gaia.data
gdat.sort("source_id")
assert np.all(unique_arr == gdat["source_id"])
gdat = gdat[indexes]
assert np.all(gdat["source_id"]==source_ids)
return gdat | identifier_body |
|
langviews.js | = $(this.config.platformSelector).val();
if (endDate.diff(startDate, 'days') === 0) {
startDate.subtract(3, 'days');
endDate.add(3, 'days');
}
return `/pageviews#start=${startDate.format('YYYY-MM-DD')}` +
`&end=${endDate.format('YYYY-MM-DD')}&project=${lang}.${project}.org&platform=${platform}&pages=${article}`;
}
/**
* Loop through given interwiki data and query the pageviews API for each
* Also updates this.langData with result
* @param {Object} interWikiData - as given by the getInterwikiData promise
* @return {Deferred} - Promise resolving with data ready to be rendered to view
*/
getPageViewsData(interWikiData) {
const startDate = this.daterangepicker.startDate.startOf('day'),
endDate = this.daterangepicker.endDate.startOf('day'),
interWikiKeys = Object.keys(interWikiData);
// XXX: throttling
let dfd = $.Deferred(), promises = [], count = 0, hadFailure, failureRetries = {},
totalRequestCount = interWikiKeys.length, failedPages = [];
/** clear out existing data */
this.langData = [];
const makeRequest = dbName => {
const data = interWikiData[dbName],
uriEncodedPageName = encodeURIComponent(data.title);
const url = (
`https://wikimedia.org/api/rest_v1/metrics/pageviews/per-article/${data.lang}.${this.baseProject}` +
`/${$(this.config.platformSelector).val()}/${$(this.config.agentSelector).val()}/${uriEncodedPageName}/daily` +
`/${startDate.format(this.config.timestampFormat)}/${endDate.format(this.config.timestampFormat)}`
);
const promise = $.ajax({ url, dataType: 'json' });
promises.push(promise);
promise.done(pvData => {
const viewCounts = pvData.items.map(el => el.views),
views = viewCounts.reduce((a, b) => a + b);
this.langData.push({
badges: data.badges,
dbName,
lang: data.lang,
pageName: data.title,
views,
url: data.url,
average: Math.round(views / this.numDaysInRange())
});
/** keep track of unique badges/titles and total pageviews */
this.totals.views += views;
if (!this.totals.titles.includes(data.title)) {
this.totals.titles.push(data.title);
}
data.badges.forEach(badge => {
if (this.totals.badges[badge] === undefined) {
this.totals.badges[badge] = 1;
} else {
this.totals.badges[badge] += 1;
}
});
}).fail(errorData => {
// XXX: throttling
/** first detect if this was a Cassandra backend error, and if so, schedule a re-try */
const cassandraError = errorData.responseJSON.title === 'Error in Cassandra table storage backend',
failedPageLink = this.getPageLink(data.title, `${data.lang}.${this.baseProject}.org`);
if (cassandraError) {
if (failureRetries[dbName]) {
failureRetries[dbName]++;
} else {
failureRetries[dbName] = 1;
}
/** maximum of 3 retries */
if (failureRetries[dbName] < 3) {
totalRequestCount++;
return this.rateLimit(makeRequest, 100, this)(dbName);
}
/** retries exceeded */
failedPages.push(failedPageLink);
} else {
this.writeMessage(
`${failedPageLink}: ${$.i18n('api-error', 'Pageviews API')} - ${errorData.responseJSON.title}`
);
}
hadFailure = true; // don't treat this series of requests as being cached by server
}).always(() => {
this.updateProgressBar((++count / totalRequestCount) * 100);
// XXX: throttling, totalRequestCount can just be interWikiKeys.length
if (count === totalRequestCount) {
dfd.resolve(this.langData);
if (failedPages.length) {
this.writeMessage($.i18n(
'api-error-timeout',
'<ul>' +
failedPages.map(failedPage => `<li>${failedPage}</li>`).join('') +
'</ul>'
));
}
/**
* if there were no failures, assume the resource is now cached by the server
* and save this assumption to our own cache so we don't throttle the same requests
*/
// XXX: throttling
if (!hadFailure) {
simpleStorage.set(this.getCacheKey(), true, {TTL: 600000});
}
}
});
};
/**
* We don't want to throttle requests for cached resources. However in our case,
* we're unable to check response headers to see if the resource was cached,
* so we use simpleStorage to keep track of what the user has recently queried.
*/
// XXX: throttling
const requestFn = this.isRequestCached() ? makeRequest : this.rateLimit(makeRequest, 100, this);
interWikiKeys.forEach((dbName, index) => {
requestFn(dbName);
});
return dfd;
}
/**
* Return cache key for current params
* @return {String} key
*/
getCacheKey() {
return `lv-cache-${this.hashCode(
JSON.stringify(this.getParams(true))
)}`;
}
/**
* Check simple storage to see if a request with the current params would be cached
* @return {Boolean} cached or not
*/
isRequestCached() {
return simpleStorage.hasKey(this.getCacheKey());
}
/**
* Query Wikidata to find data about a given page across all sister projects
* @param {String} dbName - database name of source project
* @param {String} pageName - name of page we want to get data about
* @return {Deferred} - Promise resolving with interwiki data
*/
getInterwikiData(dbName, pageName) {
const dfd = $.Deferred();
const url = `https://www.wikidata.org/w/api.php?action=wbgetentities&sites=${dbName}` +
`&titles=${encodeURIComponent(pageName)}&props=sitelinks/urls|datatype&format=json&callback=?`;
$.getJSON(url).done(data => {
if (data.error) {
return dfd.reject(`${$.i18n('api-error', 'Wikidata')}: ${data.error.info}`);
} else if (data.entities['-1']) {
return dfd.reject(
`<a href='${this.getPageURL(pageName)}'>${pageName.descore()}</a> - ${$.i18n('api-error-no-data')}`
);
}
const key = Object.keys(data.entities)[0],
sitelinks = data.entities[key].sitelinks,
filteredLinks = {},
matchRegex = new RegExp(`^https://[\\w-]+\\.${this.baseProject}\\.org`);
/** restrict to selected base project (e.g. wikipedias, not wikipedias and wikivoyages) */
Object.keys(sitelinks).forEach(key => {
const siteMapKey = sitelinks[key].site.replace(/-/g, '_');
if (matchRegex.test(sitelinks[key].url) && siteMap[siteMapKey]) {
sitelinks[key].lang = siteMap[siteMapKey].replace(/\.wiki.*$/, '');
filteredLinks[key] = sitelinks[key];
}
});
return dfd.resolve(filteredLinks);
});
return dfd;
}
/**
* Parse wiki URL for the page name
* @param {String} url - full URL to a wiki page
* @return {String|null} page name
*/
getPageNameFromURL(url) {
if (url.includes('?')) {
return url.match(/\?(?:.*\b)?title=(.*?)(?:&|$)/)[1];
} else {
return url.match(/\/wiki\/(.*?)(?:\?|$)/)[1];
}
}
/**
* Parses the URL query string and sets all the inputs accordingly
* Should only be called on initial page load, until we decide to support pop states (probably never)
* @returns {null} nothing
*/
popParams() | {
let startDate, endDate, params = this.parseQueryString('pages');
$(this.config.projectInput).val(params.project || this.config.defaults.project);
if (this.validateProject()) return;
// FIXME: only run this when they actually submit
this.patchUsage('lv');
/**
* Check if we're using a valid range, and if so ignore any start/end dates.
* If an invalid range, throw and error and use default dates.
*/
if (params.range) {
if (!this.setSpecialRange(params.range)) {
this.addSiteNotice('danger', $.i18n('param-error-3'), $.i18n('invalid-params'), true);
this.setSpecialRange(this.config.defaults.dateRange);
}
} else if (params.start) {
startDate = moment(params.start || moment().subtract(this.config.defaults.daysAgo, 'days')); | identifier_body |
|
langviews.js | `);
if (cassandraError) {
if (failureRetries[dbName]) {
failureRetries[dbName]++;
} else {
failureRetries[dbName] = 1;
}
/** maximum of 3 retries */
if (failureRetries[dbName] < 3) {
totalRequestCount++;
return this.rateLimit(makeRequest, 100, this)(dbName);
}
/** retries exceeded */
failedPages.push(failedPageLink);
} else {
this.writeMessage(
`${failedPageLink}: ${$.i18n('api-error', 'Pageviews API')} - ${errorData.responseJSON.title}`
);
}
hadFailure = true; // don't treat this series of requests as being cached by server
}).always(() => {
this.updateProgressBar((++count / totalRequestCount) * 100);
// XXX: throttling, totalRequestCount can just be interWikiKeys.length
if (count === totalRequestCount) {
dfd.resolve(this.langData);
if (failedPages.length) {
this.writeMessage($.i18n(
'api-error-timeout',
'<ul>' +
failedPages.map(failedPage => `<li>${failedPage}</li>`).join('') +
'</ul>'
));
}
/**
* if there were no failures, assume the resource is now cached by the server
* and save this assumption to our own cache so we don't throttle the same requests
*/
// XXX: throttling
if (!hadFailure) {
simpleStorage.set(this.getCacheKey(), true, {TTL: 600000});
}
}
});
};
/**
* We don't want to throttle requests for cached resources. However in our case,
* we're unable to check response headers to see if the resource was cached,
* so we use simpleStorage to keep track of what the user has recently queried.
*/
// XXX: throttling
const requestFn = this.isRequestCached() ? makeRequest : this.rateLimit(makeRequest, 100, this);
interWikiKeys.forEach((dbName, index) => {
requestFn(dbName);
});
return dfd;
}
/**
* Return cache key for current params
* @return {String} key
*/
getCacheKey() {
return `lv-cache-${this.hashCode(
JSON.stringify(this.getParams(true))
)}`;
}
/**
* Check simple storage to see if a request with the current params would be cached
* @return {Boolean} cached or not
*/
isRequestCached() {
return simpleStorage.hasKey(this.getCacheKey());
}
/**
* Query Wikidata to find data about a given page across all sister projects
* @param {String} dbName - database name of source project
* @param {String} pageName - name of page we want to get data about
* @return {Deferred} - Promise resolving with interwiki data
*/
getInterwikiData(dbName, pageName) {
const dfd = $.Deferred();
const url = `https://www.wikidata.org/w/api.php?action=wbgetentities&sites=${dbName}` +
`&titles=${encodeURIComponent(pageName)}&props=sitelinks/urls|datatype&format=json&callback=?`;
$.getJSON(url).done(data => {
if (data.error) {
return dfd.reject(`${$.i18n('api-error', 'Wikidata')}: ${data.error.info}`);
} else if (data.entities['-1']) {
return dfd.reject(
`<a href='${this.getPageURL(pageName)}'>${pageName.descore()}</a> - ${$.i18n('api-error-no-data')}`
);
}
const key = Object.keys(data.entities)[0],
sitelinks = data.entities[key].sitelinks,
filteredLinks = {},
matchRegex = new RegExp(`^https://[\\w-]+\\.${this.baseProject}\\.org`);
/** restrict to selected base project (e.g. wikipedias, not wikipedias and wikivoyages) */
Object.keys(sitelinks).forEach(key => {
const siteMapKey = sitelinks[key].site.replace(/-/g, '_');
if (matchRegex.test(sitelinks[key].url) && siteMap[siteMapKey]) {
sitelinks[key].lang = siteMap[siteMapKey].replace(/\.wiki.*$/, '');
filteredLinks[key] = sitelinks[key];
}
});
return dfd.resolve(filteredLinks);
});
return dfd;
}
/**
* Parse wiki URL for the page name
* @param {String} url - full URL to a wiki page
* @return {String|null} page name
*/
getPageNameFromURL(url) {
if (url.includes('?')) {
return url.match(/\?(?:.*\b)?title=(.*?)(?:&|$)/)[1];
} else {
return url.match(/\/wiki\/(.*?)(?:\?|$)/)[1];
}
}
/**
* Parses the URL query string and sets all the inputs accordingly
* Should only be called on initial page load, until we decide to support pop states (probably never)
* @returns {null} nothing
*/
popParams() {
let startDate, endDate, params = this.parseQueryString('pages');
$(this.config.projectInput).val(params.project || this.config.defaults.project);
if (this.validateProject()) return;
// FIXME: only run this when they actually submit
this.patchUsage('lv');
/**
* Check if we're using a valid range, and if so ignore any start/end dates.
* If an invalid range, throw and error and use default dates.
*/
if (params.range) {
if (!this.setSpecialRange(params.range)) {
this.addSiteNotice('danger', $.i18n('param-error-3'), $.i18n('invalid-params'), true);
this.setSpecialRange(this.config.defaults.dateRange);
}
} else if (params.start) {
startDate = moment(params.start || moment().subtract(this.config.defaults.daysAgo, 'days'));
endDate = moment(params.end || Date.now());
if (startDate < this.config.minDate || endDate < this.config.minDate) {
this.addSiteNotice('danger', $.i18n('param-error-1', `${$.i18n('july')} 2015`), $.i18n('invalid-params'), true);
return;
} else if (startDate > endDate) {
this.addSiteNotice('warning', $.i18n('param-error-2'), $.i18n('invalid-params'), true);
return;
}
this.daterangepicker.setStartDate(startDate);
this.daterangepicker.setEndDate(endDate);
} else {
this.setSpecialRange(this.config.defaults.dateRange);
}
$(this.config.platformSelector).val(params.platform || 'all-access');
$(this.config.agentSelector).val(params.agent || 'user');
this.sort = params.sort || this.config.defaults.params.sort;
this.direction = params.direction || this.config.defaults.params.direction;
/** start up processing if page name is present */
if (params.page) {
$(this.config.articleInput).val(decodeURIComponent(params.page).descore());
this.processArticle();
}
}
getState() {
const classList = $('main')[0].classList;
return this.config.formStates.filter(stateName => {
return classList.contains(stateName);
})[0];
}
/**
* Helper to set a CSS class on the `main` node,
* styling the document based on a 'state'
* @param {String} state - class to be added;
* should be one of ['initial', 'processing', 'complete']
* @returns {null} nothing
*/
setState(state) {
$('main').removeClass(this.config.formStates.join(' ')).addClass(state);
switch (state) {
case 'initial':
this.clearMessages();
this.assignDefaults();
if (this.typeahead) this.typeahead.hide();
$(this.config.articleInput).val('').focus();
break;
case 'processing':
this.processStarted();
this.clearMessages();
document.activeElement.blur();
$('.progress-bar').addClass('active');
break;
case 'complete':
this.processEnded();
/** stop hidden animation for slight performance improvement */
this.updateProgressBar(0);
$('.progress-bar').removeClass('active');
break;
case 'invalid':
break;
}
}
/**
* sets up the daterange selector and adds listeners
* @returns {null} - nothing
*/
setupDateRangeSelector() {
super.setupDateRangeSelector();
$(this.config.dateRangeSelector).on('apply.daterangepicker', (e, action) => {
if (action.chosenLabel === $.i18n('custom-range')) {
this.specialRange = null;
/** force events to re-fire since apply.daterangepicker occurs before 'change' event */
this.daterangepicker.updateElement();
}
});
}
/**
* Process the langviews for the article and options entered
* Called when submitting the form
* @return {null} nothing
*/
| processArticle | identifier_name |
|
langviews.js | -badge' src='${badgeImage}' alt='${badgeName}' title='${badgeName}' />`;
}
/**
* Render list of langviews into view
* @returns {null} nothing
*/
renderData() {
/** sort ascending by current sort setting */
const sortedLangViews = this.langData.sort((a, b) => {
const before = this.getSortProperty(a, this.sort),
after = this.getSortProperty(b, this.sort);
if (before < after) {
return this.direction;
} else if (before > after) {
return -this.direction;
} else {
return 0;
}
});
$('.sort-link span').removeClass('glyphicon-sort-by-alphabet-alt glyphicon-sort-by-alphabet').addClass('glyphicon-sort');
const newSortClassName = parseInt(this.direction) === 1 ? 'glyphicon-sort-by-alphabet-alt' : 'glyphicon-sort-by-alphabet';
$(`.sort-link--${this.sort} span`).addClass(newSortClassName).removeClass('glyphicon-sort');
const totalBadgesMarkup = Object.keys(this.totals.badges).map(badge => {
return `<span class='nowrap'>${this.getBadgeMarkup(badge)} × ${this.totals.badges[badge]}</span>`;
}).join(', ');
$('.output-totals').html(
`<th scope='row'>${$.i18n('totals')}</th>
<th>${$.i18n('num-languages', this.langData.length)}</th>
<th>${$.i18n('unique-titles', this.totals.titles.length)}</th>
<th>${totalBadgesMarkup}</th>
<th>${this.n(this.totals.views)}</th>
<th>${this.n(Math.round(this.totals.views / this.numDaysInRange()))} / ${$.i18n('day')}</th>`
);
$('#lang_list').html('');
sortedLangViews.forEach((item, index) => {
let badgeMarkup = '';
if (item.badges) {
badgeMarkup = item.badges.map(this.getBadgeMarkup.bind(this)).join();
}
$('#lang_list').append(
`<tr>
<th scope='row'>${index + 1}</th>
<td>${item.lang}</td>
<td><a href="${item.url}" target="_blank">${item.pageName}</a></td>
<td>${badgeMarkup}</td>
<td><a href='${this.getPageviewsURL(item.lang, this.baseProject, item.pageName)}'>${this.n(item.views)}</a></td>
<td>${this.n(item.average)} / ${$.i18n('day')}</td>
</tr>`
);
});
this.pushParams();
this.setState('complete');
}
/**
* Get value of given langview entry for the purposes of column sorting
* @param {object} item - langview entry within this.langData
* @param {String} type - type of property to get
* @return {String|Number} - value
*/
getSortProperty(item, type) {
switch (type) {
case 'lang':
return item.lang;
case 'title':
return item.pageName;
case 'badges':
return item.badges.sort().join('');
case 'views':
return Number(item.views);
}
}
/**
* Link to /pageviews for given article and chosen daterange
* @param {String} lang - two character language code
* @param {String} project - base project without lang, e.g. wikipedia.org
* @param {String} article - page name
* @returns {String} URL
*/
// FIXME: should include agent and platform, and use special ranges as currently specified
getPageviewsURL(lang, project, article) {
let startDate = moment(this.daterangepicker.startDate),
endDate = moment(this.daterangepicker.endDate);
const platform = $(this.config.platformSelector).val();
if (endDate.diff(startDate, 'days') === 0) {
startDate.subtract(3, 'days');
endDate.add(3, 'days');
}
return `/pageviews#start=${startDate.format('YYYY-MM-DD')}` +
`&end=${endDate.format('YYYY-MM-DD')}&project=${lang}.${project}.org&platform=${platform}&pages=${article}`;
}
/**
* Loop through given interwiki data and query the pageviews API for each
* Also updates this.langData with result
* @param {Object} interWikiData - as given by the getInterwikiData promise
* @return {Deferred} - Promise resolving with data ready to be rendered to view
*/
getPageViewsData(interWikiData) {
const startDate = this.daterangepicker.startDate.startOf('day'),
endDate = this.daterangepicker.endDate.startOf('day'),
interWikiKeys = Object.keys(interWikiData);
// XXX: throttling
let dfd = $.Deferred(), promises = [], count = 0, hadFailure, failureRetries = {},
totalRequestCount = interWikiKeys.length, failedPages = [];
/** clear out existing data */
this.langData = [];
const makeRequest = dbName => {
const data = interWikiData[dbName],
uriEncodedPageName = encodeURIComponent(data.title);
const url = (
`https://wikimedia.org/api/rest_v1/metrics/pageviews/per-article/${data.lang}.${this.baseProject}` +
`/${$(this.config.platformSelector).val()}/${$(this.config.agentSelector).val()}/${uriEncodedPageName}/daily` +
`/${startDate.format(this.config.timestampFormat)}/${endDate.format(this.config.timestampFormat)}`
);
const promise = $.ajax({ url, dataType: 'json' });
promises.push(promise);
promise.done(pvData => {
const viewCounts = pvData.items.map(el => el.views),
views = viewCounts.reduce((a, b) => a + b);
this.langData.push({
badges: data.badges,
dbName,
lang: data.lang,
pageName: data.title,
views,
url: data.url,
average: Math.round(views / this.numDaysInRange())
});
/** keep track of unique badges/titles and total pageviews */
this.totals.views += views;
if (!this.totals.titles.includes(data.title)) {
this.totals.titles.push(data.title);
}
data.badges.forEach(badge => {
if (this.totals.badges[badge] === undefined) {
this.totals.badges[badge] = 1;
} else {
this.totals.badges[badge] += 1;
}
});
}).fail(errorData => {
// XXX: throttling
/** first detect if this was a Cassandra backend error, and if so, schedule a re-try */
const cassandraError = errorData.responseJSON.title === 'Error in Cassandra table storage backend',
failedPageLink = this.getPageLink(data.title, `${data.lang}.${this.baseProject}.org`);
if (cassandraError) {
if (failureRetries[dbName]) {
failureRetries[dbName]++;
} else { | totalRequestCount++;
return this.rateLimit(makeRequest, 100, this)(dbName);
}
/** retries exceeded */
failedPages.push(failedPageLink);
} else {
this.writeMessage(
`${failedPageLink}: ${$.i18n('api-error', 'Pageviews API')} - ${errorData.responseJSON.title}`
);
}
hadFailure = true; // don't treat this series of requests as being cached by server
}).always(() => {
this.updateProgressBar((++count / totalRequestCount) * 100);
// XXX: throttling, totalRequestCount can just be interWikiKeys.length
if (count === totalRequestCount) {
dfd.resolve(this.langData);
if (failedPages.length) {
this.writeMessage($.i18n(
'api-error-timeout',
'<ul>' +
failedPages.map(failedPage => `<li>${failedPage}</li>`).join('') +
'</ul>'
));
}
/**
* if there were no failures, assume the resource is now cached by the server
* and save this assumption to our own cache so we don't throttle the same requests
*/
// XXX: throttling
if (!hadFailure) {
simpleStorage.set(this.getCacheKey(), true, {TTL: 600000});
}
}
});
};
/**
* We don't want to throttle requests for cached resources. However in our case,
* we're unable to check response headers to see if the resource was cached,
* so we use simpleStorage to keep track of what the user has recently queried.
*/
// XXX: throttling
const requestFn = this.isRequestCached() ? makeRequest : this.rateLimit(makeRequest, 100, this);
interWikiKeys.forEach((dbName, index) => {
requestFn(dbName);
});
return dfd;
}
/**
* Return cache key for current params
* @return {String} key
*/
| failureRetries[dbName] = 1;
}
/** maximum of 3 retries */
if (failureRetries[dbName] < 3) { | random_line_split |
langviews.js | of column sorting
* @param {object} item - langview entry within this.langData
* @param {String} type - type of property to get
* @return {String|Number} - value
*/
getSortProperty(item, type) {
switch (type) {
case 'lang':
return item.lang;
case 'title':
return item.pageName;
case 'badges':
return item.badges.sort().join('');
case 'views':
return Number(item.views);
}
}
/**
* Link to /pageviews for given article and chosen daterange
* @param {String} lang - two character language code
* @param {String} project - base project without lang, e.g. wikipedia.org
* @param {String} article - page name
* @returns {String} URL
*/
// FIXME: should include agent and platform, and use special ranges as currently specified
getPageviewsURL(lang, project, article) {
let startDate = moment(this.daterangepicker.startDate),
endDate = moment(this.daterangepicker.endDate);
const platform = $(this.config.platformSelector).val();
if (endDate.diff(startDate, 'days') === 0) {
startDate.subtract(3, 'days');
endDate.add(3, 'days');
}
return `/pageviews#start=${startDate.format('YYYY-MM-DD')}` +
`&end=${endDate.format('YYYY-MM-DD')}&project=${lang}.${project}.org&platform=${platform}&pages=${article}`;
}
/**
* Loop through given interwiki data and query the pageviews API for each
* Also updates this.langData with result
* @param {Object} interWikiData - as given by the getInterwikiData promise
* @return {Deferred} - Promise resolving with data ready to be rendered to view
*/
getPageViewsData(interWikiData) {
const startDate = this.daterangepicker.startDate.startOf('day'),
endDate = this.daterangepicker.endDate.startOf('day'),
interWikiKeys = Object.keys(interWikiData);
// XXX: throttling
let dfd = $.Deferred(), promises = [], count = 0, hadFailure, failureRetries = {},
totalRequestCount = interWikiKeys.length, failedPages = [];
/** clear out existing data */
this.langData = [];
const makeRequest = dbName => {
const data = interWikiData[dbName],
uriEncodedPageName = encodeURIComponent(data.title);
const url = (
`https://wikimedia.org/api/rest_v1/metrics/pageviews/per-article/${data.lang}.${this.baseProject}` +
`/${$(this.config.platformSelector).val()}/${$(this.config.agentSelector).val()}/${uriEncodedPageName}/daily` +
`/${startDate.format(this.config.timestampFormat)}/${endDate.format(this.config.timestampFormat)}`
);
const promise = $.ajax({ url, dataType: 'json' });
promises.push(promise);
promise.done(pvData => {
const viewCounts = pvData.items.map(el => el.views),
views = viewCounts.reduce((a, b) => a + b);
this.langData.push({
badges: data.badges,
dbName,
lang: data.lang,
pageName: data.title,
views,
url: data.url,
average: Math.round(views / this.numDaysInRange())
});
/** keep track of unique badges/titles and total pageviews */
this.totals.views += views;
if (!this.totals.titles.includes(data.title)) {
this.totals.titles.push(data.title);
}
data.badges.forEach(badge => {
if (this.totals.badges[badge] === undefined) {
this.totals.badges[badge] = 1;
} else {
this.totals.badges[badge] += 1;
}
});
}).fail(errorData => {
// XXX: throttling
/** first detect if this was a Cassandra backend error, and if so, schedule a re-try */
const cassandraError = errorData.responseJSON.title === 'Error in Cassandra table storage backend',
failedPageLink = this.getPageLink(data.title, `${data.lang}.${this.baseProject}.org`);
if (cassandraError) {
if (failureRetries[dbName]) {
failureRetries[dbName]++;
} else {
failureRetries[dbName] = 1;
}
/** maximum of 3 retries */
if (failureRetries[dbName] < 3) {
totalRequestCount++;
return this.rateLimit(makeRequest, 100, this)(dbName);
}
/** retries exceeded */
failedPages.push(failedPageLink);
} else {
this.writeMessage(
`${failedPageLink}: ${$.i18n('api-error', 'Pageviews API')} - ${errorData.responseJSON.title}`
);
}
hadFailure = true; // don't treat this series of requests as being cached by server
}).always(() => {
this.updateProgressBar((++count / totalRequestCount) * 100);
// XXX: throttling, totalRequestCount can just be interWikiKeys.length
if (count === totalRequestCount) {
dfd.resolve(this.langData);
if (failedPages.length) {
this.writeMessage($.i18n(
'api-error-timeout',
'<ul>' +
failedPages.map(failedPage => `<li>${failedPage}</li>`).join('') +
'</ul>'
));
}
/**
* if there were no failures, assume the resource is now cached by the server
* and save this assumption to our own cache so we don't throttle the same requests
*/
// XXX: throttling
if (!hadFailure) {
simpleStorage.set(this.getCacheKey(), true, {TTL: 600000});
}
}
});
};
/**
* We don't want to throttle requests for cached resources. However in our case,
* we're unable to check response headers to see if the resource was cached,
* so we use simpleStorage to keep track of what the user has recently queried.
*/
// XXX: throttling
const requestFn = this.isRequestCached() ? makeRequest : this.rateLimit(makeRequest, 100, this);
interWikiKeys.forEach((dbName, index) => {
requestFn(dbName);
});
return dfd;
}
/**
* Return cache key for current params
* @return {String} key
*/
getCacheKey() {
return `lv-cache-${this.hashCode(
JSON.stringify(this.getParams(true))
)}`;
}
/**
* Check simple storage to see if a request with the current params would be cached
* @return {Boolean} cached or not
*/
isRequestCached() {
return simpleStorage.hasKey(this.getCacheKey());
}
/**
* Query Wikidata to find data about a given page across all sister projects
* @param {String} dbName - database name of source project
* @param {String} pageName - name of page we want to get data about
* @return {Deferred} - Promise resolving with interwiki data
*/
getInterwikiData(dbName, pageName) {
const dfd = $.Deferred();
const url = `https://www.wikidata.org/w/api.php?action=wbgetentities&sites=${dbName}` +
`&titles=${encodeURIComponent(pageName)}&props=sitelinks/urls|datatype&format=json&callback=?`;
$.getJSON(url).done(data => {
if (data.error) {
return dfd.reject(`${$.i18n('api-error', 'Wikidata')}: ${data.error.info}`);
} else if (data.entities['-1']) {
return dfd.reject(
`<a href='${this.getPageURL(pageName)}'>${pageName.descore()}</a> - ${$.i18n('api-error-no-data')}`
);
}
const key = Object.keys(data.entities)[0],
sitelinks = data.entities[key].sitelinks,
filteredLinks = {},
matchRegex = new RegExp(`^https://[\\w-]+\\.${this.baseProject}\\.org`);
/** restrict to selected base project (e.g. wikipedias, not wikipedias and wikivoyages) */
Object.keys(sitelinks).forEach(key => {
const siteMapKey = sitelinks[key].site.replace(/-/g, '_');
if (matchRegex.test(sitelinks[key].url) && siteMap[siteMapKey]) {
sitelinks[key].lang = siteMap[siteMapKey].replace(/\.wiki.*$/, '');
filteredLinks[key] = sitelinks[key];
}
});
return dfd.resolve(filteredLinks);
});
return dfd;
}
/**
* Parse wiki URL for the page name
* @param {String} url - full URL to a wiki page
* @return {String|null} page name
*/
getPageNameFromURL(url) {
if (url.includes('?')) {
return url.match(/\?(?:.*\b)?title=(.*?)(?:&|$)/)[1];
} else | {
return url.match(/\/wiki\/(.*?)(?:\?|$)/)[1];
} | conditional_block |
|
gaia_executor.rs | store_config
} else {
StoreConfig::init()
}
};
let (alive_id, partitions) = get_init_info(&store_config);
info!("alive_id: {:?}, partitions: {:?}", alive_id, partitions);
store_config.update_alive_id(alive_id);
info!("{:?}", store_config);
let worker_num = store_config.timely_worker_per_process;
let store_config = Arc::new(store_config);
if store_config.graph_type.to_lowercase().eq(VINEYARD_GRAPH) {
if cfg!(target_os = "linux") {
info!(
"Start executor with vineyard graph object id {:?}",
store_config.vineyard_graph_id
);
use maxgraph_runtime::store::ffi::FFIGraphStore;
let ffi_store = FFIGraphStore::new(store_config.vineyard_graph_id, worker_num as i32);
let partition_manager = ffi_store.get_partition_manager();
run_main(
store_config,
Arc::new(ffi_store),
Arc::new(partition_manager),
);
} else {
unimplemented!("Mac not support vineyard graph")
}
} else {
unimplemented!("only start vineyard graph from executor")
}
}
fn run_main<V, VI, E, EI>(
store_config: Arc<StoreConfig>,
graph: Arc<GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<GraphPartitionManager>,
) where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
let process_partition_list = partition_manager.get_process_partition_list();
info!("process_partition_list: {:?}", process_partition_list);
let runtime_info = Arc::new(Mutex::new(RuntimeInfo::new(
store_config.timely_worker_per_process,
process_partition_list,
)));
let runtime_info_clone = runtime_info.clone();
let (hb_resp_sender, hb_resp_receiver) = channel();
let signal = Arc::new(AtomicBool::new(false));
let gaia_server_manager =
GaiaServerManager::new(hb_resp_receiver, runtime_info, signal.clone());
let partition_worker_mapping = gaia_server_manager.get_partition_worker_mapping();
let worker_partition_list_mapping = gaia_server_manager.get_worker_partition_list_mapping();
let server_manager = Box::new(gaia_server_manager);
let _manager_guards = ServerManager::start_server(
server_manager,
store_config.clone(),
Box::new(recover_prepare),
)
.unwrap();
let gaia_service = GaiaService::new(
store_config.clone(),
graph.clone(),
partition_manager.clone(),
partition_worker_mapping,
worker_partition_list_mapping,
);
let (_, gaia_rpc_service_port) = gaia_service.start_rpc_service();
let store_context = StoreContext::new(graph, partition_manager);
start_hb_rpc_service(
runtime_info_clone,
store_config,
gaia_rpc_service_port,
hb_resp_sender,
store_context,
);
thread::sleep(Duration::from_secs(u64::max_value()));
}
fn recover_prepare(prepared: &[u8]) -> Result<Vec<u8>, String> {
::protobuf::parse_from_bytes::<QueryFlow>(prepared)
.map_err(|err| err.to_string())
.and_then(move |desc| {
info!("parse {} bytes to {:?} ", prepared.len(), desc);
Ok(desc.write_to_bytes().expect("query flow to bytes"))
})
}
fn start_hb_rpc_service<VV, VVI, EE, EEI>(
runtime_info: Arc<Mutex<RuntimeInfo>>,
store_config: Arc<StoreConfig>,
gaia_service_port: u16,
hb_resp_sender: Sender<Arc<ServerHBResp>>,
store_context: StoreContext<VV, VVI, EE, EEI>,
) where
VV: 'static + Vertex,
VVI: 'static + Iterator<Item = VV> + Send,
EE: 'static + Edge,
EEI: 'static + Iterator<Item = EE> + Send,
{
// build hb information
let mut hb_providers = Vec::new();
let mut hb_resp_senders = Vec::new();
let hb_provider = move |ref mut server_hb_req: &mut ServerHBReq| {
server_hb_req.set_runtimeReq(build_runtime_req(runtime_info.clone()));
server_hb_req
.mut_endpoint()
.set_runtimCtrlAndAsyncPort(gaia_service_port as i32);
};
hb_providers.push(Box::new(hb_provider));
hb_resp_senders.push(hb_resp_sender);
let store_config_clone = store_config.clone();
init_with_rpc_service(
store_config_clone,
hb_providers,
hb_resp_senders,
store_context,
);
}
fn build_runtime_req(runtime_info: Arc<Mutex<RuntimeInfo>>) -> RuntimeHBReq {
let hb_req = runtime_info.lock().expect("Lock runtime hb req failed");
let mut runtime_req = RuntimeHBReq::new();
runtime_req.set_serverStatus(hb_req.get_server_status());
runtime_req.set_runtimePort(hb_req.get_server_port() as i32);
runtime_req.set_worker_num_per_process(hb_req.get_worker_num_per_process());
runtime_req.set_process_partition_list(hb_req.get_process_partition_list().to_vec());
debug!("Build runtime request {:?} in heartbeat", &runtime_req);
runtime_req
}
/// return: (aliveId, partiiton assignments)
fn get_init_info(config: &StoreConfig) -> (u64, Vec<PartitionId>) {
use maxgraph_common::proto::data_grpc::*;
use maxgraph_common::util::ip;
use maxgraph_server::client::ZKClient;
let zk_url = format!("{}/{}", config.zk_url, config.graph_name);
let zk = ZKClient::new(&zk_url, config.zk_timeout_ms, config.get_zk_auth());
let addr = zk.get_coordinator_addr();
let channel =
ChannelBuilder::new(Arc::new(EnvBuilder::new().build())).connect(addr.to_string().as_str());
let client = ServerDataApiClient::new(channel);
let mut request = GetExecutorAliveIdRequest::new();
request.set_serverId(config.worker_id);
request.set_ip(ip::get_local_ip());
let response = client.get_executor_alive_id(&request).unwrap();
let alive_id = response.get_aliveId();
let mut request = GetPartitionAssignmentRequest::new();
request.set_serverId(config.worker_id);
let response = client.get_partition_assignment(&request).unwrap();
let partitions = response.get_partitionId().to_vec();
(alive_id, partitions)
}
pub struct GaiaService<V, VI, E, EI>
where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
store_config: Arc<StoreConfig>,
graph: Arc<dyn GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<dyn GraphPartitionManager>,
// mapping of partition id -> worker id
partition_worker_mapping: Arc<RwLock<Option<HashMap<u32, u32>>>>,
// mapping of worker id -> partition list
worker_partition_list_mapping: Arc<RwLock<Option<HashMap<u32, Vec<u32>>>>>,
rpc_runtime: Runtime,
}
impl<V, VI, E, EI> GaiaService<V, VI, E, EI>
where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
pub fn new(
store_config: Arc<StoreConfig>,
graph: Arc<dyn GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<dyn GraphPartitionManager>,
partition_worker_mapping: Arc<RwLock<Option<HashMap<u32, u32>>>>,
worker_partition_list_mapping: Arc<RwLock<Option<HashMap<u32, Vec<u32>>>>>,
) -> GaiaService<V, VI, E, EI> {
GaiaService {
store_config,
graph,
partition_manager,
partition_worker_mapping,
worker_partition_list_mapping,
rpc_runtime: Runtime::new().unwrap(),
}
}
pub fn start_rpc_service(&self) -> (String, u16) | {
let rpc_port = self.rpc_runtime.block_on(async {
let query_vineyard = QueryVineyard::new(
self.graph.clone(),
self.partition_manager.clone(),
self.partition_worker_mapping.clone(),
self.worker_partition_list_mapping.clone(),
self.store_config.worker_num as usize,
self.store_config.worker_id as u64,
);
let job_compiler = query_vineyard.initialize_job_compiler();
let service = Service::new(job_compiler);
let addr = format!("{}:{}", "0.0.0.0", self.store_config.rpc_port);
let local_addr = start_rpc_server(addr.parse().unwrap(), service, true, false)
.await
.unwrap();
local_addr.port()
});
let ip = get_local_ip();
info!("start rpc server on {} {}", ip, rpc_port); | identifier_body |
|
gaia_executor.rs | crate maxgraph_server;
extern crate maxgraph_store;
extern crate pegasus;
extern crate pegasus_server;
extern crate protobuf;
extern crate structopt;
use gaia_runtime::server::init_with_rpc_service;
use gaia_runtime::server::manager::GaiaServerManager;
use grpcio::ChannelBuilder;
use grpcio::EnvBuilder;
use gs_gremlin::{InitializeJobCompiler, QueryVineyard};
use maxgraph_common::proto::data::*;
use maxgraph_common::proto::hb::*;
use maxgraph_common::proto::query_flow::*;
use maxgraph_common::util;
use maxgraph_common::util::get_local_ip;
use maxgraph_common::util::log4rs::init_log4rs;
use maxgraph_runtime::server::manager::*;
use maxgraph_runtime::server::RuntimeInfo;
use maxgraph_server::StoreContext;
use maxgraph_store::api::graph_partition::GraphPartitionManager;
use maxgraph_store::api::prelude::*;
use maxgraph_store::config::{StoreConfig, VINEYARD_GRAPH};
use pegasus_server::rpc::start_rpc_server;
use pegasus_server::service::Service;
use protobuf::Message;
use std::collections::HashMap;
use std::env;
use std::sync::atomic::AtomicBool;
use std::sync::mpsc::{channel, Sender};
use std::sync::{Arc, Mutex, RwLock};
use std::thread;
use std::time::Duration;
use tokio::runtime::Runtime;
fn main() {
if let Some(_) = env::args().find(|arg| arg == "--show-build-info") |
init_log4rs();
let mut store_config = {
let args: Vec<String> = std::env::args().collect();
if args.len() <= 6 && args[1] == "--config" {
let mut store_config = StoreConfig::init_from_file(&args[2], &args[4]);
if args.len() == 6 {
store_config.graph_name = (&args[5]).to_string();
}
store_config
} else {
StoreConfig::init()
}
};
let (alive_id, partitions) = get_init_info(&store_config);
info!("alive_id: {:?}, partitions: {:?}", alive_id, partitions);
store_config.update_alive_id(alive_id);
info!("{:?}", store_config);
let worker_num = store_config.timely_worker_per_process;
let store_config = Arc::new(store_config);
if store_config.graph_type.to_lowercase().eq(VINEYARD_GRAPH) {
if cfg!(target_os = "linux") {
info!(
"Start executor with vineyard graph object id {:?}",
store_config.vineyard_graph_id
);
use maxgraph_runtime::store::ffi::FFIGraphStore;
let ffi_store = FFIGraphStore::new(store_config.vineyard_graph_id, worker_num as i32);
let partition_manager = ffi_store.get_partition_manager();
run_main(
store_config,
Arc::new(ffi_store),
Arc::new(partition_manager),
);
} else {
unimplemented!("Mac not support vineyard graph")
}
} else {
unimplemented!("only start vineyard graph from executor")
}
}
fn run_main<V, VI, E, EI>(
store_config: Arc<StoreConfig>,
graph: Arc<GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<GraphPartitionManager>,
) where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
let process_partition_list = partition_manager.get_process_partition_list();
info!("process_partition_list: {:?}", process_partition_list);
let runtime_info = Arc::new(Mutex::new(RuntimeInfo::new(
store_config.timely_worker_per_process,
process_partition_list,
)));
let runtime_info_clone = runtime_info.clone();
let (hb_resp_sender, hb_resp_receiver) = channel();
let signal = Arc::new(AtomicBool::new(false));
let gaia_server_manager =
GaiaServerManager::new(hb_resp_receiver, runtime_info, signal.clone());
let partition_worker_mapping = gaia_server_manager.get_partition_worker_mapping();
let worker_partition_list_mapping = gaia_server_manager.get_worker_partition_list_mapping();
let server_manager = Box::new(gaia_server_manager);
let _manager_guards = ServerManager::start_server(
server_manager,
store_config.clone(),
Box::new(recover_prepare),
)
.unwrap();
let gaia_service = GaiaService::new(
store_config.clone(),
graph.clone(),
partition_manager.clone(),
partition_worker_mapping,
worker_partition_list_mapping,
);
let (_, gaia_rpc_service_port) = gaia_service.start_rpc_service();
let store_context = StoreContext::new(graph, partition_manager);
start_hb_rpc_service(
runtime_info_clone,
store_config,
gaia_rpc_service_port,
hb_resp_sender,
store_context,
);
thread::sleep(Duration::from_secs(u64::max_value()));
}
fn recover_prepare(prepared: &[u8]) -> Result<Vec<u8>, String> {
::protobuf::parse_from_bytes::<QueryFlow>(prepared)
.map_err(|err| err.to_string())
.and_then(move |desc| {
info!("parse {} bytes to {:?} ", prepared.len(), desc);
Ok(desc.write_to_bytes().expect("query flow to bytes"))
})
}
fn start_hb_rpc_service<VV, VVI, EE, EEI>(
runtime_info: Arc<Mutex<RuntimeInfo>>,
store_config: Arc<StoreConfig>,
gaia_service_port: u16,
hb_resp_sender: Sender<Arc<ServerHBResp>>,
store_context: StoreContext<VV, VVI, EE, EEI>,
) where
VV: 'static + Vertex,
VVI: 'static + Iterator<Item = VV> + Send,
EE: 'static + Edge,
EEI: 'static + Iterator<Item = EE> + Send,
{
// build hb information
let mut hb_providers = Vec::new();
let mut hb_resp_senders = Vec::new();
let hb_provider = move |ref mut server_hb_req: &mut ServerHBReq| {
server_hb_req.set_runtimeReq(build_runtime_req(runtime_info.clone()));
server_hb_req
.mut_endpoint()
.set_runtimCtrlAndAsyncPort(gaia_service_port as i32);
};
hb_providers.push(Box::new(hb_provider));
hb_resp_senders.push(hb_resp_sender);
let store_config_clone = store_config.clone();
init_with_rpc_service(
store_config_clone,
hb_providers,
hb_resp_senders,
store_context,
);
}
fn build_runtime_req(runtime_info: Arc<Mutex<RuntimeInfo>>) -> RuntimeHBReq {
let hb_req = runtime_info.lock().expect("Lock runtime hb req failed");
let mut runtime_req = RuntimeHBReq::new();
runtime_req.set_serverStatus(hb_req.get_server_status());
runtime_req.set_runtimePort(hb_req.get_server_port() as i32);
runtime_req.set_worker_num_per_process(hb_req.get_worker_num_per_process());
runtime_req.set_process_partition_list(hb_req.get_process_partition_list().to_vec());
debug!("Build runtime request {:?} in heartbeat", &runtime_req);
runtime_req
}
/// return: (aliveId, partiiton assignments)
fn get_init_info(config: &StoreConfig) -> (u64, Vec<PartitionId>) {
use maxgraph_common::proto::data_grpc::*;
use maxgraph_common::util::ip;
use maxgraph_server::client::ZKClient;
let zk_url = format!("{}/{}", config.zk_url, config.graph_name);
let zk = ZKClient::new(&zk_url, config.zk_timeout_ms, config.get_zk_auth());
let addr = zk.get_coordinator_addr();
let channel =
ChannelBuilder::new(Arc::new(EnvBuilder::new().build())).connect(addr.to_string().as_str());
let client = ServerDataApiClient::new(channel);
let mut request = GetExecutorAliveIdRequest::new();
request.set_serverId(config.worker_id);
request.set_ip(ip::get_local_ip());
let response = client.get_executor_alive_id(&request).unwrap();
let alive_id = response.get_aliveId();
let mut request = GetPartitionAssignmentRequest::new();
request.set_serverId(config.worker_id);
let response = client.get_partition_assignment(&request).unwrap();
let partitions = response.get_partitionId().to_vec();
(alive_id, partitions)
}
pub struct GaiaService<V, VI, E, EI>
where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
store_config: Arc<StoreConfig>,
graph: Arc<dyn GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<dyn GraphPartitionManager>,
// mapping of partition id -> worker id
partition_worker_mapping: Arc<RwLock<Option<HashMap<u32, u32>>>>,
// mapping of worker id -> partition | {
util::get_build_info();
return;
} | conditional_block |
gaia_executor.rs | extern crate maxgraph_server;
extern crate maxgraph_store;
extern crate pegasus;
extern crate pegasus_server;
extern crate protobuf;
extern crate structopt;
use gaia_runtime::server::init_with_rpc_service;
use gaia_runtime::server::manager::GaiaServerManager;
use grpcio::ChannelBuilder;
use grpcio::EnvBuilder;
use gs_gremlin::{InitializeJobCompiler, QueryVineyard};
use maxgraph_common::proto::data::*;
use maxgraph_common::proto::hb::*;
use maxgraph_common::proto::query_flow::*;
use maxgraph_common::util;
use maxgraph_common::util::get_local_ip;
use maxgraph_common::util::log4rs::init_log4rs;
use maxgraph_runtime::server::manager::*;
use maxgraph_runtime::server::RuntimeInfo;
use maxgraph_server::StoreContext;
use maxgraph_store::api::graph_partition::GraphPartitionManager;
use maxgraph_store::api::prelude::*;
use maxgraph_store::config::{StoreConfig, VINEYARD_GRAPH};
use pegasus_server::rpc::start_rpc_server;
use pegasus_server::service::Service;
use protobuf::Message;
use std::collections::HashMap;
use std::env;
use std::sync::atomic::AtomicBool;
use std::sync::mpsc::{channel, Sender};
use std::sync::{Arc, Mutex, RwLock};
use std::thread;
use std::time::Duration;
use tokio::runtime::Runtime;
fn main() {
if let Some(_) = env::args().find(|arg| arg == "--show-build-info") {
util::get_build_info();
return;
}
init_log4rs();
let mut store_config = {
let args: Vec<String> = std::env::args().collect();
if args.len() <= 6 && args[1] == "--config" {
let mut store_config = StoreConfig::init_from_file(&args[2], &args[4]);
if args.len() == 6 {
store_config.graph_name = (&args[5]).to_string();
}
store_config
} else {
StoreConfig::init()
}
};
let (alive_id, partitions) = get_init_info(&store_config);
info!("alive_id: {:?}, partitions: {:?}", alive_id, partitions);
store_config.update_alive_id(alive_id);
info!("{:?}", store_config);
let worker_num = store_config.timely_worker_per_process;
let store_config = Arc::new(store_config);
if store_config.graph_type.to_lowercase().eq(VINEYARD_GRAPH) {
if cfg!(target_os = "linux") {
info!(
"Start executor with vineyard graph object id {:?}",
store_config.vineyard_graph_id
);
use maxgraph_runtime::store::ffi::FFIGraphStore;
let ffi_store = FFIGraphStore::new(store_config.vineyard_graph_id, worker_num as i32);
let partition_manager = ffi_store.get_partition_manager();
run_main(
store_config,
Arc::new(ffi_store),
Arc::new(partition_manager),
);
} else {
unimplemented!("Mac not support vineyard graph")
}
} else {
unimplemented!("only start vineyard graph from executor")
}
}
fn run_main<V, VI, E, EI>(
store_config: Arc<StoreConfig>,
graph: Arc<GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<GraphPartitionManager>,
) where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
let process_partition_list = partition_manager.get_process_partition_list();
info!("process_partition_list: {:?}", process_partition_list);
let runtime_info = Arc::new(Mutex::new(RuntimeInfo::new(
store_config.timely_worker_per_process,
process_partition_list,
)));
let runtime_info_clone = runtime_info.clone();
let (hb_resp_sender, hb_resp_receiver) = channel();
let signal = Arc::new(AtomicBool::new(false));
let gaia_server_manager =
GaiaServerManager::new(hb_resp_receiver, runtime_info, signal.clone());
let partition_worker_mapping = gaia_server_manager.get_partition_worker_mapping();
let worker_partition_list_mapping = gaia_server_manager.get_worker_partition_list_mapping();
let server_manager = Box::new(gaia_server_manager);
let _manager_guards = ServerManager::start_server( | server_manager,
store_config.clone(),
Box::new(recover_prepare),
)
.unwrap();
let gaia_service = GaiaService::new(
store_config.clone(),
graph.clone(),
partition_manager.clone(),
partition_worker_mapping,
worker_partition_list_mapping,
);
let (_, gaia_rpc_service_port) = gaia_service.start_rpc_service();
let store_context = StoreContext::new(graph, partition_manager);
start_hb_rpc_service(
runtime_info_clone,
store_config,
gaia_rpc_service_port,
hb_resp_sender,
store_context,
);
thread::sleep(Duration::from_secs(u64::max_value()));
}
fn recover_prepare(prepared: &[u8]) -> Result<Vec<u8>, String> {
::protobuf::parse_from_bytes::<QueryFlow>(prepared)
.map_err(|err| err.to_string())
.and_then(move |desc| {
info!("parse {} bytes to {:?} ", prepared.len(), desc);
Ok(desc.write_to_bytes().expect("query flow to bytes"))
})
}
fn start_hb_rpc_service<VV, VVI, EE, EEI>(
runtime_info: Arc<Mutex<RuntimeInfo>>,
store_config: Arc<StoreConfig>,
gaia_service_port: u16,
hb_resp_sender: Sender<Arc<ServerHBResp>>,
store_context: StoreContext<VV, VVI, EE, EEI>,
) where
VV: 'static + Vertex,
VVI: 'static + Iterator<Item = VV> + Send,
EE: 'static + Edge,
EEI: 'static + Iterator<Item = EE> + Send,
{
// build hb information
let mut hb_providers = Vec::new();
let mut hb_resp_senders = Vec::new();
let hb_provider = move |ref mut server_hb_req: &mut ServerHBReq| {
server_hb_req.set_runtimeReq(build_runtime_req(runtime_info.clone()));
server_hb_req
.mut_endpoint()
.set_runtimCtrlAndAsyncPort(gaia_service_port as i32);
};
hb_providers.push(Box::new(hb_provider));
hb_resp_senders.push(hb_resp_sender);
let store_config_clone = store_config.clone();
init_with_rpc_service(
store_config_clone,
hb_providers,
hb_resp_senders,
store_context,
);
}
fn build_runtime_req(runtime_info: Arc<Mutex<RuntimeInfo>>) -> RuntimeHBReq {
let hb_req = runtime_info.lock().expect("Lock runtime hb req failed");
let mut runtime_req = RuntimeHBReq::new();
runtime_req.set_serverStatus(hb_req.get_server_status());
runtime_req.set_runtimePort(hb_req.get_server_port() as i32);
runtime_req.set_worker_num_per_process(hb_req.get_worker_num_per_process());
runtime_req.set_process_partition_list(hb_req.get_process_partition_list().to_vec());
debug!("Build runtime request {:?} in heartbeat", &runtime_req);
runtime_req
}
/// return: (aliveId, partiiton assignments)
fn get_init_info(config: &StoreConfig) -> (u64, Vec<PartitionId>) {
use maxgraph_common::proto::data_grpc::*;
use maxgraph_common::util::ip;
use maxgraph_server::client::ZKClient;
let zk_url = format!("{}/{}", config.zk_url, config.graph_name);
let zk = ZKClient::new(&zk_url, config.zk_timeout_ms, config.get_zk_auth());
let addr = zk.get_coordinator_addr();
let channel =
ChannelBuilder::new(Arc::new(EnvBuilder::new().build())).connect(addr.to_string().as_str());
let client = ServerDataApiClient::new(channel);
let mut request = GetExecutorAliveIdRequest::new();
request.set_serverId(config.worker_id);
request.set_ip(ip::get_local_ip());
let response = client.get_executor_alive_id(&request).unwrap();
let alive_id = response.get_aliveId();
let mut request = GetPartitionAssignmentRequest::new();
request.set_serverId(config.worker_id);
let response = client.get_partition_assignment(&request).unwrap();
let partitions = response.get_partitionId().to_vec();
(alive_id, partitions)
}
pub struct GaiaService<V, VI, E, EI>
where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
store_config: Arc<StoreConfig>,
graph: Arc<dyn GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<dyn GraphPartitionManager>,
// mapping of partition id -> worker id
partition_worker_mapping: Arc<RwLock<Option<HashMap<u32, u32>>>>,
// mapping of worker id -> partition list | random_line_split |
|
gaia_executor.rs | crate maxgraph_server;
extern crate maxgraph_store;
extern crate pegasus;
extern crate pegasus_server;
extern crate protobuf;
extern crate structopt;
use gaia_runtime::server::init_with_rpc_service;
use gaia_runtime::server::manager::GaiaServerManager;
use grpcio::ChannelBuilder;
use grpcio::EnvBuilder;
use gs_gremlin::{InitializeJobCompiler, QueryVineyard};
use maxgraph_common::proto::data::*;
use maxgraph_common::proto::hb::*;
use maxgraph_common::proto::query_flow::*;
use maxgraph_common::util;
use maxgraph_common::util::get_local_ip;
use maxgraph_common::util::log4rs::init_log4rs;
use maxgraph_runtime::server::manager::*;
use maxgraph_runtime::server::RuntimeInfo;
use maxgraph_server::StoreContext;
use maxgraph_store::api::graph_partition::GraphPartitionManager;
use maxgraph_store::api::prelude::*;
use maxgraph_store::config::{StoreConfig, VINEYARD_GRAPH};
use pegasus_server::rpc::start_rpc_server;
use pegasus_server::service::Service;
use protobuf::Message;
use std::collections::HashMap;
use std::env;
use std::sync::atomic::AtomicBool;
use std::sync::mpsc::{channel, Sender};
use std::sync::{Arc, Mutex, RwLock};
use std::thread;
use std::time::Duration;
use tokio::runtime::Runtime;
fn main() {
if let Some(_) = env::args().find(|arg| arg == "--show-build-info") {
util::get_build_info();
return;
}
init_log4rs();
let mut store_config = {
let args: Vec<String> = std::env::args().collect();
if args.len() <= 6 && args[1] == "--config" {
let mut store_config = StoreConfig::init_from_file(&args[2], &args[4]);
if args.len() == 6 {
store_config.graph_name = (&args[5]).to_string();
}
store_config
} else {
StoreConfig::init()
}
};
let (alive_id, partitions) = get_init_info(&store_config);
info!("alive_id: {:?}, partitions: {:?}", alive_id, partitions);
store_config.update_alive_id(alive_id);
info!("{:?}", store_config);
let worker_num = store_config.timely_worker_per_process;
let store_config = Arc::new(store_config);
if store_config.graph_type.to_lowercase().eq(VINEYARD_GRAPH) {
if cfg!(target_os = "linux") {
info!(
"Start executor with vineyard graph object id {:?}",
store_config.vineyard_graph_id
);
use maxgraph_runtime::store::ffi::FFIGraphStore;
let ffi_store = FFIGraphStore::new(store_config.vineyard_graph_id, worker_num as i32);
let partition_manager = ffi_store.get_partition_manager();
run_main(
store_config,
Arc::new(ffi_store),
Arc::new(partition_manager),
);
} else {
unimplemented!("Mac not support vineyard graph")
}
} else {
unimplemented!("only start vineyard graph from executor")
}
}
fn | <V, VI, E, EI>(
store_config: Arc<StoreConfig>,
graph: Arc<GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<GraphPartitionManager>,
) where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
let process_partition_list = partition_manager.get_process_partition_list();
info!("process_partition_list: {:?}", process_partition_list);
let runtime_info = Arc::new(Mutex::new(RuntimeInfo::new(
store_config.timely_worker_per_process,
process_partition_list,
)));
let runtime_info_clone = runtime_info.clone();
let (hb_resp_sender, hb_resp_receiver) = channel();
let signal = Arc::new(AtomicBool::new(false));
let gaia_server_manager =
GaiaServerManager::new(hb_resp_receiver, runtime_info, signal.clone());
let partition_worker_mapping = gaia_server_manager.get_partition_worker_mapping();
let worker_partition_list_mapping = gaia_server_manager.get_worker_partition_list_mapping();
let server_manager = Box::new(gaia_server_manager);
let _manager_guards = ServerManager::start_server(
server_manager,
store_config.clone(),
Box::new(recover_prepare),
)
.unwrap();
let gaia_service = GaiaService::new(
store_config.clone(),
graph.clone(),
partition_manager.clone(),
partition_worker_mapping,
worker_partition_list_mapping,
);
let (_, gaia_rpc_service_port) = gaia_service.start_rpc_service();
let store_context = StoreContext::new(graph, partition_manager);
start_hb_rpc_service(
runtime_info_clone,
store_config,
gaia_rpc_service_port,
hb_resp_sender,
store_context,
);
thread::sleep(Duration::from_secs(u64::max_value()));
}
fn recover_prepare(prepared: &[u8]) -> Result<Vec<u8>, String> {
::protobuf::parse_from_bytes::<QueryFlow>(prepared)
.map_err(|err| err.to_string())
.and_then(move |desc| {
info!("parse {} bytes to {:?} ", prepared.len(), desc);
Ok(desc.write_to_bytes().expect("query flow to bytes"))
})
}
fn start_hb_rpc_service<VV, VVI, EE, EEI>(
runtime_info: Arc<Mutex<RuntimeInfo>>,
store_config: Arc<StoreConfig>,
gaia_service_port: u16,
hb_resp_sender: Sender<Arc<ServerHBResp>>,
store_context: StoreContext<VV, VVI, EE, EEI>,
) where
VV: 'static + Vertex,
VVI: 'static + Iterator<Item = VV> + Send,
EE: 'static + Edge,
EEI: 'static + Iterator<Item = EE> + Send,
{
// build hb information
let mut hb_providers = Vec::new();
let mut hb_resp_senders = Vec::new();
let hb_provider = move |ref mut server_hb_req: &mut ServerHBReq| {
server_hb_req.set_runtimeReq(build_runtime_req(runtime_info.clone()));
server_hb_req
.mut_endpoint()
.set_runtimCtrlAndAsyncPort(gaia_service_port as i32);
};
hb_providers.push(Box::new(hb_provider));
hb_resp_senders.push(hb_resp_sender);
let store_config_clone = store_config.clone();
init_with_rpc_service(
store_config_clone,
hb_providers,
hb_resp_senders,
store_context,
);
}
fn build_runtime_req(runtime_info: Arc<Mutex<RuntimeInfo>>) -> RuntimeHBReq {
let hb_req = runtime_info.lock().expect("Lock runtime hb req failed");
let mut runtime_req = RuntimeHBReq::new();
runtime_req.set_serverStatus(hb_req.get_server_status());
runtime_req.set_runtimePort(hb_req.get_server_port() as i32);
runtime_req.set_worker_num_per_process(hb_req.get_worker_num_per_process());
runtime_req.set_process_partition_list(hb_req.get_process_partition_list().to_vec());
debug!("Build runtime request {:?} in heartbeat", &runtime_req);
runtime_req
}
/// return: (aliveId, partiiton assignments)
fn get_init_info(config: &StoreConfig) -> (u64, Vec<PartitionId>) {
use maxgraph_common::proto::data_grpc::*;
use maxgraph_common::util::ip;
use maxgraph_server::client::ZKClient;
let zk_url = format!("{}/{}", config.zk_url, config.graph_name);
let zk = ZKClient::new(&zk_url, config.zk_timeout_ms, config.get_zk_auth());
let addr = zk.get_coordinator_addr();
let channel =
ChannelBuilder::new(Arc::new(EnvBuilder::new().build())).connect(addr.to_string().as_str());
let client = ServerDataApiClient::new(channel);
let mut request = GetExecutorAliveIdRequest::new();
request.set_serverId(config.worker_id);
request.set_ip(ip::get_local_ip());
let response = client.get_executor_alive_id(&request).unwrap();
let alive_id = response.get_aliveId();
let mut request = GetPartitionAssignmentRequest::new();
request.set_serverId(config.worker_id);
let response = client.get_partition_assignment(&request).unwrap();
let partitions = response.get_partitionId().to_vec();
(alive_id, partitions)
}
pub struct GaiaService<V, VI, E, EI>
where
V: Vertex + 'static,
VI: Iterator<Item = V> + Send + 'static,
E: Edge + 'static,
EI: Iterator<Item = E> + Send + 'static,
{
store_config: Arc<StoreConfig>,
graph: Arc<dyn GlobalGraphQuery<V = V, E = E, VI = VI, EI = EI>>,
partition_manager: Arc<dyn GraphPartitionManager>,
// mapping of partition id -> worker id
partition_worker_mapping: Arc<RwLock<Option<HashMap<u32, u32>>>>,
// mapping of worker id -> partition list | run_main | identifier_name |
conn.go | out.
func (c *Conn) SetReadDeadline(t time.Time) error {
return c.conn.SetReadDeadline(t)
}
// SetWriteDeadline sets the write deadline on the underlying connection.
// A zero value for t means Write will not time out.
// After a Write has timed out, the Noise state is corrupt and all future writes will return the same error.
func (c *Conn) SetWriteDeadline(t time.Time) error {
return c.conn.SetWriteDeadline(t)
}
// Write writes data to the connection.
func (c *Conn) Write(b []byte) (int, error) {
//
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A server should not write on one-way patterns")
}
// Make sure to go through the handshake first
if err := c.Handshake(); err != nil {
return 0, err
}
// Lock the write socket
c.outLock.Lock()
defer c.outLock.Unlock()
// process the data in a loop
var n int
data := b
for len(data) > 0 {
// fragment the data
m := len(data)
if m > MaxMsgLen {
m = MaxMsgLen
}
// Encrypt
ciphertext := c.out.Encrypt(nil, nil, data[:m])
// header (length)
length := []byte{byte(len(ciphertext) >> 8), byte(len(ciphertext) % 256)}
// Send data
_, err := c.conn.Write(append(length, ciphertext...))
if err != nil {
return n, err
}
n += m
data = data[m:]
}
return n, nil
}
// Read can be made to time out and return a net.Error with Timeout() == true
// after a fixed time limit; see SetDeadline and SetReadDeadline.
func (c *Conn) Read(b []byte) (int, error) {
var err error
// Make sure to go through the handshake first
if err = c.Handshake(); err != nil {
return 0, err
}
// Put this after Handshake, in case people were calling
// Read(nil) for the side effect of the Handshake.
if len(b) == 0 {
return 0, err
}
// If this is a one-way pattern, do some checks
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A client should not read on one-way patterns")
}
// Lock the read socket
c.inLock.Lock()
defer c.inLock.Unlock()
// read whatever there is to read in the buffer
readSoFar := 0
if len(c.inputBuffer) > 0 {
copy(b, c.inputBuffer)
if len(c.inputBuffer) >= len(b) {
c.inputBuffer = c.inputBuffer[len(b):]
return len(b), nil
}
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
}
// read header from socket
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return 0, err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return 2, errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
// read noise message from socket
noiseMessage, err := readBytes(c.conn, length)
if err != nil {
return 0, err
}
// decrypt
plaintext, err := c.in.Decrypt(nil, nil, noiseMessage)
if err != nil {
return 0, err
}
// append to the input buffer
c.inputBuffer = append(c.inputBuffer, plaintext...)
// read whatever we can read
rest := len(b) - readSoFar
copy(b[readSoFar:], c.inputBuffer)
if len(c.inputBuffer) >= rest {
c.inputBuffer = c.inputBuffer[rest:]
return len(b), nil
}
// we haven't filled the buffer
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
return readSoFar, nil
}
// Close closes the connection.
func (c *Conn) Close() error {
return c.conn.Close()
}
// Noise-related functions
// Handshake runs the client or server handshake protocol if
// it has not yet been run.
// Most uses of this package need not call Handshake explicitly: | // the first Read or Write will call it automatically.
func (c *Conn) Handshake() (err error) {
c.handshakeMutex.Lock()
defer c.handshakeMutex.Unlock()
if c.handshakeComplete {
return nil
}
var remoteKeyPair *DHKey
if c.config.PeerStatic != nil {
if len(c.config.PeerStatic) != 32 {
return errors.New("noise: the provided remote key is not 32-byte")
}
remoteKeyPair = &DHKey{}
copy(remoteKeyPair.Public[:], c.config.PeerStatic)
}
c.hs, err = NewHandshakeState(*c.config)
if err != nil {
return err
}
// start handshake
var c1, c2 *CipherState
var state bool
var msg []byte
state = c.isClient
for _ = range c.config.Pattern.Messages {
if state {
msg, c1, c2, err = c.hs.WriteMessage(nil, nil)
if err != nil {
return err
}
// header (length)
length := []byte{byte(len(msg) >> 8), byte(len(msg) % 256)}
// write
_, err = c.conn.Write(append(length, msg...))
if err != nil {
return err
}
} else {
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
msg, err = readBytes(c.conn, length)
if err != nil {
return err
}
_, c1, c2, err = c.hs.ReadMessage(nil, msg)
if err != nil {
return err
}
}
state = !state
}
if c.isClient {
c.out, c.in = c1, c2
} else {
c.out, c.in = c2, c1
}
c.handshakeComplete = true
return nil
}
// IsRemoteAuthenticated can be used to check if the remote peer has been
// properly authenticated. It serves no real purpose for the moment as the
// handshake will not go through if a peer is not properly authenticated in
// patterns where the peer needs to be authenticated.
func (c *Conn) IsRemoteAuthenticated() bool {
return c.isRemoteAuthenticated
}
// RemoteKey returns the static key of the remote peer.
// It is useful in case the static key is only transmitted during the handshake.
func (c *Conn) RemoteKey() ([]byte, error) {
if !c.handshakeComplete {
return nil, errors.New("handshake not completed")
}
return c.hs.rs, nil
}
// Server returns a new Noise server side connection
// using net.Conn as the underlying transport.
// The configuration config must be non-nil and must include
// at least one certificate or else set GetCertificate.
func Server(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: false}
}
// Client returns a new Noise client side connection
// using conn as the underlying transport.
// The config cannot be nil: users must set either ServerName or
// InsecureSkipVerify in the config.
func Client(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: true}
}
// A Listener implements a network Listener (net.Listener) for Noise connections.
type Listener struct {
net.Listener
config *Config
}
// Accept waits for and returns the next incoming Noise connection.
// The returned connection is of type *Conn.
func (l *Listener) Accept() (net.Conn, error) {
c, err := l.Listener.Accept()
if err != nil {
return &Conn{}, err
}
return Server(c, l.config), nil
}
// Close closes the listener.
// Any blocked Accept operations will be unblocked and return errors.
func (l *Listener) Close() error {
return l.Listener.Close()
}
// Addr returns the listener's network address.
func (l *Listener) Addr() net.Addr {
return l.Listener.Addr()
}
// Listen creates a Noise Listener accepting connections on the
// given network address using net.Listen.
// The configuration config must be non-nil.
func Listen(network, laddr string, config *Config) (net.Listener, error) {
if config == nil {
return &Listener{}, errors.New("Noise: no Config set")
}
l, err := net.Listen(network, laddr)
if err != nil {
return &Listener{}, err
}
noiseListener := &Listener{}
noiseListener.Listener = l
noise | random_line_split |
|
conn.go | .
func (c *Conn) SetReadDeadline(t time.Time) error {
return c.conn.SetReadDeadline(t)
}
// SetWriteDeadline sets the write deadline on the underlying connection.
// A zero value for t means Write will not time out.
// After a Write has timed out, the Noise state is corrupt and all future writes will return the same error.
func (c *Conn) SetWriteDeadline(t time.Time) error {
return c.conn.SetWriteDeadline(t)
}
// Write writes data to the connection.
func (c *Conn) Write(b []byte) (int, error) {
//
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A server should not write on one-way patterns")
}
// Make sure to go through the handshake first
if err := c.Handshake(); err != nil {
return 0, err
}
// Lock the write socket
c.outLock.Lock()
defer c.outLock.Unlock()
// process the data in a loop
var n int
data := b
for len(data) > 0 {
// fragment the data
m := len(data)
if m > MaxMsgLen {
m = MaxMsgLen
}
// Encrypt
ciphertext := c.out.Encrypt(nil, nil, data[:m])
// header (length)
length := []byte{byte(len(ciphertext) >> 8), byte(len(ciphertext) % 256)}
// Send data
_, err := c.conn.Write(append(length, ciphertext...))
if err != nil {
return n, err
}
n += m
data = data[m:]
}
return n, nil
}
// Read can be made to time out and return a net.Error with Timeout() == true
// after a fixed time limit; see SetDeadline and SetReadDeadline.
func (c *Conn) Read(b []byte) (int, error) {
var err error
// Make sure to go through the handshake first
if err = c.Handshake(); err != nil {
return 0, err
}
// Put this after Handshake, in case people were calling
// Read(nil) for the side effect of the Handshake.
if len(b) == 0 {
return 0, err
}
// If this is a one-way pattern, do some checks
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A client should not read on one-way patterns")
}
// Lock the read socket
c.inLock.Lock()
defer c.inLock.Unlock()
// read whatever there is to read in the buffer
readSoFar := 0
if len(c.inputBuffer) > 0 {
copy(b, c.inputBuffer)
if len(c.inputBuffer) >= len(b) {
c.inputBuffer = c.inputBuffer[len(b):]
return len(b), nil
}
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
}
// read header from socket
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return 0, err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return 2, errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
// read noise message from socket
noiseMessage, err := readBytes(c.conn, length)
if err != nil {
return 0, err
}
// decrypt
plaintext, err := c.in.Decrypt(nil, nil, noiseMessage)
if err != nil {
return 0, err
}
// append to the input buffer
c.inputBuffer = append(c.inputBuffer, plaintext...)
// read whatever we can read
rest := len(b) - readSoFar
copy(b[readSoFar:], c.inputBuffer)
if len(c.inputBuffer) >= rest {
c.inputBuffer = c.inputBuffer[rest:]
return len(b), nil
}
// we haven't filled the buffer
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
return readSoFar, nil
}
// Close closes the connection.
func (c *Conn) Close() error {
return c.conn.Close()
}
// Noise-related functions
// Handshake runs the client or server handshake protocol if
// it has not yet been run.
// Most uses of this package need not call Handshake explicitly:
// the first Read or Write will call it automatically.
func (c *Conn) Handshake() (err error) {
c.handshakeMutex.Lock()
defer c.handshakeMutex.Unlock()
if c.handshakeComplete {
return nil
}
var remoteKeyPair *DHKey
if c.config.PeerStatic != nil {
if len(c.config.PeerStatic) != 32 {
return errors.New("noise: the provided remote key is not 32-byte")
}
remoteKeyPair = &DHKey{}
copy(remoteKeyPair.Public[:], c.config.PeerStatic)
}
c.hs, err = NewHandshakeState(*c.config)
if err != nil {
return err
}
// start handshake
var c1, c2 *CipherState
var state bool
var msg []byte
state = c.isClient
for _ = range c.config.Pattern.Messages {
if state {
msg, c1, c2, err = c.hs.WriteMessage(nil, nil)
if err != nil {
return err
}
// header (length)
length := []byte{byte(len(msg) >> 8), byte(len(msg) % 256)}
// write
_, err = c.conn.Write(append(length, msg...))
if err != nil {
return err
}
} else {
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
msg, err = readBytes(c.conn, length)
if err != nil {
return err
}
_, c1, c2, err = c.hs.ReadMessage(nil, msg)
if err != nil {
return err
}
}
state = !state
}
if c.isClient {
c.out, c.in = c1, c2
} else {
c.out, c.in = c2, c1
}
c.handshakeComplete = true
return nil
}
// IsRemoteAuthenticated can be used to check if the remote peer has been
// properly authenticated. It serves no real purpose for the moment as the
// handshake will not go through if a peer is not properly authenticated in
// patterns where the peer needs to be authenticated.
func (c *Conn) | () bool {
return c.isRemoteAuthenticated
}
// RemoteKey returns the static key of the remote peer.
// It is useful in case the static key is only transmitted during the handshake.
func (c *Conn) RemoteKey() ([]byte, error) {
if !c.handshakeComplete {
return nil, errors.New("handshake not completed")
}
return c.hs.rs, nil
}
// Server returns a new Noise server side connection
// using net.Conn as the underlying transport.
// The configuration config must be non-nil and must include
// at least one certificate or else set GetCertificate.
func Server(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: false}
}
// Client returns a new Noise client side connection
// using conn as the underlying transport.
// The config cannot be nil: users must set either ServerName or
// InsecureSkipVerify in the config.
func Client(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: true}
}
// A Listener implements a network Listener (net.Listener) for Noise connections.
type Listener struct {
net.Listener
config *Config
}
// Accept waits for and returns the next incoming Noise connection.
// The returned connection is of type *Conn.
func (l *Listener) Accept() (net.Conn, error) {
c, err := l.Listener.Accept()
if err != nil {
return &Conn{}, err
}
return Server(c, l.config), nil
}
// Close closes the listener.
// Any blocked Accept operations will be unblocked and return errors.
func (l *Listener) Close() error {
return l.Listener.Close()
}
// Addr returns the listener's network address.
func (l *Listener) Addr() net.Addr {
return l.Listener.Addr()
}
// Listen creates a Noise Listener accepting connections on the
// given network address using net.Listen.
// The configuration config must be non-nil.
func Listen(network, laddr string, config *Config) (net.Listener, error) {
if config == nil {
return &Listener{}, errors.New("Noise: no Config set")
}
l, err := net.Listen(network, laddr)
if err != nil {
return &Listener{}, err
}
noiseListener := &Listener{}
noiseListener.Listener = l
noise | IsRemoteAuthenticated | identifier_name |
conn.go | .
func (c *Conn) SetReadDeadline(t time.Time) error {
return c.conn.SetReadDeadline(t)
}
// SetWriteDeadline sets the write deadline on the underlying connection.
// A zero value for t means Write will not time out.
// After a Write has timed out, the Noise state is corrupt and all future writes will return the same error.
func (c *Conn) SetWriteDeadline(t time.Time) error {
return c.conn.SetWriteDeadline(t)
}
// Write writes data to the connection.
func (c *Conn) Write(b []byte) (int, error) {
//
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A server should not write on one-way patterns")
}
// Make sure to go through the handshake first
if err := c.Handshake(); err != nil {
return 0, err
}
// Lock the write socket
c.outLock.Lock()
defer c.outLock.Unlock()
// process the data in a loop
var n int
data := b
for len(data) > 0 {
// fragment the data
m := len(data)
if m > MaxMsgLen {
m = MaxMsgLen
}
// Encrypt
ciphertext := c.out.Encrypt(nil, nil, data[:m])
// header (length)
length := []byte{byte(len(ciphertext) >> 8), byte(len(ciphertext) % 256)}
// Send data
_, err := c.conn.Write(append(length, ciphertext...))
if err != nil {
return n, err
}
n += m
data = data[m:]
}
return n, nil
}
// Read can be made to time out and return a net.Error with Timeout() == true
// after a fixed time limit; see SetDeadline and SetReadDeadline.
func (c *Conn) Read(b []byte) (int, error) {
var err error
// Make sure to go through the handshake first
if err = c.Handshake(); err != nil {
return 0, err
}
// Put this after Handshake, in case people were calling
// Read(nil) for the side effect of the Handshake.
if len(b) == 0 {
return 0, err
}
// If this is a one-way pattern, do some checks
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A client should not read on one-way patterns")
}
// Lock the read socket
c.inLock.Lock()
defer c.inLock.Unlock()
// read whatever there is to read in the buffer
readSoFar := 0
if len(c.inputBuffer) > 0 {
copy(b, c.inputBuffer)
if len(c.inputBuffer) >= len(b) {
c.inputBuffer = c.inputBuffer[len(b):]
return len(b), nil
}
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
}
// read header from socket
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return 0, err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return 2, errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
// read noise message from socket
noiseMessage, err := readBytes(c.conn, length)
if err != nil {
return 0, err
}
// decrypt
plaintext, err := c.in.Decrypt(nil, nil, noiseMessage)
if err != nil {
return 0, err
}
// append to the input buffer
c.inputBuffer = append(c.inputBuffer, plaintext...)
// read whatever we can read
rest := len(b) - readSoFar
copy(b[readSoFar:], c.inputBuffer)
if len(c.inputBuffer) >= rest {
c.inputBuffer = c.inputBuffer[rest:]
return len(b), nil
}
// we haven't filled the buffer
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
return readSoFar, nil
}
// Close closes the connection.
func (c *Conn) Close() error |
// Noise-related functions
// Handshake runs the client or server handshake protocol if
// it has not yet been run.
// Most uses of this package need not call Handshake explicitly:
// the first Read or Write will call it automatically.
func (c *Conn) Handshake() (err error) {
c.handshakeMutex.Lock()
defer c.handshakeMutex.Unlock()
if c.handshakeComplete {
return nil
}
var remoteKeyPair *DHKey
if c.config.PeerStatic != nil {
if len(c.config.PeerStatic) != 32 {
return errors.New("noise: the provided remote key is not 32-byte")
}
remoteKeyPair = &DHKey{}
copy(remoteKeyPair.Public[:], c.config.PeerStatic)
}
c.hs, err = NewHandshakeState(*c.config)
if err != nil {
return err
}
// start handshake
var c1, c2 *CipherState
var state bool
var msg []byte
state = c.isClient
for _ = range c.config.Pattern.Messages {
if state {
msg, c1, c2, err = c.hs.WriteMessage(nil, nil)
if err != nil {
return err
}
// header (length)
length := []byte{byte(len(msg) >> 8), byte(len(msg) % 256)}
// write
_, err = c.conn.Write(append(length, msg...))
if err != nil {
return err
}
} else {
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
msg, err = readBytes(c.conn, length)
if err != nil {
return err
}
_, c1, c2, err = c.hs.ReadMessage(nil, msg)
if err != nil {
return err
}
}
state = !state
}
if c.isClient {
c.out, c.in = c1, c2
} else {
c.out, c.in = c2, c1
}
c.handshakeComplete = true
return nil
}
// IsRemoteAuthenticated can be used to check if the remote peer has been
// properly authenticated. It serves no real purpose for the moment as the
// handshake will not go through if a peer is not properly authenticated in
// patterns where the peer needs to be authenticated.
func (c *Conn) IsRemoteAuthenticated() bool {
return c.isRemoteAuthenticated
}
// RemoteKey returns the static key of the remote peer.
// It is useful in case the static key is only transmitted during the handshake.
func (c *Conn) RemoteKey() ([]byte, error) {
if !c.handshakeComplete {
return nil, errors.New("handshake not completed")
}
return c.hs.rs, nil
}
// Server returns a new Noise server side connection
// using net.Conn as the underlying transport.
// The configuration config must be non-nil and must include
// at least one certificate or else set GetCertificate.
func Server(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: false}
}
// Client returns a new Noise client side connection
// using conn as the underlying transport.
// The config cannot be nil: users must set either ServerName or
// InsecureSkipVerify in the config.
func Client(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: true}
}
// A Listener implements a network Listener (net.Listener) for Noise connections.
type Listener struct {
net.Listener
config *Config
}
// Accept waits for and returns the next incoming Noise connection.
// The returned connection is of type *Conn.
func (l *Listener) Accept() (net.Conn, error) {
c, err := l.Listener.Accept()
if err != nil {
return &Conn{}, err
}
return Server(c, l.config), nil
}
// Close closes the listener.
// Any blocked Accept operations will be unblocked and return errors.
func (l *Listener) Close() error {
return l.Listener.Close()
}
// Addr returns the listener's network address.
func (l *Listener) Addr() net.Addr {
return l.Listener.Addr()
}
// Listen creates a Noise Listener accepting connections on the
// given network address using net.Listen.
// The configuration config must be non-nil.
func Listen(network, laddr string, config *Config) (net.Listener, error) {
if config == nil {
return &Listener{}, errors.New("Noise: no Config set")
}
l, err := net.Listen(network, laddr)
if err != nil {
return &Listener{}, err
}
noiseListener := &Listener{}
noiseListener.Listener = l
| {
return c.conn.Close()
} | identifier_body |
conn.go | .
func (c *Conn) SetReadDeadline(t time.Time) error {
return c.conn.SetReadDeadline(t)
}
// SetWriteDeadline sets the write deadline on the underlying connection.
// A zero value for t means Write will not time out.
// After a Write has timed out, the Noise state is corrupt and all future writes will return the same error.
func (c *Conn) SetWriteDeadline(t time.Time) error {
return c.conn.SetWriteDeadline(t)
}
// Write writes data to the connection.
func (c *Conn) Write(b []byte) (int, error) {
//
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A server should not write on one-way patterns")
}
// Make sure to go through the handshake first
if err := c.Handshake(); err != nil {
return 0, err
}
// Lock the write socket
c.outLock.Lock()
defer c.outLock.Unlock()
// process the data in a loop
var n int
data := b
for len(data) > 0 {
// fragment the data
m := len(data)
if m > MaxMsgLen {
m = MaxMsgLen
}
// Encrypt
ciphertext := c.out.Encrypt(nil, nil, data[:m])
// header (length)
length := []byte{byte(len(ciphertext) >> 8), byte(len(ciphertext) % 256)}
// Send data
_, err := c.conn.Write(append(length, ciphertext...))
if err != nil {
return n, err
}
n += m
data = data[m:]
}
return n, nil
}
// Read can be made to time out and return a net.Error with Timeout() == true
// after a fixed time limit; see SetDeadline and SetReadDeadline.
func (c *Conn) Read(b []byte) (int, error) {
var err error
// Make sure to go through the handshake first
if err = c.Handshake(); err != nil {
return 0, err
}
// Put this after Handshake, in case people were calling
// Read(nil) for the side effect of the Handshake.
if len(b) == 0 {
return 0, err
}
// If this is a one-way pattern, do some checks
if hp := c.config.Pattern; !c.isClient && len(hp.Messages) < 2 {
return 0, errors.New("A client should not read on one-way patterns")
}
// Lock the read socket
c.inLock.Lock()
defer c.inLock.Unlock()
// read whatever there is to read in the buffer
readSoFar := 0
if len(c.inputBuffer) > 0 {
copy(b, c.inputBuffer)
if len(c.inputBuffer) >= len(b) {
c.inputBuffer = c.inputBuffer[len(b):]
return len(b), nil
}
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
}
// read header from socket
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return 0, err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return 2, errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
// read noise message from socket
noiseMessage, err := readBytes(c.conn, length)
if err != nil {
return 0, err
}
// decrypt
plaintext, err := c.in.Decrypt(nil, nil, noiseMessage)
if err != nil {
return 0, err
}
// append to the input buffer
c.inputBuffer = append(c.inputBuffer, plaintext...)
// read whatever we can read
rest := len(b) - readSoFar
copy(b[readSoFar:], c.inputBuffer)
if len(c.inputBuffer) >= rest {
c.inputBuffer = c.inputBuffer[rest:]
return len(b), nil
}
// we haven't filled the buffer
readSoFar += len(c.inputBuffer)
c.inputBuffer = c.inputBuffer[:0]
return readSoFar, nil
}
// Close closes the connection.
func (c *Conn) Close() error {
return c.conn.Close()
}
// Noise-related functions
// Handshake runs the client or server handshake protocol if
// it has not yet been run.
// Most uses of this package need not call Handshake explicitly:
// the first Read or Write will call it automatically.
func (c *Conn) Handshake() (err error) {
c.handshakeMutex.Lock()
defer c.handshakeMutex.Unlock()
if c.handshakeComplete {
return nil
}
var remoteKeyPair *DHKey
if c.config.PeerStatic != nil {
if len(c.config.PeerStatic) != 32 {
return errors.New("noise: the provided remote key is not 32-byte")
}
remoteKeyPair = &DHKey{}
copy(remoteKeyPair.Public[:], c.config.PeerStatic)
}
c.hs, err = NewHandshakeState(*c.config)
if err != nil {
return err
}
// start handshake
var c1, c2 *CipherState
var state bool
var msg []byte
state = c.isClient
for _ = range c.config.Pattern.Messages {
if state {
msg, c1, c2, err = c.hs.WriteMessage(nil, nil)
if err != nil {
return err
}
// header (length)
length := []byte{byte(len(msg) >> 8), byte(len(msg) % 256)}
// write
_, err = c.conn.Write(append(length, msg...))
if err != nil {
return err
}
} else {
bufHeader, err := readBytes(c.conn, 2)
if err != nil {
return err
}
length := (int(bufHeader[0]) << 8) | int(bufHeader[1])
if length > MaxMsgLen {
return errors.New("Noise: Noise message received exceeds NoiseMessageLength")
}
msg, err = readBytes(c.conn, length)
if err != nil |
_, c1, c2, err = c.hs.ReadMessage(nil, msg)
if err != nil {
return err
}
}
state = !state
}
if c.isClient {
c.out, c.in = c1, c2
} else {
c.out, c.in = c2, c1
}
c.handshakeComplete = true
return nil
}
// IsRemoteAuthenticated can be used to check if the remote peer has been
// properly authenticated. It serves no real purpose for the moment as the
// handshake will not go through if a peer is not properly authenticated in
// patterns where the peer needs to be authenticated.
func (c *Conn) IsRemoteAuthenticated() bool {
return c.isRemoteAuthenticated
}
// RemoteKey returns the static key of the remote peer.
// It is useful in case the static key is only transmitted during the handshake.
func (c *Conn) RemoteKey() ([]byte, error) {
if !c.handshakeComplete {
return nil, errors.New("handshake not completed")
}
return c.hs.rs, nil
}
// Server returns a new Noise server side connection
// using net.Conn as the underlying transport.
// The configuration config must be non-nil and must include
// at least one certificate or else set GetCertificate.
func Server(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: false}
}
// Client returns a new Noise client side connection
// using conn as the underlying transport.
// The config cannot be nil: users must set either ServerName or
// InsecureSkipVerify in the config.
func Client(conn net.Conn, config *Config) *Conn {
return &Conn{conn: conn, config: config, isClient: true}
}
// A Listener implements a network Listener (net.Listener) for Noise connections.
type Listener struct {
net.Listener
config *Config
}
// Accept waits for and returns the next incoming Noise connection.
// The returned connection is of type *Conn.
func (l *Listener) Accept() (net.Conn, error) {
c, err := l.Listener.Accept()
if err != nil {
return &Conn{}, err
}
return Server(c, l.config), nil
}
// Close closes the listener.
// Any blocked Accept operations will be unblocked and return errors.
func (l *Listener) Close() error {
return l.Listener.Close()
}
// Addr returns the listener's network address.
func (l *Listener) Addr() net.Addr {
return l.Listener.Addr()
}
// Listen creates a Noise Listener accepting connections on the
// given network address using net.Listen.
// The configuration config must be non-nil.
func Listen(network, laddr string, config *Config) (net.Listener, error) {
if config == nil {
return &Listener{}, errors.New("Noise: no Config set")
}
l, err := net.Listen(network, laddr)
if err != nil {
return &Listener{}, err
}
noiseListener := &Listener{}
noiseListener.Listener = l
| {
return err
} | conditional_block |
barnacle_vcf.py | +base2
return alt1, alt2
elif breakpoint1.endswith('(down)') and breakpoint2.endswith('(down)'):
alt1 = base1+']'+chrom2+':'+str(pos2)+']'
alt2 = base2+']'+chrom1+':'+str(pos1)+']'
return alt1, alt2
#one breakpoint is at the start of the contig region and other breakpoint is at the end
if breakpoint1.endswith('(up)'):
alt1 = ']'+chrom2+':'+pos2+']'+base1
alt2 = base2+'['+chrom1+':'+pos1+'['
else:
alt1 = base1+'['+chrom2+':'+pos2+'['
alt2 = ']'+chrom1+':'+pos1+']'+base2
return alt1, alt2
def get_QUAL():
return '.'
def get_FILT():
return 'PASS'
def get_INFO(member, id1, id2):
overlap = str(member.meta_fields['ctg_overlap'])
svtype = 'FND'
dp = int(member.avg_read_to_ctg_unique)
if int(overlap) > 0:
return 'SVTYPE='+svtype+';MATEID='+str(id2)+'b;CIPOS=0,'+overlap+';SR='+str(dp)+';CTG=', svtype+';MATEID='+str(id1)+'a;CIPOS=0,'+overlap+';SR='+str(dp)+';CTG='
else:
return 'SVTYPE='+svtype+';MATEID='+str(id2)+'b;SR='+str(dp)+';CTG=', svtype+';MATEID='+str(id1)+'a;SR='+str(dp)+';CTG='
#header output method
def write_header(GIN_user, GIN_pass, LIMS_user, LIMS_pass, refseq_flag, library, filetype_flag, out_file, contig=None):
#file format
out_file.write('##fileformat=VCFv4.1\n')
#file date
out_file.write('##filedate='+time.strftime("%Y%m%d")+'\n')
#tcga version
out_file.write('##tcgaversion=1.0\n')
#genome reference; need to use URL
if refseq_flag == 'hg19':
out_file.write('##reference=<ID=hg19,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg19/1000genomes/bwa_ind/genome/\n')
elif refseq_flag == 'hg18':
out_file.write('##reference=<ID=hg18,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg18/bwa_ind/genome/tcga_ref/>\n')
elif refseq_flag == 'mm9':
out_file.write('##reference=<ID=mm9,Source=/projects/transabyss/trans-ABySS/annotations/mm9/201107/genome.fa>\n')
#contig assembly tags, need to use URL
out_file.write('##assembly='+contig+'\n')
#center
out_file.write('##center="BCGSC"\n')
#phasing
out_file.write('##phasing=none\n')
info_format = {
'svtype':'##INFO=<ID=SVTYPE,Number=1,Type=String,Description="Type of structural variant">\n',
'mateid':'##INFO=<ID=MATEID,Number=1,Type=String,Description="ID of mate breakends">\n',
'event':'##INFO=<ID=EVENT,Number=1,Type=String,Description="ID of breakend event">\n',
'cipos':'##INFO=<ID=CIPOS,Number=2,Type=Integer,Description="Confidence interval around POS for imprecise variants">\n',
'svlen':'##INFO=<ID=SVLEN,Number=1,Type=Integer,Description="Difference in length between REF and ALT alleles">\n',
'end':'##INFO=<ID=END,Number=1,Type=Integer,Description="End position of the variant described in this record">\n',
'inv':'##ALT=<ID=INV,Description="Inversion">\n',
'del':'##ALT=<ID=DEL,Description="Deletion">\n',
'duptan':'##ALT=<ID=DUP:TANDEM,Description="Tandem Duplication">\n',
'sr':'##INFO=<ID=SR,Number=1,Type=Integer,Description="Spanning reads">\n',
'dp':'##INFO=<ID=DP,Number=1,Type=Integer,Description="Read depth">\n',
'CTG':'##INFO=<ID=CTG,Number=.,Type=String,Description="Contig ID">\n'
}
fusion = ['svtype', 'mateid', 'cipos', 'CTG', 'sr']
duplication = ['svtype', 'duptan', 'CTG', 'sr']
if filetype_flag == 'fusion':
for item in fusion:
if item in info_format:
out_file.write(info_format[item])
elif filetype_flag == 'itd' or filetype_flag == 'ptd':
for item in duplication:
if item in info_format:
out_file.write(info_format[item])
sample_info = commands.getoutput("python get_tcga_sample_info.py --username "+GIN_user+" --password "+GIN_pass+" --LIMS_user "+LIMS_user+" --LIMS_pass "+LIMS_pass+" --library "+library)
#sample info
sample_info = sample_info.split(',')
patient = sample_info[0]
sample_id = sample_info[1]
sample_desc = sample_info[2]
platform = sample_info[3]
accession = sample_info[4]
out_file.write('##SAMPLE=<ID='+sample_id+',Individual='+patient+',Description="'+sample_desc+'",Platform='+platform+',Accession='+accession+'>\n')
#pedigree
out_file.write('##PEDIGREE=<Name_0='+sample_id+'>\n')
fields_line = '#CHROM\t'+'POS\t'+'ID\t'+'REF\t'+'ALT\t'+'QUAL\t'+'FILTER\t'+'INFO\n'
out_file.write(fields_line)
def create_fusion_dict(output_dir, in_file, refseq, sequence_dict):
fusion_dict = {}
groupParser = CandidateGroupParserCls(in_file)
id1, id2 = 1, 1
key1, key2 = 1, 2
ctg_dir = output_dir.strip('vcf')
contigfa = open(ctg_dir+'fa', "w")
for group in groupParser:
member = group.members[0]
chrom1, chrom2 = get_CHROM(member)
pos1, pos2 = get_POS(member)
ref1, ref2 = get_REF(member, refseq)
alt1, alt2 = get_ALT(member, refseq)
qual = get_QUAL()
filt = get_FILT()
info1, info2 = get_INFO(member, id1, id2)
fusion1 = chrom1+'\t'+pos1+'\t'+str(id1)+'a'+'\t'+ref1+'\t'+alt1+'\t'+qual+'\t'+filt+'\t'+info1
fusion2 = chrom2+'\t'+pos2+'\t'+str(id2)+'b'+'\t'+ref2+'\t'+alt2+'\t'+qual+'\t'+filt+'\t'+info2
counter = 0
for m in group.members:
contig = m.contig_info.ToString()
contig = contig.replace(':', '_')
contig = contig.partition('(')[0]
if counter > 0:
fusion1 += ','+contig
fusion2 += ','+contig
else:
fusion1 += contig
fusion2 += contig
sequence = sequence_dict['>'+contig]
contigfa.write('>'+contig+'\n'+sequence+'\n')
counter += 1
fusion_dict[key1] = fusion1+'\n'
fusion_dict[key2] = fusion2+'\n'
id1 += 1
id2 += 1
key1 += 2
key2 += 2
return fusion_dict
def dup_CHROM(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
chrom = breakpoint[0]
chrom = chrom[3:]
return chrom
def dup_POS(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
position = breakpoint[2]
position = position.partition('(')[0]
return position
def | (member, refseq):
pos = dup_POS(member)
chrom = dup_CHROM(member)
seq = refseq.GetSequence(chrom, int(pos), int(pos))
return seq
def dup_ALT():
alt = '<DUP:TANDEM>'
return alt
def dup_INFO(member):
pos = int(dup_POS(member))
svtype = 'FND'
length | dup_REF | identifier_name |
barnacle_vcf.py | str(dp)+';CTG='
#header output method
def write_header(GIN_user, GIN_pass, LIMS_user, LIMS_pass, refseq_flag, library, filetype_flag, out_file, contig=None):
#file format
out_file.write('##fileformat=VCFv4.1\n')
#file date
out_file.write('##filedate='+time.strftime("%Y%m%d")+'\n')
#tcga version
out_file.write('##tcgaversion=1.0\n')
#genome reference; need to use URL
if refseq_flag == 'hg19':
out_file.write('##reference=<ID=hg19,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg19/1000genomes/bwa_ind/genome/\n')
elif refseq_flag == 'hg18':
out_file.write('##reference=<ID=hg18,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg18/bwa_ind/genome/tcga_ref/>\n')
elif refseq_flag == 'mm9':
out_file.write('##reference=<ID=mm9,Source=/projects/transabyss/trans-ABySS/annotations/mm9/201107/genome.fa>\n')
#contig assembly tags, need to use URL
out_file.write('##assembly='+contig+'\n')
#center
out_file.write('##center="BCGSC"\n')
#phasing
out_file.write('##phasing=none\n')
info_format = {
'svtype':'##INFO=<ID=SVTYPE,Number=1,Type=String,Description="Type of structural variant">\n',
'mateid':'##INFO=<ID=MATEID,Number=1,Type=String,Description="ID of mate breakends">\n',
'event':'##INFO=<ID=EVENT,Number=1,Type=String,Description="ID of breakend event">\n',
'cipos':'##INFO=<ID=CIPOS,Number=2,Type=Integer,Description="Confidence interval around POS for imprecise variants">\n',
'svlen':'##INFO=<ID=SVLEN,Number=1,Type=Integer,Description="Difference in length between REF and ALT alleles">\n',
'end':'##INFO=<ID=END,Number=1,Type=Integer,Description="End position of the variant described in this record">\n',
'inv':'##ALT=<ID=INV,Description="Inversion">\n',
'del':'##ALT=<ID=DEL,Description="Deletion">\n',
'duptan':'##ALT=<ID=DUP:TANDEM,Description="Tandem Duplication">\n',
'sr':'##INFO=<ID=SR,Number=1,Type=Integer,Description="Spanning reads">\n',
'dp':'##INFO=<ID=DP,Number=1,Type=Integer,Description="Read depth">\n',
'CTG':'##INFO=<ID=CTG,Number=.,Type=String,Description="Contig ID">\n'
}
fusion = ['svtype', 'mateid', 'cipos', 'CTG', 'sr']
duplication = ['svtype', 'duptan', 'CTG', 'sr']
if filetype_flag == 'fusion':
for item in fusion:
if item in info_format:
out_file.write(info_format[item])
elif filetype_flag == 'itd' or filetype_flag == 'ptd':
for item in duplication:
if item in info_format:
out_file.write(info_format[item])
sample_info = commands.getoutput("python get_tcga_sample_info.py --username "+GIN_user+" --password "+GIN_pass+" --LIMS_user "+LIMS_user+" --LIMS_pass "+LIMS_pass+" --library "+library)
#sample info
sample_info = sample_info.split(',')
patient = sample_info[0]
sample_id = sample_info[1]
sample_desc = sample_info[2]
platform = sample_info[3]
accession = sample_info[4]
out_file.write('##SAMPLE=<ID='+sample_id+',Individual='+patient+',Description="'+sample_desc+'",Platform='+platform+',Accession='+accession+'>\n')
#pedigree
out_file.write('##PEDIGREE=<Name_0='+sample_id+'>\n')
fields_line = '#CHROM\t'+'POS\t'+'ID\t'+'REF\t'+'ALT\t'+'QUAL\t'+'FILTER\t'+'INFO\n'
out_file.write(fields_line)
def create_fusion_dict(output_dir, in_file, refseq, sequence_dict):
fusion_dict = {}
groupParser = CandidateGroupParserCls(in_file)
id1, id2 = 1, 1
key1, key2 = 1, 2
ctg_dir = output_dir.strip('vcf')
contigfa = open(ctg_dir+'fa', "w")
for group in groupParser:
member = group.members[0]
chrom1, chrom2 = get_CHROM(member)
pos1, pos2 = get_POS(member)
ref1, ref2 = get_REF(member, refseq)
alt1, alt2 = get_ALT(member, refseq)
qual = get_QUAL()
filt = get_FILT()
info1, info2 = get_INFO(member, id1, id2)
fusion1 = chrom1+'\t'+pos1+'\t'+str(id1)+'a'+'\t'+ref1+'\t'+alt1+'\t'+qual+'\t'+filt+'\t'+info1
fusion2 = chrom2+'\t'+pos2+'\t'+str(id2)+'b'+'\t'+ref2+'\t'+alt2+'\t'+qual+'\t'+filt+'\t'+info2
counter = 0
for m in group.members:
contig = m.contig_info.ToString()
contig = contig.replace(':', '_')
contig = contig.partition('(')[0]
if counter > 0:
fusion1 += ','+contig
fusion2 += ','+contig
else:
fusion1 += contig
fusion2 += contig
sequence = sequence_dict['>'+contig]
contigfa.write('>'+contig+'\n'+sequence+'\n')
counter += 1
fusion_dict[key1] = fusion1+'\n'
fusion_dict[key2] = fusion2+'\n'
id1 += 1
id2 += 1
key1 += 2
key2 += 2
return fusion_dict
def dup_CHROM(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
chrom = breakpoint[0]
chrom = chrom[3:]
return chrom
def dup_POS(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
position = breakpoint[2]
position = position.partition('(')[0]
return position
def dup_REF(member, refseq):
pos = dup_POS(member)
chrom = dup_CHROM(member)
seq = refseq.GetSequence(chrom, int(pos), int(pos))
return seq
def dup_ALT():
alt = '<DUP:TANDEM>'
return alt
def dup_INFO(member):
pos = int(dup_POS(member))
svtype = 'FND'
length = len(member.event_seq)
end = pos + length - 1
info = 'SVTYPE='+svtype+';END='+str(end)
return info
def ptd_POS(member):
breakpoint1 = member.breakpointA.ToString()
breakpoint2 = member.breakpointB.ToString()
if breakpoint1.endswith('(down)'):
end = breakpoint2
start = breakpoint1.partition(':')[2]
else:
end = breakpoint1
start = breakpoint2.partition(':')[2]
start = start.partition('(')[0]
return start
def ptd_INFO(member):
breakpoint1 = member.breakpointA.ToString()
breakpoint2 = member.breakpointB.ToString()
if breakpoint1.endswith('(down)'):
end = breakpoint2
start = breakpoint1.partition(':')[2]
else:
end = breakpoint1
start = breakpoint2.partition(':')[2]
start = start.partition('(')[0]
endpos = end.partition(':')[2]
endpos = endpos.partition('(')[0]
svtype = 'FND'
info = 'SVTYPE='+svtype+';END='+endpos
return info
def create_dup_dict(in_file, refseq, filetype_flag):
dup_dict = {}
groupParser = CandidateGroupParserCls(in_file)
id1 = 1
for group in groupParser:
member = group.members[0]
chrom = dup_CHROM(member)
qual = get_QUAL()
filt = get_FILT()
if filetype_flag == 'itd':
pos = dup_POS(member)
else:
pos = ptd_POS(member)
ref = dup_REF(member, refseq)
alt = dup_ALT()
if filetype_flag == 'itd':
info = dup_INFO(member)
else:
| info = ptd_INFO(member) | conditional_block |
|
barnacle_vcf.py | ['+base2
return alt1, alt2
elif breakpoint1.endswith('(down)') and breakpoint2.endswith('(down)'):
alt1 = base1+']'+chrom2+':'+str(pos2)+']'
alt2 = base2+']'+chrom1+':'+str(pos1)+']'
return alt1, alt2
#one breakpoint is at the start of the contig region and other breakpoint is at the end
if breakpoint1.endswith('(up)'):
alt1 = ']'+chrom2+':'+pos2+']'+base1
alt2 = base2+'['+chrom1+':'+pos1+'['
else:
alt1 = base1+'['+chrom2+':'+pos2+'['
alt2 = ']'+chrom1+':'+pos1+']'+base2
return alt1, alt2
def get_QUAL():
return '.'
def get_FILT():
return 'PASS'
def get_INFO(member, id1, id2):
overlap = str(member.meta_fields['ctg_overlap'])
svtype = 'FND'
dp = int(member.avg_read_to_ctg_unique)
if int(overlap) > 0:
return 'SVTYPE='+svtype+';MATEID='+str(id2)+'b;CIPOS=0,'+overlap+';SR='+str(dp)+';CTG=', svtype+';MATEID='+str(id1)+'a;CIPOS=0,'+overlap+';SR='+str(dp)+';CTG='
else:
return 'SVTYPE='+svtype+';MATEID='+str(id2)+'b;SR='+str(dp)+';CTG=', svtype+';MATEID='+str(id1)+'a;SR='+str(dp)+';CTG='
#header output method
def write_header(GIN_user, GIN_pass, LIMS_user, LIMS_pass, refseq_flag, library, filetype_flag, out_file, contig=None):
#file format
out_file.write('##fileformat=VCFv4.1\n')
#file date
out_file.write('##filedate='+time.strftime("%Y%m%d")+'\n')
#tcga version
out_file.write('##tcgaversion=1.0\n')
#genome reference; need to use URL
if refseq_flag == 'hg19':
out_file.write('##reference=<ID=hg19,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg19/1000genomes/bwa_ind/genome/\n')
elif refseq_flag == 'hg18':
out_file.write('##reference=<ID=hg18,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg18/bwa_ind/genome/tcga_ref/>\n')
elif refseq_flag == 'mm9':
out_file.write('##reference=<ID=mm9,Source=/projects/transabyss/trans-ABySS/annotations/mm9/201107/genome.fa>\n')
#contig assembly tags, need to use URL
out_file.write('##assembly='+contig+'\n')
#center
out_file.write('##center="BCGSC"\n')
#phasing
out_file.write('##phasing=none\n')
info_format = {
'svtype':'##INFO=<ID=SVTYPE,Number=1,Type=String,Description="Type of structural variant">\n',
'mateid':'##INFO=<ID=MATEID,Number=1,Type=String,Description="ID of mate breakends">\n',
'event':'##INFO=<ID=EVENT,Number=1,Type=String,Description="ID of breakend event">\n',
'cipos':'##INFO=<ID=CIPOS,Number=2,Type=Integer,Description="Confidence interval around POS for imprecise variants">\n',
'svlen':'##INFO=<ID=SVLEN,Number=1,Type=Integer,Description="Difference in length between REF and ALT alleles">\n',
'end':'##INFO=<ID=END,Number=1,Type=Integer,Description="End position of the variant described in this record">\n',
'inv':'##ALT=<ID=INV,Description="Inversion">\n',
'del':'##ALT=<ID=DEL,Description="Deletion">\n',
'duptan':'##ALT=<ID=DUP:TANDEM,Description="Tandem Duplication">\n',
'sr':'##INFO=<ID=SR,Number=1,Type=Integer,Description="Spanning reads">\n',
'dp':'##INFO=<ID=DP,Number=1,Type=Integer,Description="Read depth">\n',
'CTG':'##INFO=<ID=CTG,Number=.,Type=String,Description="Contig ID">\n'
}
fusion = ['svtype', 'mateid', 'cipos', 'CTG', 'sr']
duplication = ['svtype', 'duptan', 'CTG', 'sr']
if filetype_flag == 'fusion':
for item in fusion:
if item in info_format:
out_file.write(info_format[item])
elif filetype_flag == 'itd' or filetype_flag == 'ptd':
for item in duplication:
if item in info_format:
out_file.write(info_format[item])
sample_info = commands.getoutput("python get_tcga_sample_info.py --username "+GIN_user+" --password "+GIN_pass+" --LIMS_user "+LIMS_user+" --LIMS_pass "+LIMS_pass+" --library "+library)
#sample info
sample_info = sample_info.split(',')
patient = sample_info[0]
sample_id = sample_info[1]
sample_desc = sample_info[2]
platform = sample_info[3]
accession = sample_info[4]
out_file.write('##SAMPLE=<ID='+sample_id+',Individual='+patient+',Description="'+sample_desc+'",Platform='+platform+',Accession='+accession+'>\n')
#pedigree
out_file.write('##PEDIGREE=<Name_0='+sample_id+'>\n')
fields_line = '#CHROM\t'+'POS\t'+'ID\t'+'REF\t'+'ALT\t'+'QUAL\t'+'FILTER\t'+'INFO\n'
out_file.write(fields_line)
def create_fusion_dict(output_dir, in_file, refseq, sequence_dict):
fusion_dict = {}
groupParser = CandidateGroupParserCls(in_file)
id1, id2 = 1, 1
key1, key2 = 1, 2
ctg_dir = output_dir.strip('vcf')
contigfa = open(ctg_dir+'fa', "w")
for group in groupParser:
member = group.members[0]
chrom1, chrom2 = get_CHROM(member)
pos1, pos2 = get_POS(member)
ref1, ref2 = get_REF(member, refseq)
alt1, alt2 = get_ALT(member, refseq)
qual = get_QUAL()
filt = get_FILT()
info1, info2 = get_INFO(member, id1, id2)
fusion1 = chrom1+'\t'+pos1+'\t'+str(id1)+'a'+'\t'+ref1+'\t'+alt1+'\t'+qual+'\t'+filt+'\t'+info1
fusion2 = chrom2+'\t'+pos2+'\t'+str(id2)+'b'+'\t'+ref2+'\t'+alt2+'\t'+qual+'\t'+filt+'\t'+info2
counter = 0
for m in group.members:
contig = m.contig_info.ToString()
contig = contig.replace(':', '_')
contig = contig.partition('(')[0]
if counter > 0:
fusion1 += ','+contig
fusion2 += ','+contig
else:
fusion1 += contig
fusion2 += contig
sequence = sequence_dict['>'+contig]
contigfa.write('>'+contig+'\n'+sequence+'\n')
counter += 1
fusion_dict[key1] = fusion1+'\n'
fusion_dict[key2] = fusion2+'\n'
id1 += 1
id2 += 1
key1 += 2
key2 += 2
return fusion_dict
def dup_CHROM(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
chrom = breakpoint[0]
chrom = chrom[3:]
return chrom
def dup_POS(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
position = breakpoint[2]
position = position.partition('(')[0]
return position | seq = refseq.GetSequence(chrom, int(pos), int(pos))
return seq
def dup_ALT():
alt = '<DUP:TANDEM>'
return alt
def dup_INFO(member):
pos = int(dup_POS(member))
svtype = 'FND'
length |
def dup_REF(member, refseq):
pos = dup_POS(member)
chrom = dup_CHROM(member) | random_line_split |
barnacle_vcf.py | ['+base2
return alt1, alt2
elif breakpoint1.endswith('(down)') and breakpoint2.endswith('(down)'):
alt1 = base1+']'+chrom2+':'+str(pos2)+']'
alt2 = base2+']'+chrom1+':'+str(pos1)+']'
return alt1, alt2
#one breakpoint is at the start of the contig region and other breakpoint is at the end
if breakpoint1.endswith('(up)'):
alt1 = ']'+chrom2+':'+pos2+']'+base1
alt2 = base2+'['+chrom1+':'+pos1+'['
else:
alt1 = base1+'['+chrom2+':'+pos2+'['
alt2 = ']'+chrom1+':'+pos1+']'+base2
return alt1, alt2
def get_QUAL():
return '.'
def get_FILT():
return 'PASS'
def get_INFO(member, id1, id2):
|
#header output method
def write_header(GIN_user, GIN_pass, LIMS_user, LIMS_pass, refseq_flag, library, filetype_flag, out_file, contig=None):
#file format
out_file.write('##fileformat=VCFv4.1\n')
#file date
out_file.write('##filedate='+time.strftime("%Y%m%d")+'\n')
#tcga version
out_file.write('##tcgaversion=1.0\n')
#genome reference; need to use URL
if refseq_flag == 'hg19':
out_file.write('##reference=<ID=hg19,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg19/1000genomes/bwa_ind/genome/\n')
elif refseq_flag == 'hg18':
out_file.write('##reference=<ID=hg18,Source=http://www.bcgsc.ca/downloads/genomes/Homo_sapiens/hg18/bwa_ind/genome/tcga_ref/>\n')
elif refseq_flag == 'mm9':
out_file.write('##reference=<ID=mm9,Source=/projects/transabyss/trans-ABySS/annotations/mm9/201107/genome.fa>\n')
#contig assembly tags, need to use URL
out_file.write('##assembly='+contig+'\n')
#center
out_file.write('##center="BCGSC"\n')
#phasing
out_file.write('##phasing=none\n')
info_format = {
'svtype':'##INFO=<ID=SVTYPE,Number=1,Type=String,Description="Type of structural variant">\n',
'mateid':'##INFO=<ID=MATEID,Number=1,Type=String,Description="ID of mate breakends">\n',
'event':'##INFO=<ID=EVENT,Number=1,Type=String,Description="ID of breakend event">\n',
'cipos':'##INFO=<ID=CIPOS,Number=2,Type=Integer,Description="Confidence interval around POS for imprecise variants">\n',
'svlen':'##INFO=<ID=SVLEN,Number=1,Type=Integer,Description="Difference in length between REF and ALT alleles">\n',
'end':'##INFO=<ID=END,Number=1,Type=Integer,Description="End position of the variant described in this record">\n',
'inv':'##ALT=<ID=INV,Description="Inversion">\n',
'del':'##ALT=<ID=DEL,Description="Deletion">\n',
'duptan':'##ALT=<ID=DUP:TANDEM,Description="Tandem Duplication">\n',
'sr':'##INFO=<ID=SR,Number=1,Type=Integer,Description="Spanning reads">\n',
'dp':'##INFO=<ID=DP,Number=1,Type=Integer,Description="Read depth">\n',
'CTG':'##INFO=<ID=CTG,Number=.,Type=String,Description="Contig ID">\n'
}
fusion = ['svtype', 'mateid', 'cipos', 'CTG', 'sr']
duplication = ['svtype', 'duptan', 'CTG', 'sr']
if filetype_flag == 'fusion':
for item in fusion:
if item in info_format:
out_file.write(info_format[item])
elif filetype_flag == 'itd' or filetype_flag == 'ptd':
for item in duplication:
if item in info_format:
out_file.write(info_format[item])
sample_info = commands.getoutput("python get_tcga_sample_info.py --username "+GIN_user+" --password "+GIN_pass+" --LIMS_user "+LIMS_user+" --LIMS_pass "+LIMS_pass+" --library "+library)
#sample info
sample_info = sample_info.split(',')
patient = sample_info[0]
sample_id = sample_info[1]
sample_desc = sample_info[2]
platform = sample_info[3]
accession = sample_info[4]
out_file.write('##SAMPLE=<ID='+sample_id+',Individual='+patient+',Description="'+sample_desc+'",Platform='+platform+',Accession='+accession+'>\n')
#pedigree
out_file.write('##PEDIGREE=<Name_0='+sample_id+'>\n')
fields_line = '#CHROM\t'+'POS\t'+'ID\t'+'REF\t'+'ALT\t'+'QUAL\t'+'FILTER\t'+'INFO\n'
out_file.write(fields_line)
def create_fusion_dict(output_dir, in_file, refseq, sequence_dict):
fusion_dict = {}
groupParser = CandidateGroupParserCls(in_file)
id1, id2 = 1, 1
key1, key2 = 1, 2
ctg_dir = output_dir.strip('vcf')
contigfa = open(ctg_dir+'fa', "w")
for group in groupParser:
member = group.members[0]
chrom1, chrom2 = get_CHROM(member)
pos1, pos2 = get_POS(member)
ref1, ref2 = get_REF(member, refseq)
alt1, alt2 = get_ALT(member, refseq)
qual = get_QUAL()
filt = get_FILT()
info1, info2 = get_INFO(member, id1, id2)
fusion1 = chrom1+'\t'+pos1+'\t'+str(id1)+'a'+'\t'+ref1+'\t'+alt1+'\t'+qual+'\t'+filt+'\t'+info1
fusion2 = chrom2+'\t'+pos2+'\t'+str(id2)+'b'+'\t'+ref2+'\t'+alt2+'\t'+qual+'\t'+filt+'\t'+info2
counter = 0
for m in group.members:
contig = m.contig_info.ToString()
contig = contig.replace(':', '_')
contig = contig.partition('(')[0]
if counter > 0:
fusion1 += ','+contig
fusion2 += ','+contig
else:
fusion1 += contig
fusion2 += contig
sequence = sequence_dict['>'+contig]
contigfa.write('>'+contig+'\n'+sequence+'\n')
counter += 1
fusion_dict[key1] = fusion1+'\n'
fusion_dict[key2] = fusion2+'\n'
id1 += 1
id2 += 1
key1 += 2
key2 += 2
return fusion_dict
def dup_CHROM(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
chrom = breakpoint[0]
chrom = chrom[3:]
return chrom
def dup_POS(member):
breakpoint = member.breakpointA.ToString()
breakpoint = breakpoint.partition(':')
position = breakpoint[2]
position = position.partition('(')[0]
return position
def dup_REF(member, refseq):
pos = dup_POS(member)
chrom = dup_CHROM(member)
seq = refseq.GetSequence(chrom, int(pos), int(pos))
return seq
def dup_ALT():
alt = '<DUP:TANDEM>'
return alt
def dup_INFO(member):
pos = int(dup_POS(member))
svtype = 'FND'
length | overlap = str(member.meta_fields['ctg_overlap'])
svtype = 'FND'
dp = int(member.avg_read_to_ctg_unique)
if int(overlap) > 0:
return 'SVTYPE='+svtype+';MATEID='+str(id2)+'b;CIPOS=0,'+overlap+';SR='+str(dp)+';CTG=', svtype+';MATEID='+str(id1)+'a;CIPOS=0,'+overlap+';SR='+str(dp)+';CTG='
else:
return 'SVTYPE='+svtype+';MATEID='+str(id2)+'b;SR='+str(dp)+';CTG=', svtype+';MATEID='+str(id1)+'a;SR='+str(dp)+';CTG=' | identifier_body |
MakeGoodGamesBot.py | tit_for_tat(),
# 2) RT followers,
# 3) RT highest ratio of number_of_RT/number_of_followers of previous day Statuses.
def run_schedule(dt=get_date(),ky='#indiedev',mx=150,clean=False,folow=False):
if clean: tit_for_tat()
if folow: RT_followers(key_=ky,max_=mx)
RT_last_day(dt,key_=ky)
def twice():
run_schedule(folow=True)
run_schedule(ky='#indiegame',clean=True,folow=True)
def loop_schedule(date):
while True:
for ky in ['#indiedev','#indiegame']:
print 'Day '+str(date)+' and keyword '+str(ky)
run_schedule(dt=date,ky=ky)
d = get_date()
if date != d:
date = d
break
#Main Functions for 'run_schedule()'
#Keeps track of who doesn't follow back. If an ID appears twice in this category then it
#unfollows. Bot follows ALL followers. Filter for undesirable accounts will be implemented soon.
def | ():
print 'Tit for Tat!'
follow_me = twitter_client.followers_ids() #who follows me
follow_you = twitter_client.friends_ids() #who do I follow
erros_ids = []
fol_len = len([1 for id_ in follow_me if id_ not in follow_you])
print 'Following '+str(fol_len)+' new users.'
for id_ in follow_me:
if id_ not in follow_you:
try:
twitter_client.create_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
unfollow,rem_len = remember_follow()
print 'Unfollowing '+str(len(unfollow))+'. Remembering '+str(rem_len)+'.'
for id_ in follow_you:
if id_ in unfollow:
try:
twitter_client.destroy_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
#Take previous day tweets. Rank by higher RT of smaller accounts. Try to RT the underdog!
def RT_last_day(date,key_='#indiedev'):
print 'RT '+str(key_)+' most relevant tweets from yesterday!'
d = latest_tweets(date=date,key_=key_)
d = rank_sort(d)
plot_distro(d[:5000])
a = RT_this(d[:10000],sleep_t=180)
return a
#Take timelines from followers and looks for keyword (default: #indiedev. RTs top tweets (default=2).
def RT_followers(key_='#indiedev',max_=150,rts_=2): #900/1500 Rate limit
print 'RT '+str(key_)+' within followers!'
clct,twtn = [],0
friends = twitter_client.followers_ids()
#Get collection of tweets of followers.
for f in friends:
c=[]
try:
c = twitter_client.user_timeline(f,count=100)
except:
#print 'Cant retweet follower.'
pass
tcl = [ci for ci in c if '#indiedev' in ci.text and ci.in_reply_to_status_id == None]
ttcl = []
for t in tcl:
keep = True
for word in banwords:
if word in t.entities['hashtags']:
keep = False
if keep == True:
ttcl.append(t)
tcl = ttcl
if len(tcl) > 0:
dc = {str(i.id):int(i.retweet_count) for i in tcl}
dfc = pd.DataFrame.from_dict(dc,orient='index')
dfc = dfc.sort(0,ascending=False)
#Final collection of RTs considers only top statuses
clct = clct + list(dfc.index[:rts_])
#After selection of most desirable RTs, we randomly RT them.
rd.shuffle(clct)
print 'Going for '+str(len(clct[:max_]))+' tweets.'
for id_ in clct:
if twtn >= max_: break
try:
twtn+=1
twitter_client.retweet(id_)
print 'Tweeted '+str(twtn)
time.sleep(120)
twitter_client.create_favorite(id_)
except:
pass
#RT statuses from a given DataFrame d.
def RT_this(d,sleep_t=60,stop_at=500,allow_like=False,checkmedia=False):
err,twts,iters=0,0,0
for tweet in d.values:
if twts == stop_at:
print 'Got '+str(stop_at)+' tweets. Stopping.'
break
try:
like,publish,i = True,True,0
if type(tweet[11]) != None:
try:
if tweet[11] in banRT: like,publish = False,False
except:
pass
i=1
if len(tweet[27]) > 14:
if tweet[27][:15] in banTXT: like,publish = False,False
i=2
like = False
if like and rd.random() < 0.05:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
if publish == False:
time.sleep(60)
i=3
if checkmedia and publish:
publish = filter_gif(tweet)
if publish:
try:
twitter_client.retweet(tweet[8])
i,twts=4,twts+1
print 'RTed : '+str(twts)+' at '+str(time.ctime())
time.sleep(sleep_t)
i=5
if type(tweet[11]) != None:
banRT.append(tweet[11])
if len(tweet[27]) > 14:
banTXT.append(tweet[27][:15])
except:
pass
try:
u_fol,u_fri=tweet[29]['followers_count'],tweet[29]['friends_count']
if (u_fol > 500 and u_fol < 10000) or (u_fol > 1.5*u_fri):
if i==4:
time.sleep(sleep_t)
i=6
twitter_client.create_friendship(tweet[29]['id'])
except:
pass
if like and allow_like:
try:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
time.sleep(sleep_t/3)
except:
print 'Couldnt like'
save_banDF()
iters+=1
except:
err+=1
#StreamListener: DoggoListener is not currently on use as RTs of previous day and followers
#use most of the bot's daytime.
#List of words to avoid and possible tweet lexic
banword = ["porn","pron","p0rn","pr0n"]
doggolex = ['*doggehyped*']
class DoggoListener(StreamListener):
def on_data(self, data):
tweet = json.loads(data)
i,like,publish = 0,True,True
try:
for word in banword:
if word in tweet['text'].lower(): like,publish = False,False
i=1
if tweet.get('lang') and tweet.get('lang') != 'en': like,publish = False,False
i=2
try:
if type(tweet['user']['description']) != None:
if 'indie' not in tweet['user']['description'] or 'dev' not in tweet['user']['description'] or 'developer' not in tweet['user']['description']:
like = False
if tweet['user']['followers_count'] < 1000: publish = False
else:
like,publish = False,False
except:
like,publish = False,False
i=3
if type(tweet['in_reply_to_status_id']) != None:
if tweet['in_reply_to_status_id'] in banRT:
like,publish = False,False
i=4
if len(tweet['text']) > 14:
if tweet['text'][:15] in banTXT:
like,publish = False,False
i=5
if like:
twitter_client.create_favorite(tweet['id'])
print 'Liked '+tweet['text']
if publish == False:
time.sleep(10)
i=6
if publish:
twitter_client.retweet(tweet['id'])
#Some console output to check if stream is RTweeting.
try:
print 'RTd: '+str(tweet['text'])
except:
print '*Woof*'
i='t'
if type(tweet['in_reply_to_status_id']) != None:
i=7
banRT.append(tweet['in_reply_to_status_id'])
if len(tweet['text']) > 14:
i=8
banTXT.append(tweet['text'][:15])
save_banDF()
time.sleep(60)
except:
print i #For debugging purposes
return True
def run_doggo_run(): #Streams the doggolistener()
if | tit_for_tat | identifier_name |
MakeGoodGamesBot.py | tit_for_tat(),
# 2) RT followers,
# 3) RT highest ratio of number_of_RT/number_of_followers of previous day Statuses.
def run_schedule(dt=get_date(),ky='#indiedev',mx=150,clean=False,folow=False):
if clean: tit_for_tat()
if folow: RT_followers(key_=ky,max_=mx)
RT_last_day(dt,key_=ky)
def twice():
|
def loop_schedule(date):
while True:
for ky in ['#indiedev','#indiegame']:
print 'Day '+str(date)+' and keyword '+str(ky)
run_schedule(dt=date,ky=ky)
d = get_date()
if date != d:
date = d
break
#Main Functions for 'run_schedule()'
#Keeps track of who doesn't follow back. If an ID appears twice in this category then it
#unfollows. Bot follows ALL followers. Filter for undesirable accounts will be implemented soon.
def tit_for_tat():
print 'Tit for Tat!'
follow_me = twitter_client.followers_ids() #who follows me
follow_you = twitter_client.friends_ids() #who do I follow
erros_ids = []
fol_len = len([1 for id_ in follow_me if id_ not in follow_you])
print 'Following '+str(fol_len)+' new users.'
for id_ in follow_me:
if id_ not in follow_you:
try:
twitter_client.create_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
unfollow,rem_len = remember_follow()
print 'Unfollowing '+str(len(unfollow))+'. Remembering '+str(rem_len)+'.'
for id_ in follow_you:
if id_ in unfollow:
try:
twitter_client.destroy_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
#Take previous day tweets. Rank by higher RT of smaller accounts. Try to RT the underdog!
def RT_last_day(date,key_='#indiedev'):
print 'RT '+str(key_)+' most relevant tweets from yesterday!'
d = latest_tweets(date=date,key_=key_)
d = rank_sort(d)
plot_distro(d[:5000])
a = RT_this(d[:10000],sleep_t=180)
return a
#Take timelines from followers and looks for keyword (default: #indiedev. RTs top tweets (default=2).
def RT_followers(key_='#indiedev',max_=150,rts_=2): #900/1500 Rate limit
print 'RT '+str(key_)+' within followers!'
clct,twtn = [],0
friends = twitter_client.followers_ids()
#Get collection of tweets of followers.
for f in friends:
c=[]
try:
c = twitter_client.user_timeline(f,count=100)
except:
#print 'Cant retweet follower.'
pass
tcl = [ci for ci in c if '#indiedev' in ci.text and ci.in_reply_to_status_id == None]
ttcl = []
for t in tcl:
keep = True
for word in banwords:
if word in t.entities['hashtags']:
keep = False
if keep == True:
ttcl.append(t)
tcl = ttcl
if len(tcl) > 0:
dc = {str(i.id):int(i.retweet_count) for i in tcl}
dfc = pd.DataFrame.from_dict(dc,orient='index')
dfc = dfc.sort(0,ascending=False)
#Final collection of RTs considers only top statuses
clct = clct + list(dfc.index[:rts_])
#After selection of most desirable RTs, we randomly RT them.
rd.shuffle(clct)
print 'Going for '+str(len(clct[:max_]))+' tweets.'
for id_ in clct:
if twtn >= max_: break
try:
twtn+=1
twitter_client.retweet(id_)
print 'Tweeted '+str(twtn)
time.sleep(120)
twitter_client.create_favorite(id_)
except:
pass
#RT statuses from a given DataFrame d.
def RT_this(d,sleep_t=60,stop_at=500,allow_like=False,checkmedia=False):
err,twts,iters=0,0,0
for tweet in d.values:
if twts == stop_at:
print 'Got '+str(stop_at)+' tweets. Stopping.'
break
try:
like,publish,i = True,True,0
if type(tweet[11]) != None:
try:
if tweet[11] in banRT: like,publish = False,False
except:
pass
i=1
if len(tweet[27]) > 14:
if tweet[27][:15] in banTXT: like,publish = False,False
i=2
like = False
if like and rd.random() < 0.05:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
if publish == False:
time.sleep(60)
i=3
if checkmedia and publish:
publish = filter_gif(tweet)
if publish:
try:
twitter_client.retweet(tweet[8])
i,twts=4,twts+1
print 'RTed : '+str(twts)+' at '+str(time.ctime())
time.sleep(sleep_t)
i=5
if type(tweet[11]) != None:
banRT.append(tweet[11])
if len(tweet[27]) > 14:
banTXT.append(tweet[27][:15])
except:
pass
try:
u_fol,u_fri=tweet[29]['followers_count'],tweet[29]['friends_count']
if (u_fol > 500 and u_fol < 10000) or (u_fol > 1.5*u_fri):
if i==4:
time.sleep(sleep_t)
i=6
twitter_client.create_friendship(tweet[29]['id'])
except:
pass
if like and allow_like:
try:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
time.sleep(sleep_t/3)
except:
print 'Couldnt like'
save_banDF()
iters+=1
except:
err+=1
#StreamListener: DoggoListener is not currently on use as RTs of previous day and followers
#use most of the bot's daytime.
#List of words to avoid and possible tweet lexic
banword = ["porn","pron","p0rn","pr0n"]
doggolex = ['*doggehyped*']
class DoggoListener(StreamListener):
def on_data(self, data):
tweet = json.loads(data)
i,like,publish = 0,True,True
try:
for word in banword:
if word in tweet['text'].lower(): like,publish = False,False
i=1
if tweet.get('lang') and tweet.get('lang') != 'en': like,publish = False,False
i=2
try:
if type(tweet['user']['description']) != None:
if 'indie' not in tweet['user']['description'] or 'dev' not in tweet['user']['description'] or 'developer' not in tweet['user']['description']:
like = False
if tweet['user']['followers_count'] < 1000: publish = False
else:
like,publish = False,False
except:
like,publish = False,False
i=3
if type(tweet['in_reply_to_status_id']) != None:
if tweet['in_reply_to_status_id'] in banRT:
like,publish = False,False
i=4
if len(tweet['text']) > 14:
if tweet['text'][:15] in banTXT:
like,publish = False,False
i=5
if like:
twitter_client.create_favorite(tweet['id'])
print 'Liked '+tweet['text']
if publish == False:
time.sleep(10)
i=6
if publish:
twitter_client.retweet(tweet['id'])
#Some console output to check if stream is RTweeting.
try:
print 'RTd: '+str(tweet['text'])
except:
print '*Woof*'
i='t'
if type(tweet['in_reply_to_status_id']) != None:
i=7
banRT.append(tweet['in_reply_to_status_id'])
if len(tweet['text']) > 14:
i=8
banTXT.append(tweet['text'][:15])
save_banDF()
time.sleep(60)
except:
print i #For debugging purposes
return True
def run_doggo_run(): #Streams the doggolistener()
if __ | run_schedule(folow=True)
run_schedule(ky='#indiegame',clean=True,folow=True) | identifier_body |
MakeGoodGamesBot.py | tit_for_tat(),
# 2) RT followers,
# 3) RT highest ratio of number_of_RT/number_of_followers of previous day Statuses.
def run_schedule(dt=get_date(),ky='#indiedev',mx=150,clean=False,folow=False):
if clean: |
if folow: RT_followers(key_=ky,max_=mx)
RT_last_day(dt,key_=ky)
def twice():
run_schedule(folow=True)
run_schedule(ky='#indiegame',clean=True,folow=True)
def loop_schedule(date):
while True:
for ky in ['#indiedev','#indiegame']:
print 'Day '+str(date)+' and keyword '+str(ky)
run_schedule(dt=date,ky=ky)
d = get_date()
if date != d:
date = d
break
#Main Functions for 'run_schedule()'
#Keeps track of who doesn't follow back. If an ID appears twice in this category then it
#unfollows. Bot follows ALL followers. Filter for undesirable accounts will be implemented soon.
def tit_for_tat():
print 'Tit for Tat!'
follow_me = twitter_client.followers_ids() #who follows me
follow_you = twitter_client.friends_ids() #who do I follow
erros_ids = []
fol_len = len([1 for id_ in follow_me if id_ not in follow_you])
print 'Following '+str(fol_len)+' new users.'
for id_ in follow_me:
if id_ not in follow_you:
try:
twitter_client.create_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
unfollow,rem_len = remember_follow()
print 'Unfollowing '+str(len(unfollow))+'. Remembering '+str(rem_len)+'.'
for id_ in follow_you:
if id_ in unfollow:
try:
twitter_client.destroy_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
#Take previous day tweets. Rank by higher RT of smaller accounts. Try to RT the underdog!
def RT_last_day(date,key_='#indiedev'):
print 'RT '+str(key_)+' most relevant tweets from yesterday!'
d = latest_tweets(date=date,key_=key_)
d = rank_sort(d)
plot_distro(d[:5000])
a = RT_this(d[:10000],sleep_t=180)
return a
#Take timelines from followers and looks for keyword (default: #indiedev. RTs top tweets (default=2).
def RT_followers(key_='#indiedev',max_=150,rts_=2): #900/1500 Rate limit
print 'RT '+str(key_)+' within followers!'
clct,twtn = [],0
friends = twitter_client.followers_ids()
#Get collection of tweets of followers.
for f in friends:
c=[]
try:
c = twitter_client.user_timeline(f,count=100)
except:
#print 'Cant retweet follower.'
pass
tcl = [ci for ci in c if '#indiedev' in ci.text and ci.in_reply_to_status_id == None]
ttcl = []
for t in tcl:
keep = True
for word in banwords:
if word in t.entities['hashtags']:
keep = False
if keep == True:
ttcl.append(t)
tcl = ttcl
if len(tcl) > 0:
dc = {str(i.id):int(i.retweet_count) for i in tcl}
dfc = pd.DataFrame.from_dict(dc,orient='index')
dfc = dfc.sort(0,ascending=False)
#Final collection of RTs considers only top statuses
clct = clct + list(dfc.index[:rts_])
#After selection of most desirable RTs, we randomly RT them.
rd.shuffle(clct)
print 'Going for '+str(len(clct[:max_]))+' tweets.'
for id_ in clct:
if twtn >= max_: break
try:
twtn+=1
twitter_client.retweet(id_)
print 'Tweeted '+str(twtn)
time.sleep(120)
twitter_client.create_favorite(id_)
except:
pass
#RT statuses from a given DataFrame d.
def RT_this(d,sleep_t=60,stop_at=500,allow_like=False,checkmedia=False):
err,twts,iters=0,0,0
for tweet in d.values:
if twts == stop_at:
print 'Got '+str(stop_at)+' tweets. Stopping.'
break
try:
like,publish,i = True,True,0
if type(tweet[11]) != None:
try:
if tweet[11] in banRT: like,publish = False,False
except:
pass
i=1
if len(tweet[27]) > 14:
if tweet[27][:15] in banTXT: like,publish = False,False
i=2
like = False
if like and rd.random() < 0.05:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
if publish == False:
time.sleep(60)
i=3
if checkmedia and publish:
publish = filter_gif(tweet)
if publish:
try:
twitter_client.retweet(tweet[8])
i,twts=4,twts+1
print 'RTed : '+str(twts)+' at '+str(time.ctime())
time.sleep(sleep_t)
i=5
if type(tweet[11]) != None:
banRT.append(tweet[11])
if len(tweet[27]) > 14:
banTXT.append(tweet[27][:15])
except:
pass
try:
u_fol,u_fri=tweet[29]['followers_count'],tweet[29]['friends_count']
if (u_fol > 500 and u_fol < 10000) or (u_fol > 1.5*u_fri):
if i==4:
time.sleep(sleep_t)
i=6
twitter_client.create_friendship(tweet[29]['id'])
except:
pass
if like and allow_like:
try:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
time.sleep(sleep_t/3)
except:
print 'Couldnt like'
save_banDF()
iters+=1
except:
err+=1
#StreamListener: DoggoListener is not currently on use as RTs of previous day and followers
#use most of the bot's daytime.
#List of words to avoid and possible tweet lexic
banword = ["porn","pron","p0rn","pr0n"]
doggolex = ['*doggehyped*']
class DoggoListener(StreamListener):
def on_data(self, data):
tweet = json.loads(data)
i,like,publish = 0,True,True
try:
for word in banword:
if word in tweet['text'].lower(): like,publish = False,False
i=1
if tweet.get('lang') and tweet.get('lang') != 'en': like,publish = False,False
i=2
try:
if type(tweet['user']['description']) != None:
if 'indie' not in tweet['user']['description'] or 'dev' not in tweet['user']['description'] or 'developer' not in tweet['user']['description']:
like = False
if tweet['user']['followers_count'] < 1000: publish = False
else:
like,publish = False,False
except:
like,publish = False,False
i=3
if type(tweet['in_reply_to_status_id']) != None:
if tweet['in_reply_to_status_id'] in banRT:
like,publish = False,False
i=4
if len(tweet['text']) > 14:
if tweet['text'][:15] in banTXT:
like,publish = False,False
i=5
if like:
twitter_client.create_favorite(tweet['id'])
print 'Liked '+tweet['text']
if publish == False:
time.sleep(10)
i=6
if publish:
twitter_client.retweet(tweet['id'])
#Some console output to check if stream is RTweeting.
try:
print 'RTd: '+str(tweet['text'])
except:
print '*Woof*'
i='t'
if type(tweet['in_reply_to_status_id']) != None:
i=7
banRT.append(tweet['in_reply_to_status_id'])
if len(tweet['text']) > 14:
i=8
banTXT.append(tweet['text'][:15])
save_banDF()
time.sleep(60)
except:
print i #For debugging purposes
return True
def run_doggo_run(): #Streams the doggolistener()
| tit_for_tat() | conditional_block |
MakeGoodGamesBot.py | tit_for_tat(),
# 2) RT followers,
# 3) RT highest ratio of number_of_RT/number_of_followers of previous day Statuses.
def run_schedule(dt=get_date(),ky='#indiedev',mx=150,clean=False,folow=False):
if clean: tit_for_tat()
if folow: RT_followers(key_=ky,max_=mx)
RT_last_day(dt,key_=ky)
def twice():
run_schedule(folow=True)
run_schedule(ky='#indiegame',clean=True,folow=True)
def loop_schedule(date):
while True:
for ky in ['#indiedev','#indiegame']:
print 'Day '+str(date)+' and keyword '+str(ky)
run_schedule(dt=date,ky=ky)
d = get_date()
if date != d:
date = d
break
#Main Functions for 'run_schedule()'
#Keeps track of who doesn't follow back. If an ID appears twice in this category then it
#unfollows. Bot follows ALL followers. Filter for undesirable accounts will be implemented soon.
def tit_for_tat():
print 'Tit for Tat!'
follow_me = twitter_client.followers_ids() #who follows me
follow_you = twitter_client.friends_ids() #who do I follow
erros_ids = []
fol_len = len([1 for id_ in follow_me if id_ not in follow_you])
print 'Following '+str(fol_len)+' new users.'
for id_ in follow_me:
if id_ not in follow_you:
try:
twitter_client.create_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
unfollow,rem_len = remember_follow()
print 'Unfollowing '+str(len(unfollow))+'. Remembering '+str(rem_len)+'.'
for id_ in follow_you:
if id_ in unfollow:
try:
twitter_client.destroy_friendship(id_)
time.sleep(5)
except:
erros_ids.append(id_)
#Take previous day tweets. Rank by higher RT of smaller accounts. Try to RT the underdog!
def RT_last_day(date,key_='#indiedev'):
print 'RT '+str(key_)+' most relevant tweets from yesterday!'
d = latest_tweets(date=date,key_=key_)
d = rank_sort(d)
plot_distro(d[:5000])
a = RT_this(d[:10000],sleep_t=180)
return a
#Take timelines from followers and looks for keyword (default: #indiedev. RTs top tweets (default=2).
def RT_followers(key_='#indiedev',max_=150,rts_=2): #900/1500 Rate limit
print 'RT '+str(key_)+' within followers!'
clct,twtn = [],0
friends = twitter_client.followers_ids()
#Get collection of tweets of followers.
for f in friends:
c=[]
try:
c = twitter_client.user_timeline(f,count=100)
except:
#print 'Cant retweet follower.'
pass
tcl = [ci for ci in c if '#indiedev' in ci.text and ci.in_reply_to_status_id == None]
ttcl = []
for t in tcl:
keep = True
for word in banwords:
if word in t.entities['hashtags']:
keep = False
if keep == True:
ttcl.append(t)
tcl = ttcl
if len(tcl) > 0:
dc = {str(i.id):int(i.retweet_count) for i in tcl}
dfc = pd.DataFrame.from_dict(dc,orient='index')
dfc = dfc.sort(0,ascending=False)
#Final collection of RTs considers only top statuses
clct = clct + list(dfc.index[:rts_])
#After selection of most desirable RTs, we randomly RT them.
rd.shuffle(clct)
print 'Going for '+str(len(clct[:max_]))+' tweets.'
for id_ in clct:
if twtn >= max_: break
try:
twtn+=1
twitter_client.retweet(id_)
print 'Tweeted '+str(twtn)
time.sleep(120)
twitter_client.create_favorite(id_)
except:
pass
#RT statuses from a given DataFrame d.
def RT_this(d,sleep_t=60,stop_at=500,allow_like=False,checkmedia=False):
err,twts,iters=0,0,0
for tweet in d.values:
if twts == stop_at:
print 'Got '+str(stop_at)+' tweets. Stopping.'
break
try:
like,publish,i = True,True,0
if type(tweet[11]) != None:
try:
if tweet[11] in banRT: like,publish = False,False
except:
pass
i=1
if len(tweet[27]) > 14:
if tweet[27][:15] in banTXT: like,publish = False,False
i=2
like = False
if like and rd.random() < 0.05:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
if publish == False:
time.sleep(60)
i=3
if checkmedia and publish:
publish = filter_gif(tweet) | i,twts=4,twts+1
print 'RTed : '+str(twts)+' at '+str(time.ctime())
time.sleep(sleep_t)
i=5
if type(tweet[11]) != None:
banRT.append(tweet[11])
if len(tweet[27]) > 14:
banTXT.append(tweet[27][:15])
except:
pass
try:
u_fol,u_fri=tweet[29]['followers_count'],tweet[29]['friends_count']
if (u_fol > 500 and u_fol < 10000) or (u_fol > 1.5*u_fri):
if i==4:
time.sleep(sleep_t)
i=6
twitter_client.create_friendship(tweet[29]['id'])
except:
pass
if like and allow_like:
try:
twitter_client.create_favorite(tweet[8])
print 'Liked '+tweet[27]
time.sleep(sleep_t/3)
except:
print 'Couldnt like'
save_banDF()
iters+=1
except:
err+=1
#StreamListener: DoggoListener is not currently on use as RTs of previous day and followers
#use most of the bot's daytime.
#List of words to avoid and possible tweet lexic
banword = ["porn","pron","p0rn","pr0n"]
doggolex = ['*doggehyped*']
class DoggoListener(StreamListener):
def on_data(self, data):
tweet = json.loads(data)
i,like,publish = 0,True,True
try:
for word in banword:
if word in tweet['text'].lower(): like,publish = False,False
i=1
if tweet.get('lang') and tweet.get('lang') != 'en': like,publish = False,False
i=2
try:
if type(tweet['user']['description']) != None:
if 'indie' not in tweet['user']['description'] or 'dev' not in tweet['user']['description'] or 'developer' not in tweet['user']['description']:
like = False
if tweet['user']['followers_count'] < 1000: publish = False
else:
like,publish = False,False
except:
like,publish = False,False
i=3
if type(tweet['in_reply_to_status_id']) != None:
if tweet['in_reply_to_status_id'] in banRT:
like,publish = False,False
i=4
if len(tweet['text']) > 14:
if tweet['text'][:15] in banTXT:
like,publish = False,False
i=5
if like:
twitter_client.create_favorite(tweet['id'])
print 'Liked '+tweet['text']
if publish == False:
time.sleep(10)
i=6
if publish:
twitter_client.retweet(tweet['id'])
#Some console output to check if stream is RTweeting.
try:
print 'RTd: '+str(tweet['text'])
except:
print '*Woof*'
i='t'
if type(tweet['in_reply_to_status_id']) != None:
i=7
banRT.append(tweet['in_reply_to_status_id'])
if len(tweet['text']) > 14:
i=8
banTXT.append(tweet['text'][:15])
save_banDF()
time.sleep(60)
except:
print i #For debugging purposes
return True
def run_doggo_run(): #Streams the doggolistener()
if __ | if publish:
try:
twitter_client.retweet(tweet[8]) | random_line_split |
calibrate_gripper_g1r1.py | amp_temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
config_default_g1_j1={
'calib':{
'motor':{
'name': 'Maxon RE13 2.5W 24V',
'winding_resistance': 53.2,#Ohm
'winding_inductance':1.79,#mH
'torque_constant':19.7, #mNm/A
'thermal_resistance_housing_ambient': 33.0,#K/W
'thermal_resistance_rotor_housing': 7.0,#K/W
'max_winding_temp': 85, #C
'gear_ratio': 275.0,
'thermal_time_constant_winding': 4.85, #S
'thermal_time_constant_motor':346, #S
'temp_sensor_type':'housing'
},
'theta':{
'type': 'ma3_12bit',
'name': 'US Digital MA3',
'cb_scale': 1.0,
'cb_bias': 0.0},
'amp_temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider=3V3
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
class M3Calibrate_Gripper_G1R1(M3CalibrateActuatorEcR1):
def __init__(self):
M3CalibrateActuatorEcR1.__init__(self)
self.joint_names=['Left Digit J0',
'Right Digit J1']
self.config_default=[
config_default_g1_j0,
config_default_g1_j1]
def start(self,ctype):
if not M3CalibrateActuatorEcR1.start(self,ctype):
return False
self.jid=int(self.comp_ec.name[self.comp_ec.name.find('_j')+2:])
self.calib_default=self.config_default[self.jid]['calib']
self.param_default=self.config_default[self.jid]['param']
self.param_internal=self.config_default[self.jid]['param_internal']
print 'Calibrating joint',self.joint_names[self.jid]
return True
def do_task(self,ct):
if ct=='ch':
self.reset_sensor('torque')
self.calibrate_torque()
self.write_config()
return True
if ct=='tt':
self.reset_sensor('theta')
self.calibrate_theta()
self.write_config()
return True
if M3CalibrateActuatorEc.do_task(self,ct):
return True
return False
def print_tasks(self):
M3CalibrateActuatorEcR1.print_tasks(self)
print 'ch: calibrate torque'
print 'tt: calibrate theta'
def display_sensors(self):
M3CalibrateActuatorEcR1.display_sensors(self) | print 'Pos: (mm) : '+'%3.3f'%pos+' Qei On '+'%d'%q_on+' Qei Period '+'%d'%q_p+' Qei Rollover '+'%d'%q_r
raw=self.comp_ec.status.adc_torque
c=self.torque.raw_2_mNm(self.comp_rt.config['calib']['torque'],raw)
mN=c/self.comp_j.config['calib']['cb_drive_radius_m']
print 'Force: (g) : '+'%3.2f'%m3u.mN2g(mN)+' (mN): '+'%3.2f'%mN+' (ADC) '+'%d'%raw
def calibrate_torque(self):
self.proxy.publish_command(self.comp_rt)
self.proxy.publish_param(self.comp_rt)
self.proxy.make_operational(self.name_rt)
self.step()
print 'Make sure other digit is all the way open'
print 'Place digit in zero load condition'
print 'Hit enter when ready'
raw_input()
self.step()
raw_a=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
load_a=0
print 'Hang 1Kg weight from gripper near slider'
print 'Hit enter to move joint in first direction.'
raw_input()
self.comp_rt.set_mode_pwm()
print 'Desired pwm? [',self.param_internal['pwm_torque'][0],']?'
p=int(m3t.get_float(self.param_internal['pwm_theta'][0]))
self.comp_rt.set_pwm(p)
self.step()
print 'Hit any key when ready to sample'
raw_input()
raw_b=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
print 'Was load in the opening direction [y]?'
if m3t.get_yes_no('y'):
load_b=m3u.g2mN(1000.0)*self.comp_j.config['calib']['cb_drive_radius_m']
else:
load_b=m3u.g2mN(-1000.0)*self.comp_j.config['calib']['cb_drive | q_on=self.comp_ec.status.qei_on
q_p=self.comp_ec.status.qei_period
q_r=self.comp_ec.status.qei_rollover
c=self.theta.raw_2_deg(self.comp_rt.config['calib']['theta'],q_on,q_p,q_r)
pos=1000.0*math.pi*2*self.comp_j.config['calib']['cb_drive_radius_m']*c/360.0 | random_line_split |
calibrate_gripper_g1r1.py | _temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
config_default_g1_j1={
'calib':{
'motor':{
'name': 'Maxon RE13 2.5W 24V',
'winding_resistance': 53.2,#Ohm
'winding_inductance':1.79,#mH
'torque_constant':19.7, #mNm/A
'thermal_resistance_housing_ambient': 33.0,#K/W
'thermal_resistance_rotor_housing': 7.0,#K/W
'max_winding_temp': 85, #C
'gear_ratio': 275.0,
'thermal_time_constant_winding': 4.85, #S
'thermal_time_constant_motor':346, #S
'temp_sensor_type':'housing'
},
'theta':{
'type': 'ma3_12bit',
'name': 'US Digital MA3',
'cb_scale': 1.0,
'cb_bias': 0.0},
'amp_temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider=3V3
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
class M3Calibrate_Gripper_G1R1(M3CalibrateActuatorEcR1):
def __init__(self):
M3CalibrateActuatorEcR1.__init__(self)
self.joint_names=['Left Digit J0',
'Right Digit J1']
self.config_default=[
config_default_g1_j0,
config_default_g1_j1]
def start(self,ctype):
if not M3CalibrateActuatorEcR1.start(self,ctype):
return False
self.jid=int(self.comp_ec.name[self.comp_ec.name.find('_j')+2:])
self.calib_default=self.config_default[self.jid]['calib']
self.param_default=self.config_default[self.jid]['param']
self.param_internal=self.config_default[self.jid]['param_internal']
print 'Calibrating joint',self.joint_names[self.jid]
return True
def do_task(self,ct):
if ct=='ch':
|
if ct=='tt':
self.reset_sensor('theta')
self.calibrate_theta()
self.write_config()
return True
if M3CalibrateActuatorEc.do_task(self,ct):
return True
return False
def print_tasks(self):
M3CalibrateActuatorEcR1.print_tasks(self)
print 'ch: calibrate torque'
print 'tt: calibrate theta'
def display_sensors(self):
M3CalibrateActuatorEcR1.display_sensors(self)
q_on=self.comp_ec.status.qei_on
q_p=self.comp_ec.status.qei_period
q_r=self.comp_ec.status.qei_rollover
c=self.theta.raw_2_deg(self.comp_rt.config['calib']['theta'],q_on,q_p,q_r)
pos=1000.0*math.pi*2*self.comp_j.config['calib']['cb_drive_radius_m']*c/360.0
print 'Pos: (mm) : '+'%3.3f'%pos+' Qei On '+'%d'%q_on+' Qei Period '+'%d'%q_p+' Qei Rollover '+'%d'%q_r
raw=self.comp_ec.status.adc_torque
c=self.torque.raw_2_mNm(self.comp_rt.config['calib']['torque'],raw)
mN=c/self.comp_j.config['calib']['cb_drive_radius_m']
print 'Force: (g) : '+'%3.2f'%m3u.mN2g(mN)+' (mN): '+'%3.2f'%mN+' (ADC) '+'%d'%raw
def calibrate_torque(self):
self.proxy.publish_command(self.comp_rt)
self.proxy.publish_param(self.comp_rt)
self.proxy.make_operational(self.name_rt)
self.step()
print 'Make sure other digit is all the way open'
print 'Place digit in zero load condition'
print 'Hit enter when ready'
raw_input()
self.step()
raw_a=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
load_a=0
print 'Hang 1Kg weight from gripper near slider'
print 'Hit enter to move joint in first direction.'
raw_input()
self.comp_rt.set_mode_pwm()
print 'Desired pwm? [',self.param_internal['pwm_torque'][0],']?'
p=int(m3t.get_float(self.param_internal['pwm_theta'][0]))
self.comp_rt.set_pwm(p)
self.step()
print 'Hit any key when ready to sample'
raw_input()
raw_b=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
print 'Was load in the opening direction [y]?'
if m3t.get_yes_no('y'):
load_b=m3u.g2mN(1000.0)*self.comp_j.config['calib']['cb_drive_radius_m']
else:
load_b=m3u.g2mN(-1000.0)*self.comp_j.config['calib']['cb_drive | self.reset_sensor('torque')
self.calibrate_torque()
self.write_config()
return True | conditional_block |
calibrate_gripper_g1r1.py | _temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
config_default_g1_j1={
'calib':{
'motor':{
'name': 'Maxon RE13 2.5W 24V',
'winding_resistance': 53.2,#Ohm
'winding_inductance':1.79,#mH
'torque_constant':19.7, #mNm/A
'thermal_resistance_housing_ambient': 33.0,#K/W
'thermal_resistance_rotor_housing': 7.0,#K/W
'max_winding_temp': 85, #C
'gear_ratio': 275.0,
'thermal_time_constant_winding': 4.85, #S
'thermal_time_constant_motor':346, #S
'temp_sensor_type':'housing'
},
'theta':{
'type': 'ma3_12bit',
'name': 'US Digital MA3',
'cb_scale': 1.0,
'cb_bias': 0.0},
'amp_temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider=3V3
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
class M3Calibrate_Gripper_G1R1(M3CalibrateActuatorEcR1):
def __init__(self):
M3CalibrateActuatorEcR1.__init__(self)
self.joint_names=['Left Digit J0',
'Right Digit J1']
self.config_default=[
config_default_g1_j0,
config_default_g1_j1]
def start(self,ctype):
if not M3CalibrateActuatorEcR1.start(self,ctype):
return False
self.jid=int(self.comp_ec.name[self.comp_ec.name.find('_j')+2:])
self.calib_default=self.config_default[self.jid]['calib']
self.param_default=self.config_default[self.jid]['param']
self.param_internal=self.config_default[self.jid]['param_internal']
print 'Calibrating joint',self.joint_names[self.jid]
return True
def do_task(self,ct):
|
def print_tasks(self):
M3CalibrateActuatorEcR1.print_tasks(self)
print 'ch: calibrate torque'
print 'tt: calibrate theta'
def display_sensors(self):
M3CalibrateActuatorEcR1.display_sensors(self)
q_on=self.comp_ec.status.qei_on
q_p=self.comp_ec.status.qei_period
q_r=self.comp_ec.status.qei_rollover
c=self.theta.raw_2_deg(self.comp_rt.config['calib']['theta'],q_on,q_p,q_r)
pos=1000.0*math.pi*2*self.comp_j.config['calib']['cb_drive_radius_m']*c/360.0
print 'Pos: (mm) : '+'%3.3f'%pos+' Qei On '+'%d'%q_on+' Qei Period '+'%d'%q_p+' Qei Rollover '+'%d'%q_r
raw=self.comp_ec.status.adc_torque
c=self.torque.raw_2_mNm(self.comp_rt.config['calib']['torque'],raw)
mN=c/self.comp_j.config['calib']['cb_drive_radius_m']
print 'Force: (g) : '+'%3.2f'%m3u.mN2g(mN)+' (mN): '+'%3.2f'%mN+' (ADC) '+'%d'%raw
def calibrate_torque(self):
self.proxy.publish_command(self.comp_rt)
self.proxy.publish_param(self.comp_rt)
self.proxy.make_operational(self.name_rt)
self.step()
print 'Make sure other digit is all the way open'
print 'Place digit in zero load condition'
print 'Hit enter when ready'
raw_input()
self.step()
raw_a=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
load_a=0
print 'Hang 1Kg weight from gripper near slider'
print 'Hit enter to move joint in first direction.'
raw_input()
self.comp_rt.set_mode_pwm()
print 'Desired pwm? [',self.param_internal['pwm_torque'][0],']?'
p=int(m3t.get_float(self.param_internal['pwm_theta'][0]))
self.comp_rt.set_pwm(p)
self.step()
print 'Hit any key when ready to sample'
raw_input()
raw_b=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
print 'Was load in the opening direction [y]?'
if m3t.get_yes_no('y'):
load_b=m3u.g2mN(1000.0)*self.comp_j.config['calib']['cb_drive_radius_m']
else:
load_b=m3u.g2mN(-1000.0)*self.comp_j.config['calib']['cb_drive | if ct=='ch':
self.reset_sensor('torque')
self.calibrate_torque()
self.write_config()
return True
if ct=='tt':
self.reset_sensor('theta')
self.calibrate_theta()
self.write_config()
return True
if M3CalibrateActuatorEc.do_task(self,ct):
return True
return False | identifier_body |
calibrate_gripper_g1r1.py | _temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
config_default_g1_j1={
'calib':{
'motor':{
'name': 'Maxon RE13 2.5W 24V',
'winding_resistance': 53.2,#Ohm
'winding_inductance':1.79,#mH
'torque_constant':19.7, #mNm/A
'thermal_resistance_housing_ambient': 33.0,#K/W
'thermal_resistance_rotor_housing': 7.0,#K/W
'max_winding_temp': 85, #C
'gear_ratio': 275.0,
'thermal_time_constant_winding': 4.85, #S
'thermal_time_constant_motor':346, #S
'temp_sensor_type':'housing'
},
'theta':{
'type': 'ma3_12bit',
'name': 'US Digital MA3',
'cb_scale': 1.0,
'cb_bias': 0.0},
'amp_temp':{
'type': 'adc_linear_3V3', #3V3 supply, no divider
'name': 'Microchip TC1047',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0,
},
'motor_temp':{
'type': 'adc_linear_3V3', #5V supply, no divider=3V3
'name': 'Analog TMP36',
'cb_mV_at_25C': 750.0,
'cb_mV_per_C': 10.0,
'cb_scale': 1.0,
'cb_bias': 0.0},
'torque':{
'type': 'adc_poly',
'name': 'Allegro A1321',
'cb_inv_torque': [1,0],
'cb_torque': [1,0],
'cb_scale': 1.0,
'cb_bias': 0.0},
'current':{
'type': 'none',
'cb_scale': 0.0,
'cb_bias': 0.0},
},
'param':{
'max_amp_temp': 100.0,
'max_current': 800,
'max_motor_temp': 75.0,
'max_tq': 150.0,
'min_tq': -30.0,
'thetadot_deadband': 1.0
},
'param_internal':
{
'calib_tq_degree':1,
'pwm_theta':[-800,800],
'pwm_torque':[-1000,-1000],
'joint_limits':[0,315.0]
}
}
class M3Calibrate_Gripper_G1R1(M3CalibrateActuatorEcR1):
def __init__(self):
M3CalibrateActuatorEcR1.__init__(self)
self.joint_names=['Left Digit J0',
'Right Digit J1']
self.config_default=[
config_default_g1_j0,
config_default_g1_j1]
def start(self,ctype):
if not M3CalibrateActuatorEcR1.start(self,ctype):
return False
self.jid=int(self.comp_ec.name[self.comp_ec.name.find('_j')+2:])
self.calib_default=self.config_default[self.jid]['calib']
self.param_default=self.config_default[self.jid]['param']
self.param_internal=self.config_default[self.jid]['param_internal']
print 'Calibrating joint',self.joint_names[self.jid]
return True
def | (self,ct):
if ct=='ch':
self.reset_sensor('torque')
self.calibrate_torque()
self.write_config()
return True
if ct=='tt':
self.reset_sensor('theta')
self.calibrate_theta()
self.write_config()
return True
if M3CalibrateActuatorEc.do_task(self,ct):
return True
return False
def print_tasks(self):
M3CalibrateActuatorEcR1.print_tasks(self)
print 'ch: calibrate torque'
print 'tt: calibrate theta'
def display_sensors(self):
M3CalibrateActuatorEcR1.display_sensors(self)
q_on=self.comp_ec.status.qei_on
q_p=self.comp_ec.status.qei_period
q_r=self.comp_ec.status.qei_rollover
c=self.theta.raw_2_deg(self.comp_rt.config['calib']['theta'],q_on,q_p,q_r)
pos=1000.0*math.pi*2*self.comp_j.config['calib']['cb_drive_radius_m']*c/360.0
print 'Pos: (mm) : '+'%3.3f'%pos+' Qei On '+'%d'%q_on+' Qei Period '+'%d'%q_p+' Qei Rollover '+'%d'%q_r
raw=self.comp_ec.status.adc_torque
c=self.torque.raw_2_mNm(self.comp_rt.config['calib']['torque'],raw)
mN=c/self.comp_j.config['calib']['cb_drive_radius_m']
print 'Force: (g) : '+'%3.2f'%m3u.mN2g(mN)+' (mN): '+'%3.2f'%mN+' (ADC) '+'%d'%raw
def calibrate_torque(self):
self.proxy.publish_command(self.comp_rt)
self.proxy.publish_param(self.comp_rt)
self.proxy.make_operational(self.name_rt)
self.step()
print 'Make sure other digit is all the way open'
print 'Place digit in zero load condition'
print 'Hit enter when ready'
raw_input()
self.step()
raw_a=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
load_a=0
print 'Hang 1Kg weight from gripper near slider'
print 'Hit enter to move joint in first direction.'
raw_input()
self.comp_rt.set_mode_pwm()
print 'Desired pwm? [',self.param_internal['pwm_torque'][0],']?'
p=int(m3t.get_float(self.param_internal['pwm_theta'][0]))
self.comp_rt.set_pwm(p)
self.step()
print 'Hit any key when ready to sample'
raw_input()
raw_b=int(self.get_sensor_list_avg(['adc_torque'],1.0)['adc_torque'])
print 'Was load in the opening direction [y]?'
if m3t.get_yes_no('y'):
load_b=m3u.g2mN(1000.0)*self.comp_j.config['calib']['cb_drive_radius_m']
else:
load_b=m3u.g2mN(-1000.0)*self.comp_j.config['calib']['cb | do_task | identifier_name |
getfood_base.py | mine = 4
def __init__(self,
agent_start_pos=(1, 1),
health_cap=50,
food_rate=4,
grid_size=8,
obs_vision=False,
reward_type='delta',
fully_observed=False,
only_partial_obs=False,
can_die=True,
one_hot_obs=True,
mixing_time_periods=[],
mixing_time_period_length=120,
**kwargs
):
self.agent_start_pos = agent_start_pos
# self.agent_start_dir = agent_start_dir
self.food_rate = food_rate
self.health_cap = health_cap
self.health = health_cap
self.last_health = self.health
self.obs_vision = obs_vision
self.reward_type = reward_type
self.fully_observed = fully_observed
self.only_partial_obs = only_partial_obs
self.can_die = can_die
self.one_hot_obs = one_hot_obs
# for conditional entropy of s' | s
self.transition_count = {}
self.prev_obs_string = ''
# for mixing time
self.mixing_time_periods = mixing_time_periods
self.max_mixing_time_period = max(mixing_time_periods) if mixing_time_periods else 0
self.mixing_time_period_length = mixing_time_period_length
self.obs_counts = []
if not hasattr(self, 'actions'):
self.actions = FoodEnvBase.Actions
super().__init__(
# Set this to True for maximum speed
see_through_walls=True,
grid_size=grid_size,
**kwargs
)
def _reward(self):
if self.reward_type == 'survival':
rwd = 1
elif self.reward_type == 'delta':
rwd = self.health - self.last_health
elif self.reward_type == 'health':
rwd = self.health
else:
assert False, "Reward type not matched"
self.last_health = self.health
return rwd
def _gen_grid(self, width, height):
# Create an empty grid
self.grid = GridAbsolute(width, height)
# Generate the surrounding walls
self.grid.wall_rect(0, 0, width, height)
# Place a goal square in the bottom-right corner
# self.grid.set(width - 2, height - 2, Goal())
self.extra_gen_grid()
# Place the agent
if self.agent_start_pos is not None:
self.start_pos = self.agent_start_pos
# self.start_dir = self.agent_start_dir
else:
self.place_agent()
self.mission = None
def step(self, action, incl_health=True):
done = False
matched = super().step(action, override=True)
# subclass-defined extra actions. if not caught by that, then unknown action
if not self.extra_step(action, matched):
assert False, "unknown action %d" % action
# decrease health bar
self.decay_health()
# generate new food
self.place_items()
# generate obs after action is caught and food is placed. generate reward before death check
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(scale=1 if self.fully_observed else 1 / 8, onehot=self.one_hot_obs)
# NOTE: below not nec due to onehot being passed into two func calls above. but leaving here for now in case.
# if self.one_hot_obs:
# # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]])
rwd = self._reward()
# tick on each grid item
to_remove = []
for j in range(0, self.grid.height):
for i in range(0, self.grid.width):
cell = self.grid.get(i, j)
if cell is not None:
if not cell.step():
self.dead_obj(i, j, cell)
to_remove.append((i, j))
for idxs in to_remove:
self.grid.set(*idxs, None)
# dead.
if self.dead():
done = True
if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
|
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
obs_string = obs.tostring()
# transition count stuff
self.transition_count.setdefault(hash(self.prev_obs_string), {})
self.transition_count[hash(self.prev_obs_string)][hash(obs_string)] = 1 + self.transition_count[hash(self.prev_obs_string)].get(hash(obs_string), 0)
# mixing time stuff
if self.step_count % self.mixing_time_period_length == 0:
self.obs_counts.append(self.obs_count.copy())
if hasattr(self, 'obs_count') and self.mixing_time_periods and len(self.obs_counts) > self.max_mixing_time_period:
self.obs_counts = self.obs_counts[-(self.max_mixing_time_period+1):]
self.prev_obs_string = obs_string
return obs, rwd, done, {}
def reset(self, incl_health=True):
super().reset()
self.health = self.health_cap
self.extra_reset()
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(onehot=self.one_hot_obs)
self.transition_count = {}
# if self.one_hot_obs:
# # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]])
if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
obs = np.concatenate((img.flatten(), np.array([self.health])))
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
self.prev_obs_string = obs.tostring()
return obs
def get_full_img(self, scale=1 / 8, onehot=False):
""" Return the whole grid view """
if self.obs_vision:
full_img = self.get_full_obs_render(scale=scale)
else:
full_img = self.grid.encode(self, onehot=onehot)
# NOTE: in case need to scale here instead of in above func call: return cv2.resize(full_img, (0, 0), fx=0.125, fy=0.125, interpolation=cv2.INTER_AREA)
return full_img
def get_img(self, onehot=False):
""" Return the agent view """
if self.obs_vision:
img = self.gen_obs(onehot=False)
img = self.get_obs_render(img, CELL_PIXELS // 4)
else:
img = self.gen_obs(onehot=onehot)
return img
def extra_step(self, action, matched):
return matched
def extra_reset(self):
pass
def place_items(self):
pass
def extra_gen_grid(self):
pass
def place_prob(self, obj, prob, top=None, size=None):
if np.random.binomial(1, prob):
pos = self.place_obj(obj, top, size)
obj.cur_pos = pos
return True
return False
def decay_health(self):
self.add_health(-1)
def add_health(self, num):
# clip health between 0 and cap after adjustment
self.health = max(0, min(self.health_cap, self.health + num))
def count_type(self, type):
count = 0
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
if type is None and cell is None or cell is not None and cell.type == type:
count += 1
return count
def count_all_types(self):
counts = {}
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
type = cell.type if cell is not None else ''
counts[type] = counts.get | obs = np.concatenate((img.flatten(), np.array([self.health]))) | conditional_block |
getfood_base.py | for conditional entropy of s' | s
self.transition_count = {}
self.prev_obs_string = ''
# for mixing time
self.mixing_time_periods = mixing_time_periods
self.max_mixing_time_period = max(mixing_time_periods) if mixing_time_periods else 0
self.mixing_time_period_length = mixing_time_period_length
self.obs_counts = []
if not hasattr(self, 'actions'):
self.actions = FoodEnvBase.Actions
super().__init__(
# Set this to True for maximum speed
see_through_walls=True,
grid_size=grid_size,
**kwargs
)
def _reward(self):
if self.reward_type == 'survival':
rwd = 1
elif self.reward_type == 'delta':
rwd = self.health - self.last_health
elif self.reward_type == 'health':
rwd = self.health
else:
assert False, "Reward type not matched"
self.last_health = self.health
return rwd
def _gen_grid(self, width, height):
# Create an empty grid
self.grid = GridAbsolute(width, height)
# Generate the surrounding walls
self.grid.wall_rect(0, 0, width, height)
# Place a goal square in the bottom-right corner
# self.grid.set(width - 2, height - 2, Goal())
self.extra_gen_grid()
# Place the agent
if self.agent_start_pos is not None:
self.start_pos = self.agent_start_pos
# self.start_dir = self.agent_start_dir
else:
self.place_agent()
self.mission = None
def step(self, action, incl_health=True):
done = False
matched = super().step(action, override=True)
# subclass-defined extra actions. if not caught by that, then unknown action
if not self.extra_step(action, matched):
assert False, "unknown action %d" % action
# decrease health bar
self.decay_health()
# generate new food
self.place_items()
# generate obs after action is caught and food is placed. generate reward before death check
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(scale=1 if self.fully_observed else 1 / 8, onehot=self.one_hot_obs)
# NOTE: below not nec due to onehot being passed into two func calls above. but leaving here for now in case.
# if self.one_hot_obs:
# # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]])
rwd = self._reward()
# tick on each grid item
to_remove = []
for j in range(0, self.grid.height):
for i in range(0, self.grid.width):
cell = self.grid.get(i, j)
if cell is not None:
if not cell.step():
self.dead_obj(i, j, cell)
to_remove.append((i, j))
for idxs in to_remove:
self.grid.set(*idxs, None)
# dead.
if self.dead():
done = True
if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
obs = np.concatenate((img.flatten(), np.array([self.health])))
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
obs_string = obs.tostring()
# transition count stuff
self.transition_count.setdefault(hash(self.prev_obs_string), {})
self.transition_count[hash(self.prev_obs_string)][hash(obs_string)] = 1 + self.transition_count[hash(self.prev_obs_string)].get(hash(obs_string), 0)
# mixing time stuff
if self.step_count % self.mixing_time_period_length == 0:
self.obs_counts.append(self.obs_count.copy())
if hasattr(self, 'obs_count') and self.mixing_time_periods and len(self.obs_counts) > self.max_mixing_time_period:
self.obs_counts = self.obs_counts[-(self.max_mixing_time_period+1):]
self.prev_obs_string = obs_string
return obs, rwd, done, {}
def reset(self, incl_health=True):
super().reset()
self.health = self.health_cap
self.extra_reset()
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(onehot=self.one_hot_obs)
self.transition_count = {}
# if self.one_hot_obs:
# # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]])
if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
obs = np.concatenate((img.flatten(), np.array([self.health])))
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
self.prev_obs_string = obs.tostring()
return obs
def get_full_img(self, scale=1 / 8, onehot=False):
""" Return the whole grid view """
if self.obs_vision:
full_img = self.get_full_obs_render(scale=scale)
else:
full_img = self.grid.encode(self, onehot=onehot)
# NOTE: in case need to scale here instead of in above func call: return cv2.resize(full_img, (0, 0), fx=0.125, fy=0.125, interpolation=cv2.INTER_AREA)
return full_img
def get_img(self, onehot=False):
""" Return the agent view """
if self.obs_vision:
img = self.gen_obs(onehot=False)
img = self.get_obs_render(img, CELL_PIXELS // 4)
else:
img = self.gen_obs(onehot=onehot)
return img
def extra_step(self, action, matched):
return matched
def extra_reset(self):
pass
def place_items(self):
pass
def extra_gen_grid(self):
pass
def place_prob(self, obj, prob, top=None, size=None):
if np.random.binomial(1, prob):
pos = self.place_obj(obj, top, size)
obj.cur_pos = pos
return True
return False
def decay_health(self):
self.add_health(-1)
def add_health(self, num):
# clip health between 0 and cap after adjustment
self.health = max(0, min(self.health_cap, self.health + num))
def count_type(self, type):
count = 0
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
if type is None and cell is None or cell is not None and cell.type == type:
count += 1
return count
def count_all_types(self):
counts = {}
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
type = cell.type if cell is not None else ''
counts[type] = counts.get(type, 0) + 1
if hasattr(self, 'monsters'):
counts['monster'] = len(self.monsters)
return counts
def exists_type(self, type):
""" Check if object of type TYPE exists in current grid. """
for i in range(1, self.grid_size - 1):
for j in range(1, self.grid_size - 1):
obj = self.grid.get(i, j)
if obj and obj.type == type:
return True
return False
def dead(self):
return self.can_die and self.health <= 0
def dead_obj(self, i, j, obj):
""" Called when OBJ dies at position (i, j). """
pass
def __getstate__(self):
d = self.__dict__.copy()
del d['grid_render']
return d
def __setstate__(self, d):
self.__dict__.update(d)
class | FoodEnvEmptyFullObs | identifier_name |
|
getfood_base.py | mine = 4
def __init__(self,
agent_start_pos=(1, 1),
health_cap=50,
food_rate=4,
grid_size=8,
obs_vision=False,
reward_type='delta',
fully_observed=False,
only_partial_obs=False,
can_die=True,
one_hot_obs=True,
mixing_time_periods=[],
mixing_time_period_length=120,
**kwargs
):
self.agent_start_pos = agent_start_pos
# self.agent_start_dir = agent_start_dir
self.food_rate = food_rate
self.health_cap = health_cap
self.health = health_cap
self.last_health = self.health
self.obs_vision = obs_vision
self.reward_type = reward_type
self.fully_observed = fully_observed
self.only_partial_obs = only_partial_obs
self.can_die = can_die
self.one_hot_obs = one_hot_obs
# for conditional entropy of s' | s
self.transition_count = {}
self.prev_obs_string = ''
# for mixing time
self.mixing_time_periods = mixing_time_periods
self.max_mixing_time_period = max(mixing_time_periods) if mixing_time_periods else 0
self.mixing_time_period_length = mixing_time_period_length
self.obs_counts = []
if not hasattr(self, 'actions'):
self.actions = FoodEnvBase.Actions
super().__init__(
# Set this to True for maximum speed
see_through_walls=True,
grid_size=grid_size,
**kwargs
)
def _reward(self):
if self.reward_type == 'survival':
rwd = 1
elif self.reward_type == 'delta':
rwd = self.health - self.last_health
elif self.reward_type == 'health':
rwd = self.health
else:
assert False, "Reward type not matched"
self.last_health = self.health
return rwd
def _gen_grid(self, width, height):
# Create an empty grid
self.grid = GridAbsolute(width, height)
# Generate the surrounding walls
self.grid.wall_rect(0, 0, width, height)
# Place a goal square in the bottom-right corner
# self.grid.set(width - 2, height - 2, Goal())
self.extra_gen_grid()
# Place the agent
if self.agent_start_pos is not None:
self.start_pos = self.agent_start_pos
# self.start_dir = self.agent_start_dir
else:
self.place_agent()
self.mission = None
def step(self, action, incl_health=True):
done = False
matched = super().step(action, override=True)
# subclass-defined extra actions. if not caught by that, then unknown action
if not self.extra_step(action, matched):
assert False, "unknown action %d" % action
# decrease health bar
self.decay_health()
# generate new food
self.place_items()
# generate obs after action is caught and food is placed. generate reward before death check
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(scale=1 if self.fully_observed else 1 / 8, onehot=self.one_hot_obs)
# NOTE: below not nec due to onehot being passed into two func calls above. but leaving here for now in case.
# if self.one_hot_obs:
# # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]])
rwd = self._reward()
# tick on each grid item
to_remove = []
for j in range(0, self.grid.height):
for i in range(0, self.grid.width):
cell = self.grid.get(i, j)
if cell is not None:
if not cell.step():
self.dead_obj(i, j, cell)
to_remove.append((i, j))
for idxs in to_remove:
self.grid.set(*idxs, None)
# dead.
if self.dead():
done = True
if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
obs = np.concatenate((img.flatten(), np.array([self.health])))
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
obs_string = obs.tostring()
# transition count stuff
self.transition_count.setdefault(hash(self.prev_obs_string), {})
self.transition_count[hash(self.prev_obs_string)][hash(obs_string)] = 1 + self.transition_count[hash(self.prev_obs_string)].get(hash(obs_string), 0)
# mixing time stuff
if self.step_count % self.mixing_time_period_length == 0:
self.obs_counts.append(self.obs_count.copy())
if hasattr(self, 'obs_count') and self.mixing_time_periods and len(self.obs_counts) > self.max_mixing_time_period:
self.obs_counts = self.obs_counts[-(self.max_mixing_time_period+1):]
self.prev_obs_string = obs_string
return obs, rwd, done, {}
def reset(self, incl_health=True):
super().reset()
self.health = self.health_cap
self.extra_reset()
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(onehot=self.one_hot_obs)
self.transition_count = {}
# if self.one_hot_obs: | if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
obs = np.concatenate((img.flatten(), np.array([self.health])))
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
self.prev_obs_string = obs.tostring()
return obs
def get_full_img(self, scale=1 / 8, onehot=False):
""" Return the whole grid view """
if self.obs_vision:
full_img = self.get_full_obs_render(scale=scale)
else:
full_img = self.grid.encode(self, onehot=onehot)
# NOTE: in case need to scale here instead of in above func call: return cv2.resize(full_img, (0, 0), fx=0.125, fy=0.125, interpolation=cv2.INTER_AREA)
return full_img
def get_img(self, onehot=False):
""" Return the agent view """
if self.obs_vision:
img = self.gen_obs(onehot=False)
img = self.get_obs_render(img, CELL_PIXELS // 4)
else:
img = self.gen_obs(onehot=onehot)
return img
def extra_step(self, action, matched):
return matched
def extra_reset(self):
pass
def place_items(self):
pass
def extra_gen_grid(self):
pass
def place_prob(self, obj, prob, top=None, size=None):
if np.random.binomial(1, prob):
pos = self.place_obj(obj, top, size)
obj.cur_pos = pos
return True
return False
def decay_health(self):
self.add_health(-1)
def add_health(self, num):
# clip health between 0 and cap after adjustment
self.health = max(0, min(self.health_cap, self.health + num))
def count_type(self, type):
count = 0
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
if type is None and cell is None or cell is not None and cell.type == type:
count += 1
return count
def count_all_types(self):
counts = {}
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
type = cell.type if cell is not None else ''
counts[type] = counts.get(type | # # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]]) | random_line_split |
getfood_base.py | mine = 4
def __init__(self,
agent_start_pos=(1, 1),
health_cap=50,
food_rate=4,
grid_size=8,
obs_vision=False,
reward_type='delta',
fully_observed=False,
only_partial_obs=False,
can_die=True,
one_hot_obs=True,
mixing_time_periods=[],
mixing_time_period_length=120,
**kwargs
):
self.agent_start_pos = agent_start_pos
# self.agent_start_dir = agent_start_dir
self.food_rate = food_rate
self.health_cap = health_cap
self.health = health_cap
self.last_health = self.health
self.obs_vision = obs_vision
self.reward_type = reward_type
self.fully_observed = fully_observed
self.only_partial_obs = only_partial_obs
self.can_die = can_die
self.one_hot_obs = one_hot_obs
# for conditional entropy of s' | s
self.transition_count = {}
self.prev_obs_string = ''
# for mixing time
self.mixing_time_periods = mixing_time_periods
self.max_mixing_time_period = max(mixing_time_periods) if mixing_time_periods else 0
self.mixing_time_period_length = mixing_time_period_length
self.obs_counts = []
if not hasattr(self, 'actions'):
self.actions = FoodEnvBase.Actions
super().__init__(
# Set this to True for maximum speed
see_through_walls=True,
grid_size=grid_size,
**kwargs
)
def _reward(self):
if self.reward_type == 'survival':
rwd = 1
elif self.reward_type == 'delta':
rwd = self.health - self.last_health
elif self.reward_type == 'health':
rwd = self.health
else:
assert False, "Reward type not matched"
self.last_health = self.health
return rwd
def _gen_grid(self, width, height):
# Create an empty grid
self.grid = GridAbsolute(width, height)
# Generate the surrounding walls
self.grid.wall_rect(0, 0, width, height)
# Place a goal square in the bottom-right corner
# self.grid.set(width - 2, height - 2, Goal())
self.extra_gen_grid()
# Place the agent
if self.agent_start_pos is not None:
self.start_pos = self.agent_start_pos
# self.start_dir = self.agent_start_dir
else:
self.place_agent()
self.mission = None
def step(self, action, incl_health=True):
done = False
matched = super().step(action, override=True)
# subclass-defined extra actions. if not caught by that, then unknown action
if not self.extra_step(action, matched):
assert False, "unknown action %d" % action
# decrease health bar
self.decay_health()
# generate new food
self.place_items()
# generate obs after action is caught and food is placed. generate reward before death check
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(scale=1 if self.fully_observed else 1 / 8, onehot=self.one_hot_obs)
# NOTE: below not nec due to onehot being passed into two func calls above. but leaving here for now in case.
# if self.one_hot_obs:
# # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]])
rwd = self._reward()
# tick on each grid item
to_remove = []
for j in range(0, self.grid.height):
for i in range(0, self.grid.width):
cell = self.grid.get(i, j)
if cell is not None:
if not cell.step():
self.dead_obj(i, j, cell)
to_remove.append((i, j))
for idxs in to_remove:
self.grid.set(*idxs, None)
# dead.
if self.dead():
done = True
if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
obs = np.concatenate((img.flatten(), np.array([self.health])))
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
obs_string = obs.tostring()
# transition count stuff
self.transition_count.setdefault(hash(self.prev_obs_string), {})
self.transition_count[hash(self.prev_obs_string)][hash(obs_string)] = 1 + self.transition_count[hash(self.prev_obs_string)].get(hash(obs_string), 0)
# mixing time stuff
if self.step_count % self.mixing_time_period_length == 0:
self.obs_counts.append(self.obs_count.copy())
if hasattr(self, 'obs_count') and self.mixing_time_periods and len(self.obs_counts) > self.max_mixing_time_period:
self.obs_counts = self.obs_counts[-(self.max_mixing_time_period+1):]
self.prev_obs_string = obs_string
return obs, rwd, done, {}
def reset(self, incl_health=True):
super().reset()
self.health = self.health_cap
self.extra_reset()
img = self.get_img(onehot=self.one_hot_obs)
full_img = self.get_full_img(onehot=self.one_hot_obs)
self.transition_count = {}
# if self.one_hot_obs:
# # ignore second channel since redundant (due to one-to-one mapping btwn color and obj type for now)
# img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in img[:1]])
# full_img = np.concatenate([np.eye(len(self.object_to_idx))[ch].transpose(2, 0, 1) for ch in full_img[:1]])
if self.fully_observed:
if incl_health:
obs = np.concatenate((full_img.flatten(), np.array([self.health]), np.array(self.agent_pos)))
else:
obs = np.concatenate((full_img.flatten(), np.array(self.agent_pos)))
elif self.only_partial_obs:
if incl_health:
obs = np.concatenate((img.flatten(), np.array([self.health])))
else:
obs = img.flatten()
else:
if incl_health:
obs = np.concatenate((img.flatten(), full_img.flatten(), np.array([self.health])))
else:
obs = np.concatenate((img.flatten(), full_img.flatten()))
self.prev_obs_string = obs.tostring()
return obs
def get_full_img(self, scale=1 / 8, onehot=False):
""" Return the whole grid view """
if self.obs_vision:
full_img = self.get_full_obs_render(scale=scale)
else:
full_img = self.grid.encode(self, onehot=onehot)
# NOTE: in case need to scale here instead of in above func call: return cv2.resize(full_img, (0, 0), fx=0.125, fy=0.125, interpolation=cv2.INTER_AREA)
return full_img
def get_img(self, onehot=False):
""" Return the agent view """
if self.obs_vision:
img = self.gen_obs(onehot=False)
img = self.get_obs_render(img, CELL_PIXELS // 4)
else:
img = self.gen_obs(onehot=onehot)
return img
def extra_step(self, action, matched):
return matched
def extra_reset(self):
|
def place_items(self):
pass
def extra_gen_grid(self):
pass
def place_prob(self, obj, prob, top=None, size=None):
if np.random.binomial(1, prob):
pos = self.place_obj(obj, top, size)
obj.cur_pos = pos
return True
return False
def decay_health(self):
self.add_health(-1)
def add_health(self, num):
# clip health between 0 and cap after adjustment
self.health = max(0, min(self.health_cap, self.health + num))
def count_type(self, type):
count = 0
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
if type is None and cell is None or cell is not None and cell.type == type:
count += 1
return count
def count_all_types(self):
counts = {}
for i in range(self.grid_size):
for j in range(self.grid_size):
cell = self.grid.get(i, j)
type = cell.type if cell is not None else ''
counts[type] = counts.get(type | pass | identifier_body |
codeHost.ts | without bleeding CSS to other code hosts (GitLab also uses .file-actions elements).
fileActions.classList.add('sg-github-file-actions')
// Old GitHub Enterprise PR views have a "☑ show comments" text that we want to insert *after*
const showCommentsElement = codeView.querySelector('.show-file-notes')
if (showCommentsElement) {
showCommentsElement.after(mountElement)
} else {
fileActions.prepend(mountElement)
}
return mountElement
}
const toolbarButtonProps = {
className: 'btn btn-sm tooltipped tooltipped-s',
}
const diffCodeView: Omit<CodeView, 'element'> = {
dom: diffDomFunctions,
getToolbarMount: createFileActionsToolbarMount,
resolveFileInfo: resolveDiffFileInfo,
toolbarButtonProps,
getScrollBoundaries: codeView => {
const fileHeader = codeView.querySelector<HTMLElement>('.file-header')
if (!fileHeader) {
throw new Error('Could not find .file-header element in GitHub PR code view')
}
return [fileHeader]
},
}
const diffConversationCodeView: Omit<CodeView, 'element'> = {
...diffCodeView,
getToolbarMount: undefined,
}
const singleFileCodeView: Omit<CodeView, 'element'> = {
dom: singleFileDOMFunctions,
getToolbarMount: createFileActionsToolbarMount,
resolveFileInfo,
toolbarButtonProps,
getSelections: getSelectionsFromHash,
observeSelections: observeSelectionsFromHash,
}
/**
* Some code snippets get leading white space trimmed. This adjusts based on
* this. See an example here https://github.com/sourcegraph/browser-extensions/issues/188.
*/
const getSnippetPositionAdjuster = (
requestGraphQL: PlatformContext['requestGraphQL']
): PositionAdjuster<RepoSpec & RevisionSpec & FileSpec & ResolvedRevisionSpec> => ({ direction, codeView, position }) =>
fetchBlobContentLines({ ...position, requestGraphQL }).pipe(
map(lines => {
const codeElement = singleFileDOMFunctions.getCodeElementFromLineNumber(
codeView,
position.line,
position.part
)
if (!codeElement) {
| const actualLine = lines[position.line - 1]
const documentLine = codeElement.textContent || ''
const actualLeadingWhiteSpace = actualLine.length - trimStart(actualLine).length
const documentLeadingWhiteSpace = documentLine.length - trimStart(documentLine).length
const modifier = direction === AdjustmentDirection.ActualToCodeView ? -1 : 1
const delta = Math.abs(actualLeadingWhiteSpace - documentLeadingWhiteSpace) * modifier
return {
line: position.line,
character: position.character + delta,
}
})
)
const searchResultCodeViewResolver = toCodeViewResolver('.code-list-item', {
dom: searchCodeSnippetDOMFunctions,
getPositionAdjuster: getSnippetPositionAdjuster,
resolveFileInfo: resolveSnippetFileInfo,
toolbarButtonProps,
})
const snippetCodeView: Omit<CodeView, 'element'> = {
dom: singleFileDOMFunctions,
resolveFileInfo: resolveSnippetFileInfo,
getPositionAdjuster: getSnippetPositionAdjuster,
}
export const createFileLineContainerToolbarMount: NonNullable<CodeView['getToolbarMount']> = (
codeViewElement: HTMLElement
): HTMLElement => {
const className = 'sourcegraph-github-file-code-view-toolbar-mount'
const existingMount = codeViewElement.querySelector(`.${className}`) as HTMLElement
if (existingMount) {
return existingMount
}
const mountElement = document.createElement('div')
mountElement.style.display = 'inline-flex'
mountElement.style.verticalAlign = 'middle'
mountElement.style.alignItems = 'center'
mountElement.className = className
const rawURLLink = codeViewElement.querySelector('#raw-url')
const buttonGroup = rawURLLink?.closest('.BtnGroup')
if (!buttonGroup?.parentNode) {
throw new Error('File actions not found')
}
buttonGroup.parentNode.insertBefore(mountElement, buttonGroup)
return mountElement
}
/**
* Matches the modern single-file code view, or snippets embedded in comments.
*
*/
export const fileLineContainerResolver: ViewResolver<CodeView> = {
selector: '.js-file-line-container',
resolveView: (fileLineContainer: HTMLElement): CodeView | null => {
const embeddedBlobWrapper = fileLineContainer.closest('.blob-wrapper-embedded')
if (embeddedBlobWrapper) {
// This is a snippet embedded in a comment.
// Resolve to `.blob-wrapper-embedded`'s parent element,
// the smallest element that contains both the code and
// the HTML anchor allowing to resolve the file info.
const element = embeddedBlobWrapper.parentElement!
return {
element,
...snippetCodeView,
}
}
const { pageType } = parseURL()
if (pageType !== 'blob') {
// this is not a single-file code view
return null
}
const repositoryContent = fileLineContainer.closest('.repository-content')
if (!repositoryContent) {
throw new Error('Could not find repository content element')
}
return {
element: repositoryContent as HTMLElement,
...singleFileCodeView,
getToolbarMount: createFileLineContainerToolbarMount,
}
},
}
const genericCodeViewResolver: ViewResolver<CodeView> = {
selector: target => {
const codeViews = new Set<HTMLElement>()
// Logic to support large diffs that are loaded asynchronously:
// https://github.com/sourcegraph/sourcegraph/issues/18337
// - Don't return `.file` elements that have yet to be loaded (loading is triggered by user)
// - When the user triggers diff loading, the mutation observer will tell us about
// .js-blob-wrapper, since the actual '.file' has been in the DOM the whole time. Return
// the closest ancestor '.file'
for (const file of querySelectorAllOrSelf<HTMLElement>(target, '.file')) {
if (file.querySelectorAll('.js-diff-load-container').length === 0) {
codeViews.add(file)
}
}
for (const blobWrapper of querySelectorAllOrSelf(target, '.js-blob-wrapper')) {
const file = blobWrapper.closest('.file')
if (file instanceof HTMLElement) {
codeViews.add(file)
}
}
return [...codeViews]
},
resolveView: (element: HTMLElement): CodeView | null => {
if (element.querySelector('article.markdown-body')) {
// This code view is rendered markdown, we shouldn't add code intelligence
return null
}
// This is a suggested change on a GitHub PR
if (element.closest('.js-suggested-changes-blob')) {
return null
}
const { pageType } = parseURL()
const isSingleCodeFile =
pageType === 'blob' &&
document.querySelectorAll('.file').length === 1 &&
document.querySelectorAll('.diff-view').length === 0
if (isSingleCodeFile) {
return { element, ...singleFileCodeView }
}
if (element.closest('.discussion-item-body') || element.classList.contains('js-comment-container')) {
// This code view is embedded on a PR conversation page.
return { element, ...diffConversationCodeView }
}
return { element, ...diffCodeView }
},
}
/**
* Returns true if the current page is GitHub Enterprise.
*/
export function checkIsGitHubEnterprise(): boolean {
const ogSiteName = document.head.querySelector<HTMLMetaElement>('meta[property="og:site_name"]')
return (
!!ogSiteName &&
// GitHub Enterprise v2.14.11 has "GitHub" as og:site_name
(ogSiteName.content === 'GitHub Enterprise' || ogSiteName.content === 'GitHub') &&
document.body.classList.contains('enterprise')
)
}
/**
* Returns true if the current page is github.com.
*/
export const checkIsGitHubDotCom = (url = window.location.href): boolean => /^https?:\/\/(www\.)?github\.com/.test(url)
/**
* Returns true if the current page is either github.com or GitHub Enterprise.
*/
export const checkIsGitHub = (): boolean => checkIsGitHubDotCom() || checkIsGitHubEnterprise()
const OPEN_ON_SOURCEGRAPH_ID = 'open-on-sourcegraph'
export const createOpenOnSourcegraphIfNotExists: MountGetter = (container: HTMLElement): HTMLElement | null => {
const pageheadActions = querySelectorOrSelf(container, '.pagehead-actions')
// If ran on page that isn't under a repository namespace.
if (!pageheadActions || pageheadActions.children.length === 0) {
return null
}
// Check for existing
let mount = pageheadActions.querySelector<HTMLElement>('#' + OPEN_ON_SOURCEGRAPH_ID)
if (mount) {
return mount
}
// Create new
mount = document.createElement('li')
mount.id = OPEN_ON_SOURCEGRAPH_ID
pageheadActions.prepend(mount)
return mount
}
const nativeTooltipResolver: ViewResolver<NativeTooltip> = {
selector: '.js-tagsearch-popover',
resolveView: element => ({ element }),
}
const iconClassName = 'icon--github v-align-text-bottom'
const notificationClassNames = {
[NotificationType.Log]: 'flash',
[NotificationType.Success]: 'flash flash-success',
[NotificationType.Info]: 'flash',
[Notification | throw new Error('(adjustPosition) could not find code element for line provided')
}
| conditional_block |
codeHost.ts | without bleeding CSS to other code hosts (GitLab also uses .file-actions elements).
fileActions.classList.add('sg-github-file-actions')
// Old GitHub Enterprise PR views have a "☑ show comments" text that we want to insert *after*
const showCommentsElement = codeView.querySelector('.show-file-notes')
if (showCommentsElement) {
showCommentsElement.after(mountElement)
} else {
fileActions.prepend(mountElement)
}
return mountElement
}
const toolbarButtonProps = {
className: 'btn btn-sm tooltipped tooltipped-s',
}
const diffCodeView: Omit<CodeView, 'element'> = {
dom: diffDomFunctions,
getToolbarMount: createFileActionsToolbarMount,
resolveFileInfo: resolveDiffFileInfo,
toolbarButtonProps,
getScrollBoundaries: codeView => {
const fileHeader = codeView.querySelector<HTMLElement>('.file-header')
if (!fileHeader) {
throw new Error('Could not find .file-header element in GitHub PR code view')
}
return [fileHeader]
},
}
const diffConversationCodeView: Omit<CodeView, 'element'> = {
...diffCodeView,
getToolbarMount: undefined,
}
const singleFileCodeView: Omit<CodeView, 'element'> = {
dom: singleFileDOMFunctions,
getToolbarMount: createFileActionsToolbarMount,
resolveFileInfo,
toolbarButtonProps,
getSelections: getSelectionsFromHash,
observeSelections: observeSelectionsFromHash,
}
/**
* Some code snippets get leading white space trimmed. This adjusts based on
* this. See an example here https://github.com/sourcegraph/browser-extensions/issues/188.
*/
const getSnippetPositionAdjuster = (
requestGraphQL: PlatformContext['requestGraphQL']
): PositionAdjuster<RepoSpec & RevisionSpec & FileSpec & ResolvedRevisionSpec> => ({ direction, codeView, position }) =>
fetchBlobContentLines({ ...position, requestGraphQL }).pipe(
map(lines => {
const codeElement = singleFileDOMFunctions.getCodeElementFromLineNumber(
codeView,
position.line,
position.part
)
if (!codeElement) {
throw new Error('(adjustPosition) could not find code element for line provided')
}
const actualLine = lines[position.line - 1]
const documentLine = codeElement.textContent || ''
const actualLeadingWhiteSpace = actualLine.length - trimStart(actualLine).length
const documentLeadingWhiteSpace = documentLine.length - trimStart(documentLine).length
const modifier = direction === AdjustmentDirection.ActualToCodeView ? -1 : 1
const delta = Math.abs(actualLeadingWhiteSpace - documentLeadingWhiteSpace) * modifier
return {
line: position.line,
character: position.character + delta,
}
})
)
const searchResultCodeViewResolver = toCodeViewResolver('.code-list-item', {
dom: searchCodeSnippetDOMFunctions,
getPositionAdjuster: getSnippetPositionAdjuster,
resolveFileInfo: resolveSnippetFileInfo,
toolbarButtonProps,
})
const snippetCodeView: Omit<CodeView, 'element'> = {
dom: singleFileDOMFunctions,
resolveFileInfo: resolveSnippetFileInfo,
getPositionAdjuster: getSnippetPositionAdjuster,
}
export const createFileLineContainerToolbarMount: NonNullable<CodeView['getToolbarMount']> = (
codeViewElement: HTMLElement
): HTMLElement => {
const className = 'sourcegraph-github-file-code-view-toolbar-mount'
const existingMount = codeViewElement.querySelector(`.${className}`) as HTMLElement
if (existingMount) {
return existingMount
}
const mountElement = document.createElement('div')
mountElement.style.display = 'inline-flex'
mountElement.style.verticalAlign = 'middle'
mountElement.style.alignItems = 'center'
mountElement.className = className
const rawURLLink = codeViewElement.querySelector('#raw-url')
const buttonGroup = rawURLLink?.closest('.BtnGroup')
if (!buttonGroup?.parentNode) {
throw new Error('File actions not found')
}
buttonGroup.parentNode.insertBefore(mountElement, buttonGroup)
return mountElement
}
/**
* Matches the modern single-file code view, or snippets embedded in comments.
*
*/
export const fileLineContainerResolver: ViewResolver<CodeView> = {
selector: '.js-file-line-container',
resolveView: (fileLineContainer: HTMLElement): CodeView | null => {
const embeddedBlobWrapper = fileLineContainer.closest('.blob-wrapper-embedded')
if (embeddedBlobWrapper) {
// This is a snippet embedded in a comment.
// Resolve to `.blob-wrapper-embedded`'s parent element,
// the smallest element that contains both the code and
// the HTML anchor allowing to resolve the file info.
const element = embeddedBlobWrapper.parentElement!
return {
element,
...snippetCodeView,
}
}
const { pageType } = parseURL()
if (pageType !== 'blob') {
// this is not a single-file code view
return null
}
const repositoryContent = fileLineContainer.closest('.repository-content')
if (!repositoryContent) {
throw new Error('Could not find repository content element')
}
return {
element: repositoryContent as HTMLElement,
...singleFileCodeView,
getToolbarMount: createFileLineContainerToolbarMount,
}
},
}
const genericCodeViewResolver: ViewResolver<CodeView> = {
selector: target => {
const codeViews = new Set<HTMLElement>()
// Logic to support large diffs that are loaded asynchronously:
// https://github.com/sourcegraph/sourcegraph/issues/18337
// - Don't return `.file` elements that have yet to be loaded (loading is triggered by user)
// - When the user triggers diff loading, the mutation observer will tell us about
// .js-blob-wrapper, since the actual '.file' has been in the DOM the whole time. Return
// the closest ancestor '.file'
for (const file of querySelectorAllOrSelf<HTMLElement>(target, '.file')) {
if (file.querySelectorAll('.js-diff-load-container').length === 0) {
codeViews.add(file)
}
}
for (const blobWrapper of querySelectorAllOrSelf(target, '.js-blob-wrapper')) {
const file = blobWrapper.closest('.file')
if (file instanceof HTMLElement) {
codeViews.add(file)
}
}
return [...codeViews]
},
resolveView: (element: HTMLElement): CodeView | null => {
if (element.querySelector('article.markdown-body')) {
// This code view is rendered markdown, we shouldn't add code intelligence
return null
}
// This is a suggested change on a GitHub PR
if (element.closest('.js-suggested-changes-blob')) {
return null
}
const { pageType } = parseURL()
const isSingleCodeFile =
pageType === 'blob' &&
document.querySelectorAll('.file').length === 1 &&
document.querySelectorAll('.diff-view').length === 0
if (isSingleCodeFile) {
return { element, ...singleFileCodeView }
}
if (element.closest('.discussion-item-body') || element.classList.contains('js-comment-container')) {
// This code view is embedded on a PR conversation page.
return { element, ...diffConversationCodeView }
}
return { element, ...diffCodeView }
},
}
/**
* Returns true if the current page is GitHub Enterprise.
*/
export function checkIsGitHubEnterprise(): boolean {
| /**
* Returns true if the current page is github.com.
*/
export const checkIsGitHubDotCom = (url = window.location.href): boolean => /^https?:\/\/(www\.)?github\.com/.test(url)
/**
* Returns true if the current page is either github.com or GitHub Enterprise.
*/
export const checkIsGitHub = (): boolean => checkIsGitHubDotCom() || checkIsGitHubEnterprise()
const OPEN_ON_SOURCEGRAPH_ID = 'open-on-sourcegraph'
export const createOpenOnSourcegraphIfNotExists: MountGetter = (container: HTMLElement): HTMLElement | null => {
const pageheadActions = querySelectorOrSelf(container, '.pagehead-actions')
// If ran on page that isn't under a repository namespace.
if (!pageheadActions || pageheadActions.children.length === 0) {
return null
}
// Check for existing
let mount = pageheadActions.querySelector<HTMLElement>('#' + OPEN_ON_SOURCEGRAPH_ID)
if (mount) {
return mount
}
// Create new
mount = document.createElement('li')
mount.id = OPEN_ON_SOURCEGRAPH_ID
pageheadActions.prepend(mount)
return mount
}
const nativeTooltipResolver: ViewResolver<NativeTooltip> = {
selector: '.js-tagsearch-popover',
resolveView: element => ({ element }),
}
const iconClassName = 'icon--github v-align-text-bottom'
const notificationClassNames = {
[NotificationType.Log]: 'flash',
[NotificationType.Success]: 'flash flash-success',
[NotificationType.Info]: 'flash',
[Notification | const ogSiteName = document.head.querySelector<HTMLMetaElement>('meta[property="og:site_name"]')
return (
!!ogSiteName &&
// GitHub Enterprise v2.14.11 has "GitHub" as og:site_name
(ogSiteName.content === 'GitHub Enterprise' || ogSiteName.content === 'GitHub') &&
document.body.classList.contains('enterprise')
)
}
| identifier_body |
codeHost.ts | (codeView: HTMLElement): HTMLElement {
const className = 'github-file-actions-toolbar-mount'
const existingMount = codeView.querySelector('.' + className) as HTMLElement
if (existingMount) {
return existingMount
}
const mountElement = document.createElement('div')
mountElement.className = className
const fileActions = codeView.querySelector('.file-actions')
if (!fileActions) {
throw new Error('Could not find GitHub file actions with selector .file-actions')
}
// Add a class to the .file-actions element, so that we can reliably match it in
// stylesheets without bleeding CSS to other code hosts (GitLab also uses .file-actions elements).
fileActions.classList.add('sg-github-file-actions')
// Old GitHub Enterprise PR views have a "☑ show comments" text that we want to insert *after*
const showCommentsElement = codeView.querySelector('.show-file-notes')
if (showCommentsElement) {
showCommentsElement.after(mountElement)
} else {
fileActions.prepend(mountElement)
}
return mountElement
}
const toolbarButtonProps = {
className: 'btn btn-sm tooltipped tooltipped-s',
}
const diffCodeView: Omit<CodeView, 'element'> = {
dom: diffDomFunctions,
getToolbarMount: createFileActionsToolbarMount,
resolveFileInfo: resolveDiffFileInfo,
toolbarButtonProps,
getScrollBoundaries: codeView => {
const fileHeader = codeView.querySelector<HTMLElement>('.file-header')
if (!fileHeader) {
throw new Error('Could not find .file-header element in GitHub PR code view')
}
return [fileHeader]
},
}
const diffConversationCodeView: Omit<CodeView, 'element'> = {
...diffCodeView,
getToolbarMount: undefined,
}
const singleFileCodeView: Omit<CodeView, 'element'> = {
dom: singleFileDOMFunctions,
getToolbarMount: createFileActionsToolbarMount,
resolveFileInfo,
toolbarButtonProps,
getSelections: getSelectionsFromHash,
observeSelections: observeSelectionsFromHash,
}
/**
* Some code snippets get leading white space trimmed. This adjusts based on
* this. See an example here https://github.com/sourcegraph/browser-extensions/issues/188.
*/
const getSnippetPositionAdjuster = (
requestGraphQL: PlatformContext['requestGraphQL']
): PositionAdjuster<RepoSpec & RevisionSpec & FileSpec & ResolvedRevisionSpec> => ({ direction, codeView, position }) =>
fetchBlobContentLines({ ...position, requestGraphQL }).pipe(
map(lines => {
const codeElement = singleFileDOMFunctions.getCodeElementFromLineNumber(
codeView,
position.line,
position.part
)
if (!codeElement) {
throw new Error('(adjustPosition) could not find code element for line provided')
}
const actualLine = lines[position.line - 1]
const documentLine = codeElement.textContent || ''
const actualLeadingWhiteSpace = actualLine.length - trimStart(actualLine).length
const documentLeadingWhiteSpace = documentLine.length - trimStart(documentLine).length
const modifier = direction === AdjustmentDirection.ActualToCodeView ? -1 : 1
const delta = Math.abs(actualLeadingWhiteSpace - documentLeadingWhiteSpace) * modifier
return {
line: position.line,
character: position.character + delta,
}
})
)
const searchResultCodeViewResolver = toCodeViewResolver('.code-list-item', {
dom: searchCodeSnippetDOMFunctions,
getPositionAdjuster: getSnippetPositionAdjuster,
resolveFileInfo: resolveSnippetFileInfo,
toolbarButtonProps,
})
const snippetCodeView: Omit<CodeView, 'element'> = {
dom: singleFileDOMFunctions,
resolveFileInfo: resolveSnippetFileInfo,
getPositionAdjuster: getSnippetPositionAdjuster,
}
export const createFileLineContainerToolbarMount: NonNullable<CodeView['getToolbarMount']> = (
codeViewElement: HTMLElement
): HTMLElement => {
const className = 'sourcegraph-github-file-code-view-toolbar-mount'
const existingMount = codeViewElement.querySelector(`.${className}`) as HTMLElement
if (existingMount) {
return existingMount
}
const mountElement = document.createElement('div')
mountElement.style.display = 'inline-flex'
mountElement.style.verticalAlign = 'middle'
mountElement.style.alignItems = 'center'
mountElement.className = className
const rawURLLink = codeViewElement.querySelector('#raw-url')
const buttonGroup = rawURLLink?.closest('.BtnGroup')
if (!buttonGroup?.parentNode) {
throw new Error('File actions not found')
}
buttonGroup.parentNode.insertBefore(mountElement, buttonGroup)
return mountElement
}
/**
* Matches the modern single-file code view, or snippets embedded in comments.
*
*/
export const fileLineContainerResolver: ViewResolver<CodeView> = {
selector: '.js-file-line-container',
resolveView: (fileLineContainer: HTMLElement): CodeView | null => {
const embeddedBlobWrapper = fileLineContainer.closest('.blob-wrapper-embedded')
if (embeddedBlobWrapper) {
// This is a snippet embedded in a comment.
// Resolve to `.blob-wrapper-embedded`'s parent element,
// the smallest element that contains both the code and
// the HTML anchor allowing to resolve the file info.
const element = embeddedBlobWrapper.parentElement!
return {
element,
...snippetCodeView,
}
}
const { pageType } = parseURL()
if (pageType !== 'blob') {
// this is not a single-file code view
return null
}
const repositoryContent = fileLineContainer.closest('.repository-content')
if (!repositoryContent) {
throw new Error('Could not find repository content element')
}
return {
element: repositoryContent as HTMLElement,
...singleFileCodeView,
getToolbarMount: createFileLineContainerToolbarMount,
}
},
}
const genericCodeViewResolver: ViewResolver<CodeView> = {
selector: target => {
const codeViews = new Set<HTMLElement>()
// Logic to support large diffs that are loaded asynchronously:
// https://github.com/sourcegraph/sourcegraph/issues/18337
// - Don't return `.file` elements that have yet to be loaded (loading is triggered by user)
// - When the user triggers diff loading, the mutation observer will tell us about
// .js-blob-wrapper, since the actual '.file' has been in the DOM the whole time. Return
// the closest ancestor '.file'
for (const file of querySelectorAllOrSelf<HTMLElement>(target, '.file')) {
if (file.querySelectorAll('.js-diff-load-container').length === 0) {
codeViews.add(file)
}
}
for (const blobWrapper of querySelectorAllOrSelf(target, '.js-blob-wrapper')) {
const file = blobWrapper.closest('.file')
if (file instanceof HTMLElement) {
codeViews.add(file)
}
}
return [...codeViews]
},
resolveView: (element: HTMLElement): CodeView | null => {
if (element.querySelector('article.markdown-body')) {
// This code view is rendered markdown, we shouldn't add code intelligence
return null
}
// This is a suggested change on a GitHub PR
if (element.closest('.js-suggested-changes-blob')) {
return null
}
const { pageType } = parseURL()
const isSingleCodeFile =
pageType === 'blob' &&
document.querySelectorAll('.file').length === 1 &&
document.querySelectorAll('.diff-view').length === 0
if (isSingleCodeFile) {
return { element, ...singleFileCodeView }
}
if (element.closest('.discussion-item-body') || element.classList.contains('js-comment-container')) {
// This code view is embedded on a PR conversation page.
return { element, ...diffConversationCodeView }
}
return { element, ...diffCodeView }
},
}
/**
* Returns true if the current page is GitHub Enterprise.
*/
export function checkIsGitHubEnterprise(): boolean {
const ogSiteName = document.head.querySelector<HTMLMetaElement>('meta[property="og:site_name"]')
return (
!!ogSiteName &&
// GitHub Enterprise v2.14.11 has "GitHub" as og:site_name
(ogSiteName.content === 'GitHub Enterprise' || ogSiteName.content === 'GitHub') &&
document.body.classList.contains('enterprise')
)
}
/**
* Returns true if the current page is github.com.
*/
export const checkIsGitHubDotCom = (url = window.location.href): boolean => /^https?:\/\/(www\.)?github\.com/.test(url)
/**
* Returns true if the current page is either github.com or GitHub Enterprise.
*/
export const checkIsGitHub = (): boolean => checkIsGitHubDotCom() || checkIsGitHubEnterprise()
const OPEN_ON_SOURCEGRAPH_ID = 'open-on-sourcegraph'
export const createOpenOnSourcegraphIfNotExists: MountGetter = (container: HTMLElement): HTMLElement | null => {
const pageheadActions = querySelectorOrSelf(container, '.pagehead-actions')
// If ran on page that isn't under a repository namespace.
if (!pageheadActions || pageheadActions.children.length === 0) {
return null
}
// Check for existing
let mount = pageheadActions.querySelector<HTMLElement>('#' + OPEN_ON_SOURCEGRAPH_ID)
| createFileActionsToolbarMount | identifier_name |
|
codeHost.ts | ',
resolveView: (fileLineContainer: HTMLElement): CodeView | null => {
const embeddedBlobWrapper = fileLineContainer.closest('.blob-wrapper-embedded')
if (embeddedBlobWrapper) {
// This is a snippet embedded in a comment.
// Resolve to `.blob-wrapper-embedded`'s parent element,
// the smallest element that contains both the code and
// the HTML anchor allowing to resolve the file info.
const element = embeddedBlobWrapper.parentElement!
return {
element,
...snippetCodeView,
}
}
const { pageType } = parseURL()
if (pageType !== 'blob') {
// this is not a single-file code view
return null
}
const repositoryContent = fileLineContainer.closest('.repository-content')
if (!repositoryContent) {
throw new Error('Could not find repository content element')
}
return {
element: repositoryContent as HTMLElement,
...singleFileCodeView,
getToolbarMount: createFileLineContainerToolbarMount,
}
},
}
const genericCodeViewResolver: ViewResolver<CodeView> = {
selector: target => {
const codeViews = new Set<HTMLElement>()
// Logic to support large diffs that are loaded asynchronously:
// https://github.com/sourcegraph/sourcegraph/issues/18337
// - Don't return `.file` elements that have yet to be loaded (loading is triggered by user)
// - When the user triggers diff loading, the mutation observer will tell us about
// .js-blob-wrapper, since the actual '.file' has been in the DOM the whole time. Return
// the closest ancestor '.file'
for (const file of querySelectorAllOrSelf<HTMLElement>(target, '.file')) {
if (file.querySelectorAll('.js-diff-load-container').length === 0) {
codeViews.add(file)
}
}
for (const blobWrapper of querySelectorAllOrSelf(target, '.js-blob-wrapper')) {
const file = blobWrapper.closest('.file')
if (file instanceof HTMLElement) {
codeViews.add(file)
}
}
return [...codeViews]
},
resolveView: (element: HTMLElement): CodeView | null => {
if (element.querySelector('article.markdown-body')) {
// This code view is rendered markdown, we shouldn't add code intelligence
return null
}
// This is a suggested change on a GitHub PR
if (element.closest('.js-suggested-changes-blob')) {
return null
}
const { pageType } = parseURL()
const isSingleCodeFile =
pageType === 'blob' &&
document.querySelectorAll('.file').length === 1 &&
document.querySelectorAll('.diff-view').length === 0
if (isSingleCodeFile) {
return { element, ...singleFileCodeView }
}
if (element.closest('.discussion-item-body') || element.classList.contains('js-comment-container')) {
// This code view is embedded on a PR conversation page.
return { element, ...diffConversationCodeView }
}
return { element, ...diffCodeView }
},
}
/**
* Returns true if the current page is GitHub Enterprise.
*/
export function checkIsGitHubEnterprise(): boolean {
const ogSiteName = document.head.querySelector<HTMLMetaElement>('meta[property="og:site_name"]')
return (
!!ogSiteName &&
// GitHub Enterprise v2.14.11 has "GitHub" as og:site_name
(ogSiteName.content === 'GitHub Enterprise' || ogSiteName.content === 'GitHub') &&
document.body.classList.contains('enterprise')
)
}
/**
* Returns true if the current page is github.com.
*/
export const checkIsGitHubDotCom = (url = window.location.href): boolean => /^https?:\/\/(www\.)?github\.com/.test(url)
/**
* Returns true if the current page is either github.com or GitHub Enterprise.
*/
export const checkIsGitHub = (): boolean => checkIsGitHubDotCom() || checkIsGitHubEnterprise()
const OPEN_ON_SOURCEGRAPH_ID = 'open-on-sourcegraph'
export const createOpenOnSourcegraphIfNotExists: MountGetter = (container: HTMLElement): HTMLElement | null => {
const pageheadActions = querySelectorOrSelf(container, '.pagehead-actions')
// If ran on page that isn't under a repository namespace.
if (!pageheadActions || pageheadActions.children.length === 0) {
return null
}
// Check for existing
let mount = pageheadActions.querySelector<HTMLElement>('#' + OPEN_ON_SOURCEGRAPH_ID)
if (mount) {
return mount
}
// Create new
mount = document.createElement('li')
mount.id = OPEN_ON_SOURCEGRAPH_ID
pageheadActions.prepend(mount)
return mount
}
const nativeTooltipResolver: ViewResolver<NativeTooltip> = {
selector: '.js-tagsearch-popover',
resolveView: element => ({ element }),
}
const iconClassName = 'icon--github v-align-text-bottom'
const notificationClassNames = {
[NotificationType.Log]: 'flash',
[NotificationType.Success]: 'flash flash-success',
[NotificationType.Info]: 'flash',
[NotificationType.Warning]: 'flash flash-warn',
[NotificationType.Error]: 'flash flash-error',
}
export const githubCodeHost: CodeHost = {
type: 'github',
name: checkIsGitHubEnterprise() ? 'GitHub Enterprise' : 'GitHub',
codeViewResolvers: [genericCodeViewResolver, fileLineContainerResolver, searchResultCodeViewResolver],
contentViewResolvers: [markdownBodyViewResolver],
nativeTooltipResolvers: [nativeTooltipResolver],
getContext: () => {
const repoHeaderHasPrivateMarker =
!!document.querySelector('.repohead .private') ||
!!document.querySelector('h1 .octicon-lock ~ [itemprop="author"] ~ [itemprop="name"]') ||
!!(
document
.querySelector('h1 [itemprop="author"] ~ [itemprop="name"] ~ .Label')
?.textContent?.trim()
.toLowerCase() === 'private'
)
const parsedURL = parseURL()
return {
...parsedURL,
revision:
parsedURL.pageType === 'blob' || parsedURL.pageType === 'tree'
? resolveFileInfo().blob.revision
: undefined,
privateRepository: window.location.hostname !== 'github.com' || repoHeaderHasPrivateMarker,
}
},
isLightTheme: defer(() => {
const mode = document.documentElement.dataset.colorMode as 'auto' | 'light' | 'dark' | undefined
if (mode === 'auto') {
return observeSystemIsLightTheme()
}
return of(mode !== 'dark')
}),
getViewContextOnSourcegraphMount: createOpenOnSourcegraphIfNotExists,
viewOnSourcegraphButtonClassProps: {
className: 'btn btn-sm tooltipped tooltipped-s',
iconClassName,
},
check: checkIsGitHub,
getCommandPaletteMount,
notificationClassNames,
commandPaletteClassProps: {
buttonClassName: 'Header-link',
popoverClassName: 'Box',
formClassName: 'p-1',
inputClassName: 'form-control input-sm header-search-input jump-to-field',
listClassName: 'p-0 m-0 js-navigation-container jump-to-suggestions-results-container',
selectedListItemClassName: 'navigation-focus',
listItemClassName:
'd-flex flex-justify-start flex-items-center p-0 f5 navigation-item js-navigation-item js-jump-to-scoped-search',
actionItemClassName:
'command-palette-action-item--github no-underline d-flex flex-auto flex-items-center jump-to-suggestions-path p-2',
noResultsClassName: 'd-flex flex-auto flex-items-center jump-to-suggestions-path p-2',
iconClassName,
},
codeViewToolbarClassProps: {
className: 'code-view-toolbar--github',
listItemClass: 'code-view-toolbar__item--github BtnGroup',
actionItemClass: 'btn btn-sm tooltipped tooltipped-s BtnGroup-item action-item--github',
actionItemPressedClass: 'selected',
actionItemIconClass: 'icon--github v-align-text-bottom',
},
hoverOverlayClassProps: {
className: 'Box',
actionItemClassName: 'btn btn-secondary',
actionItemPressedClassName: 'active',
closeButtonClassName: 'btn-octicon p-0 hover-overlay__close-button--github',
badgeClassName: 'label hover-overlay__badge--github',
getAlertClassName: createNotificationClassNameGetter(notificationClassNames, 'flash-full'),
iconClassName,
},
setElementTooltip,
linkPreviewContentClass: 'text-small text-gray p-1 mx-1 border rounded-1 bg-gray text-gray-dark',
urlToFile: (sourcegraphURL, target, context) => {
if (target.viewState) {
// A view state means that a panel must be shown, and panels are currently only supported on
// Sourcegraph (not code hosts).
return toAbsoluteBlobURL(sourcegraphURL, target)
}
// Make sure the location is also on this github instance, return an absolute URL otherwise.
const sameCodeHost = target.rawRepoName.startsWith(window.location.hostname)
if (!sameCodeHost) {
return toAbsoluteBlobURL(sourcegraphURL, target)
}
const revision = target.revision || 'HEAD'
// If we're provided options, we can make the j2d URL more specific.
const { rawRepoName } = parseURL() | random_line_split |
||
edgehub.rs | , BrokerBuilder, BrokerHandle, BrokerReady, BrokerSnapshot, FilePersistor,
MakeMqttPacketProcessor, Message, Persist, Server, ServerCertificate, SystemEvent,
VersionedFileFormat,
};
use mqtt_edgehub::{
auth::{
EdgeHubAuthenticator, EdgeHubAuthorizer, LocalAuthenticator, LocalAuthorizer,
PolicyAuthorizer,
},
command::{
AuthorizedIdentitiesCommand, BridgeUpdateCommand, CommandHandler, DisconnectCommand,
PolicyUpdateCommand,
},
connection::MakeEdgeHubPacketProcessor,
settings::Settings,
};
use super::{shutdown, Bootstrap};
const DEVICE_ID_ENV: &str = "IOTEDGE_DEVICEID";
const IOTHUB_HOSTNAME_ENV: &str = "IOTEDGE_IOTHUBHOSTNAME";
#[derive(Default)]
pub struct EdgeHubBootstrap {
broker_ready: BrokerReady,
}
#[async_trait]
impl Bootstrap for EdgeHubBootstrap {
type Settings = Settings;
fn load_config<P: AsRef<Path>>(&self, path: P) -> Result<Self::Settings> {
info!("loading settings from a file {}", path.as_ref().display());
Ok(Self::Settings::from_file(path)?)
}
type Authorizer = LocalAuthorizer<EdgeHubAuthorizer<PolicyAuthorizer>>;
async fn make_broker(
&self,
settings: &Self::Settings,
) -> Result<(Broker<Self::Authorizer>, FilePersistor<VersionedFileFormat>)> {
info!("loading state...");
let persistence_config = settings.broker().persistence();
let state_dir = persistence_config.file_path();
fs::create_dir_all(state_dir.clone())?;
let mut persistor = FilePersistor::new(state_dir, VersionedFileFormat::default());
let state = persistor.load().await?;
info!("state loaded.");
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let iothub_id = env::var(IOTHUB_HOSTNAME_ENV).context(IOTHUB_HOSTNAME_ENV)?;
let authorizer = LocalAuthorizer::new(EdgeHubAuthorizer::new(
PolicyAuthorizer::new(device_id.clone(), self.broker_ready.handle()),
device_id,
iothub_id,
self.broker_ready.handle(),
));
let broker = BrokerBuilder::default()
.with_authorizer(authorizer)
.with_state(state.unwrap_or_default())
.with_config(settings.broker().clone())
.build();
Ok((broker, persistor))
}
fn snapshot_interval(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().persistence().time_interval()
}
fn session_expiration(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().expiration()
}
fn session_cleanup_interval(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().cleanup_interval()
}
async fn run(
self,
config: Self::Settings,
broker: Broker<Self::Authorizer>,
) -> Result<BrokerSnapshot> {
let broker_handle = broker.handle();
let sidecars = make_sidecars(&broker_handle, &config)?;
info!("starting server...");
let server = make_server(config, broker, self.broker_ready).await?;
let shutdown_signal = shutdown_signal(&server);
let server = tokio::spawn(server.serve(shutdown_signal));
info!("starting sidecars...");
let mut shutdowns = Vec::new();
let mut sidecar_joins = Vec::new();
for sidecar in sidecars {
shutdowns.push(sidecar.shutdown_handle()?);
sidecar_joins.push(tokio::spawn(sidecar.run()));
}
let state = match future::select(server, future::select_all(sidecar_joins)).await {
// server exited first
Either::Left((snapshot, sidecars)) => {
// send shutdown event to each sidecar
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// awaits for at least one to finish
let (_res, _stopped, sidecars) = sidecars.await;
|
snapshot??
}
// one of sidecars exited first
Either::Right(((res, stopped, sidecars), server)) => {
debug!("a sidecar has stopped. shutting down all sidecars...");
if let Err(e) = res {
error!(message = "failed waiting for sidecar shutdown", error = %e);
}
// send shutdown event to each of the rest sidecars
shutdowns.remove(stopped);
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// wait for the rest to exit
future::join_all(sidecars).await;
// signal server
broker_handle.send(Message::System(SystemEvent::Shutdown))?;
server.await??
}
};
Ok(state)
}
}
async fn make_server<Z>(
config: Settings,
broker: Broker<Z>,
broker_ready: BrokerReady,
) -> Result<Server<Z, MakeEdgeHubPacketProcessor<MakeMqttPacketProcessor>>>
where
Z: Authorizer + Send + 'static,
{
let broker_handle = broker.handle();
let make_processor = MakeEdgeHubPacketProcessor::new_default(broker_handle.clone());
let mut server = Server::from_broker(broker).with_packet_processor(make_processor);
// Add system transport to allow communication between edgehub components
let authenticator = LocalAuthenticator::new();
server.with_tcp(config.listener().system().addr(), authenticator, None)?;
// Add regular MQTT over TCP transport
let authenticator = EdgeHubAuthenticator::new(config.auth().url());
if let Some(tcp) = config.listener().tcp() {
let broker_ready = Some(broker_ready.signal());
server.with_tcp(tcp.addr(), authenticator.clone(), broker_ready)?;
}
// Add regular MQTT over TLS transport
if let Some(tls) = config.listener().tls() {
let identity = if let Some(config) = tls.certificate() {
info!("loading identity from {}", config.cert_path().display());
ServerCertificate::from_pem(config.cert_path(), config.private_key_path())
.with_context(|| {
ServerCertificateLoadError::File(
config.cert_path().to_path_buf(),
config.private_key_path().to_path_buf(),
)
})?
} else {
info!("downloading identity from edgelet");
download_server_certificate()
.await
.with_context(|| ServerCertificateLoadError::Edgelet)?
};
let broker_ready = Some(broker_ready.signal());
server.with_tls(tls.addr(), identity, authenticator.clone(), broker_ready)?;
};
Ok(server)
}
fn make_sidecars(
broker_handle: &BrokerHandle,
config: &Settings,
) -> Result<Vec<Box<dyn Sidecar + Send>>> {
let mut sidecars: Vec<Box<dyn Sidecar + Send>> = Vec::new();
let system_address = config.listener().system().addr().to_string();
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let settings = BridgeSettings::new()?;
let bridge_controller =
BridgeController::new(system_address.clone(), device_id.to_owned(), settings);
let bridge_controller_handle = bridge_controller.handle();
sidecars.push(Box::new(bridge_controller));
let mut command_handler = CommandHandler::new(system_address, &device_id);
command_handler.add_command(DisconnectCommand::new(&broker_handle));
command_handler.add_command(AuthorizedIdentitiesCommand::new(&broker_handle));
command_handler.add_command(PolicyUpdateCommand::new(broker_handle));
command_handler.add_command(BridgeUpdateCommand::new(bridge_controller_handle));
sidecars.push(Box::new(command_handler));
Ok(sidecars)
}
pub const WORKLOAD_URI: &str = "IOTEDGE_WORKLOADURI";
pub const EDGE_DEVICE_HOST_NAME: &str = "EdgeDeviceHostName";
pub const MODULE_ID: &str = "IOTEDGE_MODULEID";
pub const MODULE_GENERATION_ID: &str = "IOTEDGE_MODULEGENERATIONID";
pub const CERTIFICATE_VALIDITY_DAYS: i64 = 90;
async fn download_server_certificate() -> Result<ServerCertificate> {
let uri = env::var(WORKLOAD_URI).context(WORKLOAD_URI)?;
let hostname = env::var(EDGE_DEVICE_HOST_NAME).context(EDGE_DEVICE_HOST_NAME)?;
let module_id = env::var(MODULE_ID).context(MODULE_ID)?;
let generation_id = env::var(MODULE_GENERATION_ID).context(MODULE_GENERATION_ID)?;
let expiration = Utc::now() + Duration::days(CERTIFICATE_VALIDITY_DAYS);
let client = edgelet_client::workload(&uri)?;
let cert = client
.create_server_cert(&module_id, &generation_id, &hostname, expiration)
.await?;
if cert.private_key().type_() != "key" {
bail!(
"unknown type of private key: {}",
cert.private_key().type_()
);
}
if let Some(private_key) = cert.private_key().bytes() {
let identity = ServerCertificate::from_pem_pair(cert.certificate(), private_key)?;
Ok(identity)
} else {
bail!("missing private key");
}
}
fn shutdown_signal<Z, P>(server: &Server<Z, P | // wait for the rest to exit
future::join_all(sidecars).await; | random_line_split |
edgehub.rs | , BrokerBuilder, BrokerHandle, BrokerReady, BrokerSnapshot, FilePersistor,
MakeMqttPacketProcessor, Message, Persist, Server, ServerCertificate, SystemEvent,
VersionedFileFormat,
};
use mqtt_edgehub::{
auth::{
EdgeHubAuthenticator, EdgeHubAuthorizer, LocalAuthenticator, LocalAuthorizer,
PolicyAuthorizer,
},
command::{
AuthorizedIdentitiesCommand, BridgeUpdateCommand, CommandHandler, DisconnectCommand,
PolicyUpdateCommand,
},
connection::MakeEdgeHubPacketProcessor,
settings::Settings,
};
use super::{shutdown, Bootstrap};
const DEVICE_ID_ENV: &str = "IOTEDGE_DEVICEID";
const IOTHUB_HOSTNAME_ENV: &str = "IOTEDGE_IOTHUBHOSTNAME";
#[derive(Default)]
pub struct EdgeHubBootstrap {
broker_ready: BrokerReady,
}
#[async_trait]
impl Bootstrap for EdgeHubBootstrap {
type Settings = Settings;
fn load_config<P: AsRef<Path>>(&self, path: P) -> Result<Self::Settings> {
info!("loading settings from a file {}", path.as_ref().display());
Ok(Self::Settings::from_file(path)?)
}
type Authorizer = LocalAuthorizer<EdgeHubAuthorizer<PolicyAuthorizer>>;
async fn make_broker(
&self,
settings: &Self::Settings,
) -> Result<(Broker<Self::Authorizer>, FilePersistor<VersionedFileFormat>)> {
info!("loading state...");
let persistence_config = settings.broker().persistence();
let state_dir = persistence_config.file_path();
fs::create_dir_all(state_dir.clone())?;
let mut persistor = FilePersistor::new(state_dir, VersionedFileFormat::default());
let state = persistor.load().await?;
info!("state loaded.");
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let iothub_id = env::var(IOTHUB_HOSTNAME_ENV).context(IOTHUB_HOSTNAME_ENV)?;
let authorizer = LocalAuthorizer::new(EdgeHubAuthorizer::new(
PolicyAuthorizer::new(device_id.clone(), self.broker_ready.handle()),
device_id,
iothub_id,
self.broker_ready.handle(),
));
let broker = BrokerBuilder::default()
.with_authorizer(authorizer)
.with_state(state.unwrap_or_default())
.with_config(settings.broker().clone())
.build();
Ok((broker, persistor))
}
fn snapshot_interval(&self, settings: &Self::Settings) -> StdDuration |
fn session_expiration(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().expiration()
}
fn session_cleanup_interval(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().cleanup_interval()
}
async fn run(
self,
config: Self::Settings,
broker: Broker<Self::Authorizer>,
) -> Result<BrokerSnapshot> {
let broker_handle = broker.handle();
let sidecars = make_sidecars(&broker_handle, &config)?;
info!("starting server...");
let server = make_server(config, broker, self.broker_ready).await?;
let shutdown_signal = shutdown_signal(&server);
let server = tokio::spawn(server.serve(shutdown_signal));
info!("starting sidecars...");
let mut shutdowns = Vec::new();
let mut sidecar_joins = Vec::new();
for sidecar in sidecars {
shutdowns.push(sidecar.shutdown_handle()?);
sidecar_joins.push(tokio::spawn(sidecar.run()));
}
let state = match future::select(server, future::select_all(sidecar_joins)).await {
// server exited first
Either::Left((snapshot, sidecars)) => {
// send shutdown event to each sidecar
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// awaits for at least one to finish
let (_res, _stopped, sidecars) = sidecars.await;
// wait for the rest to exit
future::join_all(sidecars).await;
snapshot??
}
// one of sidecars exited first
Either::Right(((res, stopped, sidecars), server)) => {
debug!("a sidecar has stopped. shutting down all sidecars...");
if let Err(e) = res {
error!(message = "failed waiting for sidecar shutdown", error = %e);
}
// send shutdown event to each of the rest sidecars
shutdowns.remove(stopped);
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// wait for the rest to exit
future::join_all(sidecars).await;
// signal server
broker_handle.send(Message::System(SystemEvent::Shutdown))?;
server.await??
}
};
Ok(state)
}
}
async fn make_server<Z>(
config: Settings,
broker: Broker<Z>,
broker_ready: BrokerReady,
) -> Result<Server<Z, MakeEdgeHubPacketProcessor<MakeMqttPacketProcessor>>>
where
Z: Authorizer + Send + 'static,
{
let broker_handle = broker.handle();
let make_processor = MakeEdgeHubPacketProcessor::new_default(broker_handle.clone());
let mut server = Server::from_broker(broker).with_packet_processor(make_processor);
// Add system transport to allow communication between edgehub components
let authenticator = LocalAuthenticator::new();
server.with_tcp(config.listener().system().addr(), authenticator, None)?;
// Add regular MQTT over TCP transport
let authenticator = EdgeHubAuthenticator::new(config.auth().url());
if let Some(tcp) = config.listener().tcp() {
let broker_ready = Some(broker_ready.signal());
server.with_tcp(tcp.addr(), authenticator.clone(), broker_ready)?;
}
// Add regular MQTT over TLS transport
if let Some(tls) = config.listener().tls() {
let identity = if let Some(config) = tls.certificate() {
info!("loading identity from {}", config.cert_path().display());
ServerCertificate::from_pem(config.cert_path(), config.private_key_path())
.with_context(|| {
ServerCertificateLoadError::File(
config.cert_path().to_path_buf(),
config.private_key_path().to_path_buf(),
)
})?
} else {
info!("downloading identity from edgelet");
download_server_certificate()
.await
.with_context(|| ServerCertificateLoadError::Edgelet)?
};
let broker_ready = Some(broker_ready.signal());
server.with_tls(tls.addr(), identity, authenticator.clone(), broker_ready)?;
};
Ok(server)
}
fn make_sidecars(
broker_handle: &BrokerHandle,
config: &Settings,
) -> Result<Vec<Box<dyn Sidecar + Send>>> {
let mut sidecars: Vec<Box<dyn Sidecar + Send>> = Vec::new();
let system_address = config.listener().system().addr().to_string();
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let settings = BridgeSettings::new()?;
let bridge_controller =
BridgeController::new(system_address.clone(), device_id.to_owned(), settings);
let bridge_controller_handle = bridge_controller.handle();
sidecars.push(Box::new(bridge_controller));
let mut command_handler = CommandHandler::new(system_address, &device_id);
command_handler.add_command(DisconnectCommand::new(&broker_handle));
command_handler.add_command(AuthorizedIdentitiesCommand::new(&broker_handle));
command_handler.add_command(PolicyUpdateCommand::new(broker_handle));
command_handler.add_command(BridgeUpdateCommand::new(bridge_controller_handle));
sidecars.push(Box::new(command_handler));
Ok(sidecars)
}
pub const WORKLOAD_URI: &str = "IOTEDGE_WORKLOADURI";
pub const EDGE_DEVICE_HOST_NAME: &str = "EdgeDeviceHostName";
pub const MODULE_ID: &str = "IOTEDGE_MODULEID";
pub const MODULE_GENERATION_ID: &str = "IOTEDGE_MODULEGENERATIONID";
pub const CERTIFICATE_VALIDITY_DAYS: i64 = 90;
async fn download_server_certificate() -> Result<ServerCertificate> {
let uri = env::var(WORKLOAD_URI).context(WORKLOAD_URI)?;
let hostname = env::var(EDGE_DEVICE_HOST_NAME).context(EDGE_DEVICE_HOST_NAME)?;
let module_id = env::var(MODULE_ID).context(MODULE_ID)?;
let generation_id = env::var(MODULE_GENERATION_ID).context(MODULE_GENERATION_ID)?;
let expiration = Utc::now() + Duration::days(CERTIFICATE_VALIDITY_DAYS);
let client = edgelet_client::workload(&uri)?;
let cert = client
.create_server_cert(&module_id, &generation_id, &hostname, expiration)
.await?;
if cert.private_key().type_() != "key" {
bail!(
"unknown type of private key: {}",
cert.private_key().type_()
);
}
if let Some(private_key) = cert.private_key().bytes() {
let identity = ServerCertificate::from_pem_pair(cert.certificate(), private_key)?;
Ok(identity)
} else {
bail!("missing private key");
}
}
fn shutdown_signal<Z, P>(server: &Server<Z, | {
settings.broker().persistence().time_interval()
} | identifier_body |
edgehub.rs | , BrokerBuilder, BrokerHandle, BrokerReady, BrokerSnapshot, FilePersistor,
MakeMqttPacketProcessor, Message, Persist, Server, ServerCertificate, SystemEvent,
VersionedFileFormat,
};
use mqtt_edgehub::{
auth::{
EdgeHubAuthenticator, EdgeHubAuthorizer, LocalAuthenticator, LocalAuthorizer,
PolicyAuthorizer,
},
command::{
AuthorizedIdentitiesCommand, BridgeUpdateCommand, CommandHandler, DisconnectCommand,
PolicyUpdateCommand,
},
connection::MakeEdgeHubPacketProcessor,
settings::Settings,
};
use super::{shutdown, Bootstrap};
const DEVICE_ID_ENV: &str = "IOTEDGE_DEVICEID";
const IOTHUB_HOSTNAME_ENV: &str = "IOTEDGE_IOTHUBHOSTNAME";
#[derive(Default)]
pub struct EdgeHubBootstrap {
broker_ready: BrokerReady,
}
#[async_trait]
impl Bootstrap for EdgeHubBootstrap {
type Settings = Settings;
fn load_config<P: AsRef<Path>>(&self, path: P) -> Result<Self::Settings> {
info!("loading settings from a file {}", path.as_ref().display());
Ok(Self::Settings::from_file(path)?)
}
type Authorizer = LocalAuthorizer<EdgeHubAuthorizer<PolicyAuthorizer>>;
async fn make_broker(
&self,
settings: &Self::Settings,
) -> Result<(Broker<Self::Authorizer>, FilePersistor<VersionedFileFormat>)> {
info!("loading state...");
let persistence_config = settings.broker().persistence();
let state_dir = persistence_config.file_path();
fs::create_dir_all(state_dir.clone())?;
let mut persistor = FilePersistor::new(state_dir, VersionedFileFormat::default());
let state = persistor.load().await?;
info!("state loaded.");
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let iothub_id = env::var(IOTHUB_HOSTNAME_ENV).context(IOTHUB_HOSTNAME_ENV)?;
let authorizer = LocalAuthorizer::new(EdgeHubAuthorizer::new(
PolicyAuthorizer::new(device_id.clone(), self.broker_ready.handle()),
device_id,
iothub_id,
self.broker_ready.handle(),
));
let broker = BrokerBuilder::default()
.with_authorizer(authorizer)
.with_state(state.unwrap_or_default())
.with_config(settings.broker().clone())
.build();
Ok((broker, persistor))
}
fn snapshot_interval(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().persistence().time_interval()
}
fn session_expiration(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().expiration()
}
fn | (&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().cleanup_interval()
}
async fn run(
self,
config: Self::Settings,
broker: Broker<Self::Authorizer>,
) -> Result<BrokerSnapshot> {
let broker_handle = broker.handle();
let sidecars = make_sidecars(&broker_handle, &config)?;
info!("starting server...");
let server = make_server(config, broker, self.broker_ready).await?;
let shutdown_signal = shutdown_signal(&server);
let server = tokio::spawn(server.serve(shutdown_signal));
info!("starting sidecars...");
let mut shutdowns = Vec::new();
let mut sidecar_joins = Vec::new();
for sidecar in sidecars {
shutdowns.push(sidecar.shutdown_handle()?);
sidecar_joins.push(tokio::spawn(sidecar.run()));
}
let state = match future::select(server, future::select_all(sidecar_joins)).await {
// server exited first
Either::Left((snapshot, sidecars)) => {
// send shutdown event to each sidecar
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// awaits for at least one to finish
let (_res, _stopped, sidecars) = sidecars.await;
// wait for the rest to exit
future::join_all(sidecars).await;
snapshot??
}
// one of sidecars exited first
Either::Right(((res, stopped, sidecars), server)) => {
debug!("a sidecar has stopped. shutting down all sidecars...");
if let Err(e) = res {
error!(message = "failed waiting for sidecar shutdown", error = %e);
}
// send shutdown event to each of the rest sidecars
shutdowns.remove(stopped);
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// wait for the rest to exit
future::join_all(sidecars).await;
// signal server
broker_handle.send(Message::System(SystemEvent::Shutdown))?;
server.await??
}
};
Ok(state)
}
}
async fn make_server<Z>(
config: Settings,
broker: Broker<Z>,
broker_ready: BrokerReady,
) -> Result<Server<Z, MakeEdgeHubPacketProcessor<MakeMqttPacketProcessor>>>
where
Z: Authorizer + Send + 'static,
{
let broker_handle = broker.handle();
let make_processor = MakeEdgeHubPacketProcessor::new_default(broker_handle.clone());
let mut server = Server::from_broker(broker).with_packet_processor(make_processor);
// Add system transport to allow communication between edgehub components
let authenticator = LocalAuthenticator::new();
server.with_tcp(config.listener().system().addr(), authenticator, None)?;
// Add regular MQTT over TCP transport
let authenticator = EdgeHubAuthenticator::new(config.auth().url());
if let Some(tcp) = config.listener().tcp() {
let broker_ready = Some(broker_ready.signal());
server.with_tcp(tcp.addr(), authenticator.clone(), broker_ready)?;
}
// Add regular MQTT over TLS transport
if let Some(tls) = config.listener().tls() {
let identity = if let Some(config) = tls.certificate() {
info!("loading identity from {}", config.cert_path().display());
ServerCertificate::from_pem(config.cert_path(), config.private_key_path())
.with_context(|| {
ServerCertificateLoadError::File(
config.cert_path().to_path_buf(),
config.private_key_path().to_path_buf(),
)
})?
} else {
info!("downloading identity from edgelet");
download_server_certificate()
.await
.with_context(|| ServerCertificateLoadError::Edgelet)?
};
let broker_ready = Some(broker_ready.signal());
server.with_tls(tls.addr(), identity, authenticator.clone(), broker_ready)?;
};
Ok(server)
}
fn make_sidecars(
broker_handle: &BrokerHandle,
config: &Settings,
) -> Result<Vec<Box<dyn Sidecar + Send>>> {
let mut sidecars: Vec<Box<dyn Sidecar + Send>> = Vec::new();
let system_address = config.listener().system().addr().to_string();
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let settings = BridgeSettings::new()?;
let bridge_controller =
BridgeController::new(system_address.clone(), device_id.to_owned(), settings);
let bridge_controller_handle = bridge_controller.handle();
sidecars.push(Box::new(bridge_controller));
let mut command_handler = CommandHandler::new(system_address, &device_id);
command_handler.add_command(DisconnectCommand::new(&broker_handle));
command_handler.add_command(AuthorizedIdentitiesCommand::new(&broker_handle));
command_handler.add_command(PolicyUpdateCommand::new(broker_handle));
command_handler.add_command(BridgeUpdateCommand::new(bridge_controller_handle));
sidecars.push(Box::new(command_handler));
Ok(sidecars)
}
pub const WORKLOAD_URI: &str = "IOTEDGE_WORKLOADURI";
pub const EDGE_DEVICE_HOST_NAME: &str = "EdgeDeviceHostName";
pub const MODULE_ID: &str = "IOTEDGE_MODULEID";
pub const MODULE_GENERATION_ID: &str = "IOTEDGE_MODULEGENERATIONID";
pub const CERTIFICATE_VALIDITY_DAYS: i64 = 90;
async fn download_server_certificate() -> Result<ServerCertificate> {
let uri = env::var(WORKLOAD_URI).context(WORKLOAD_URI)?;
let hostname = env::var(EDGE_DEVICE_HOST_NAME).context(EDGE_DEVICE_HOST_NAME)?;
let module_id = env::var(MODULE_ID).context(MODULE_ID)?;
let generation_id = env::var(MODULE_GENERATION_ID).context(MODULE_GENERATION_ID)?;
let expiration = Utc::now() + Duration::days(CERTIFICATE_VALIDITY_DAYS);
let client = edgelet_client::workload(&uri)?;
let cert = client
.create_server_cert(&module_id, &generation_id, &hostname, expiration)
.await?;
if cert.private_key().type_() != "key" {
bail!(
"unknown type of private key: {}",
cert.private_key().type_()
);
}
if let Some(private_key) = cert.private_key().bytes() {
let identity = ServerCertificate::from_pem_pair(cert.certificate(), private_key)?;
Ok(identity)
} else {
bail!("missing private key");
}
}
fn shutdown_signal<Z, P>(server: &Server<Z, P | session_cleanup_interval | identifier_name |
edgehub.rs | , BrokerBuilder, BrokerHandle, BrokerReady, BrokerSnapshot, FilePersistor,
MakeMqttPacketProcessor, Message, Persist, Server, ServerCertificate, SystemEvent,
VersionedFileFormat,
};
use mqtt_edgehub::{
auth::{
EdgeHubAuthenticator, EdgeHubAuthorizer, LocalAuthenticator, LocalAuthorizer,
PolicyAuthorizer,
},
command::{
AuthorizedIdentitiesCommand, BridgeUpdateCommand, CommandHandler, DisconnectCommand,
PolicyUpdateCommand,
},
connection::MakeEdgeHubPacketProcessor,
settings::Settings,
};
use super::{shutdown, Bootstrap};
const DEVICE_ID_ENV: &str = "IOTEDGE_DEVICEID";
const IOTHUB_HOSTNAME_ENV: &str = "IOTEDGE_IOTHUBHOSTNAME";
#[derive(Default)]
pub struct EdgeHubBootstrap {
broker_ready: BrokerReady,
}
#[async_trait]
impl Bootstrap for EdgeHubBootstrap {
type Settings = Settings;
fn load_config<P: AsRef<Path>>(&self, path: P) -> Result<Self::Settings> {
info!("loading settings from a file {}", path.as_ref().display());
Ok(Self::Settings::from_file(path)?)
}
type Authorizer = LocalAuthorizer<EdgeHubAuthorizer<PolicyAuthorizer>>;
async fn make_broker(
&self,
settings: &Self::Settings,
) -> Result<(Broker<Self::Authorizer>, FilePersistor<VersionedFileFormat>)> {
info!("loading state...");
let persistence_config = settings.broker().persistence();
let state_dir = persistence_config.file_path();
fs::create_dir_all(state_dir.clone())?;
let mut persistor = FilePersistor::new(state_dir, VersionedFileFormat::default());
let state = persistor.load().await?;
info!("state loaded.");
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let iothub_id = env::var(IOTHUB_HOSTNAME_ENV).context(IOTHUB_HOSTNAME_ENV)?;
let authorizer = LocalAuthorizer::new(EdgeHubAuthorizer::new(
PolicyAuthorizer::new(device_id.clone(), self.broker_ready.handle()),
device_id,
iothub_id,
self.broker_ready.handle(),
));
let broker = BrokerBuilder::default()
.with_authorizer(authorizer)
.with_state(state.unwrap_or_default())
.with_config(settings.broker().clone())
.build();
Ok((broker, persistor))
}
fn snapshot_interval(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().persistence().time_interval()
}
fn session_expiration(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().expiration()
}
fn session_cleanup_interval(&self, settings: &Self::Settings) -> StdDuration {
settings.broker().session().cleanup_interval()
}
async fn run(
self,
config: Self::Settings,
broker: Broker<Self::Authorizer>,
) -> Result<BrokerSnapshot> {
let broker_handle = broker.handle();
let sidecars = make_sidecars(&broker_handle, &config)?;
info!("starting server...");
let server = make_server(config, broker, self.broker_ready).await?;
let shutdown_signal = shutdown_signal(&server);
let server = tokio::spawn(server.serve(shutdown_signal));
info!("starting sidecars...");
let mut shutdowns = Vec::new();
let mut sidecar_joins = Vec::new();
for sidecar in sidecars {
shutdowns.push(sidecar.shutdown_handle()?);
sidecar_joins.push(tokio::spawn(sidecar.run()));
}
let state = match future::select(server, future::select_all(sidecar_joins)).await {
// server exited first
Either::Left((snapshot, sidecars)) => {
// send shutdown event to each sidecar
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// awaits for at least one to finish
let (_res, _stopped, sidecars) = sidecars.await;
// wait for the rest to exit
future::join_all(sidecars).await;
snapshot??
}
// one of sidecars exited first
Either::Right(((res, stopped, sidecars), server)) => |
};
Ok(state)
}
}
async fn make_server<Z>(
config: Settings,
broker: Broker<Z>,
broker_ready: BrokerReady,
) -> Result<Server<Z, MakeEdgeHubPacketProcessor<MakeMqttPacketProcessor>>>
where
Z: Authorizer + Send + 'static,
{
let broker_handle = broker.handle();
let make_processor = MakeEdgeHubPacketProcessor::new_default(broker_handle.clone());
let mut server = Server::from_broker(broker).with_packet_processor(make_processor);
// Add system transport to allow communication between edgehub components
let authenticator = LocalAuthenticator::new();
server.with_tcp(config.listener().system().addr(), authenticator, None)?;
// Add regular MQTT over TCP transport
let authenticator = EdgeHubAuthenticator::new(config.auth().url());
if let Some(tcp) = config.listener().tcp() {
let broker_ready = Some(broker_ready.signal());
server.with_tcp(tcp.addr(), authenticator.clone(), broker_ready)?;
}
// Add regular MQTT over TLS transport
if let Some(tls) = config.listener().tls() {
let identity = if let Some(config) = tls.certificate() {
info!("loading identity from {}", config.cert_path().display());
ServerCertificate::from_pem(config.cert_path(), config.private_key_path())
.with_context(|| {
ServerCertificateLoadError::File(
config.cert_path().to_path_buf(),
config.private_key_path().to_path_buf(),
)
})?
} else {
info!("downloading identity from edgelet");
download_server_certificate()
.await
.with_context(|| ServerCertificateLoadError::Edgelet)?
};
let broker_ready = Some(broker_ready.signal());
server.with_tls(tls.addr(), identity, authenticator.clone(), broker_ready)?;
};
Ok(server)
}
fn make_sidecars(
broker_handle: &BrokerHandle,
config: &Settings,
) -> Result<Vec<Box<dyn Sidecar + Send>>> {
let mut sidecars: Vec<Box<dyn Sidecar + Send>> = Vec::new();
let system_address = config.listener().system().addr().to_string();
let device_id = env::var(DEVICE_ID_ENV).context(DEVICE_ID_ENV)?;
let settings = BridgeSettings::new()?;
let bridge_controller =
BridgeController::new(system_address.clone(), device_id.to_owned(), settings);
let bridge_controller_handle = bridge_controller.handle();
sidecars.push(Box::new(bridge_controller));
let mut command_handler = CommandHandler::new(system_address, &device_id);
command_handler.add_command(DisconnectCommand::new(&broker_handle));
command_handler.add_command(AuthorizedIdentitiesCommand::new(&broker_handle));
command_handler.add_command(PolicyUpdateCommand::new(broker_handle));
command_handler.add_command(BridgeUpdateCommand::new(bridge_controller_handle));
sidecars.push(Box::new(command_handler));
Ok(sidecars)
}
pub const WORKLOAD_URI: &str = "IOTEDGE_WORKLOADURI";
pub const EDGE_DEVICE_HOST_NAME: &str = "EdgeDeviceHostName";
pub const MODULE_ID: &str = "IOTEDGE_MODULEID";
pub const MODULE_GENERATION_ID: &str = "IOTEDGE_MODULEGENERATIONID";
pub const CERTIFICATE_VALIDITY_DAYS: i64 = 90;
async fn download_server_certificate() -> Result<ServerCertificate> {
let uri = env::var(WORKLOAD_URI).context(WORKLOAD_URI)?;
let hostname = env::var(EDGE_DEVICE_HOST_NAME).context(EDGE_DEVICE_HOST_NAME)?;
let module_id = env::var(MODULE_ID).context(MODULE_ID)?;
let generation_id = env::var(MODULE_GENERATION_ID).context(MODULE_GENERATION_ID)?;
let expiration = Utc::now() + Duration::days(CERTIFICATE_VALIDITY_DAYS);
let client = edgelet_client::workload(&uri)?;
let cert = client
.create_server_cert(&module_id, &generation_id, &hostname, expiration)
.await?;
if cert.private_key().type_() != "key" {
bail!(
"unknown type of private key: {}",
cert.private_key().type_()
);
}
if let Some(private_key) = cert.private_key().bytes() {
let identity = ServerCertificate::from_pem_pair(cert.certificate(), private_key)?;
Ok(identity)
} else {
bail!("missing private key");
}
}
fn shutdown_signal<Z, P>(server: &Server<Z, | {
debug!("a sidecar has stopped. shutting down all sidecars...");
if let Err(e) = res {
error!(message = "failed waiting for sidecar shutdown", error = %e);
}
// send shutdown event to each of the rest sidecars
shutdowns.remove(stopped);
let shutdowns = shutdowns.into_iter().map(SidecarShutdownHandle::shutdown);
future::join_all(shutdowns).await;
// wait for the rest to exit
future::join_all(sidecars).await;
// signal server
broker_handle.send(Message::System(SystemEvent::Shutdown))?;
server.await??
} | conditional_block |
utils.ts | city) {
const hex = hexColor.replace('#', '');
const r = parseInt(hex.substring(0, 2), 16);
const g = parseInt(hex.substring(2, 4), 16);
const b = parseInt(hex.substring(4, 6), 16);
const result = `rgba(${r}, ${g}, ${b}, ${opacity})`;
return result;
}
/**
*
* @param target {object}
*/
export function isObject(target) {
return (
Object.prototype.toString.call(target).toLowerCase() === '[object object]'
);
}
/**
*
* @param target {string | any}
*/
export function isString(target) {
return (
Object.prototype.toString.call(target).toLowerCase() === '[object string]'
);
}
/**
*
* @param target {object}
* @param options {object}
*/
export function mergeOptions(target, options) {
if (!isObject(target) || !isObject(options)) {
throw new Error('params must be object');
}
Object.keys(options).forEach(key => {
if (options[key] && !target[key]) {
target[key] = options[key];
return;
}
if (isObject(target[key]) && isObject(options[key])) {
mergeOptions(target[key], options[key]);
} else {
const isType =
Object.prototype.toString.call(options[key]).toLowerCase() ===
Object.prototype.toString.call(target[key]).toLowerCase();
if (!isType && target[key] != undefined) {
throw new Error(`params ${key} must be ${typeof target[key]}`);
} else {
target[key] = options[key];
}
}
});
}
/**
*
* @param ctx
* @param vertex
* @param radius
* @param options
*/
export const drawCircle = (
ctx: any,
vertex: IVertex,
radius,
options: DrawCircleOption
) => {
if (!options.hasOwnProperty('dashed') || options.dashed === false) {
ctx.setLineDash([]);
} else {
const _dashedConfig =
options.dashedConfig && options.dashedConfig.length
? options.dashedConfig
: [5, 5, 5];
ctx.setLineDash(_dashedConfig);
}
const { lineColor, weight, opacity, fillColor } = options;
ctx.beginPath();
ctx.arc(vertex.x, vertex.y, radius, 0, 2 * Math.PI, false);
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.fill();
ctx.lineWidth = weight;
ctx.strokeStyle = lineColor;
ctx.stroke();
};
/**
*
* @param ctx
* @param vertexes
* @param drawPolyOption
*/
export const drawPolygon = (
ctx: any,
vertexes: IVertex[],
drawPolyOption: DrawPolygonOption
) => {
const { lineColor, fillColor, weight, opacity } = drawPolyOption;
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
ctx.beginPath();
ctx.moveTo(vertexes[0].x, vertexes[0].y);
for (let i = 1; i < vertexes.length; i++) {
const { x, y } = vertexes[i];
ctx.lineTo(x, y);
}
ctx.lineTo(vertexes[0].x, vertexes[0].y);
ctx.closePath();
ctx.fill();
ctx.stroke();
};
/**
*
* @param ctx
* @param start
* @param end
* @param drawLineOption
*/
export const drawLine = (
ctx: any,
start: IVertex,
end: IVertex,
drawLineOption: DrawLineOption
): any => {
const { color, weight, opacity, strokeStyle, noStrokeStyle } = drawLineOption;
ctx.beginPath();
ctx.moveTo(start.x, start.y);
ctx.lineTo(end.x, end.y);
if (!noStrokeStyle) {
const style = hex2rgba(color, opacity);
ctx.strokeStyle = strokeStyle ? strokeStyle : style;
}
ctx.lineWidth = weight;
ctx.stroke();
return {
start,
end
};
};
export function drawRect(
ctx: any,
rect: [IVertex, IVertex],
drawRectOption: DrawRectOption
) {
const {
lineColor,
fillColor,
weight,
opacity,
dashed,
dashedConfig
} = drawRectOption;
ctx.beginPath();
// 虚线设置
if (dashed) {
const _dashedConfig =
dashedConfig && dashedConfig.length ? dashedConfig : [5, 5, 5];
ctx.setLineDash(_dashedConfig);
} else {
ctx.setLineDash([]);
}
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
if (fillColor) { ctx.fillStyle = hex2rgba(fillColor, opacity) };
const [{ x: startX, y: startY }, { x: endX, y: endY }] = rect;
const width = endX - startX;
const height = endY - startY;
ctx.rect(startX, startY, width, height);
fillColor && ctx.fill()
ctx.stroke();
return rect;
}
export function drawEllipse(
ctx: any,
ellipse: Ellipse,
drawEllipseOption: DrawEllipseOption
) {
const {
vertex: { x, y },
radius: { minorAxis, macroAxis }
} = ellipse;
const {
fillColor,
opacity,
linearFlag,
linearStartPoint,
linearEndPoint,
startRadius,
endRadius,
colorItems
} = drawEllipseOption;
ctx.save();
let grd = null;
if (linearFlag) {
grd = ctx.createLinearGradient(
linearStartPoint.x,
linearStartPoint.y,
linearEndPoint.x,
linearEndPoint.y
);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
} else {
grd = ctx.createRadialGradient(x, y, startRadius, x, y, endRadius);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
}
ctx.fillStyle = grd;
var step = minorAxis > macroAxis ? 1 / minorAxis : 1 / macroAxis;
ctx.beginPath();
ctx.moveTo(x + minorAxis, y);
for (let i = 0; i < 2 * Math.PI; i += step) {
ctx.lineTo(x + minorAxis * Math.cos(i), y + macroAxis * Math.sin(i));
}
ctx.closePath();
ctx.fill();
}
/**
*
* @param ctx
* @param rect
*/
export const clearCanvas = (
ctx: any,
rect: { width: number; height: number }
) => {
const { width, height } = rect;
ctx.clearRect(0, 0, width, height);
};
/**
*
* @param event {mouseEvent}
*/
export function transformVertex(event, zoom = 1): IVertex {
const { offsetX: x, offsetY: y } = event;
return { x: x / zoom, y: y / zoom };
}
export function isInRect(vertex: IVertex, rect: [IVertex, IVertex]): boolean {
if (
vertex.x > rect[0].x &&
vertex.x < rect[1].x &&
vertex.y > rect[0].y &&
vertex.y < rect[1].y
) {
return true;
}
return false;
}
/**
* 在 canvas 上下文新建一个渐变区域
* @param ctx
* @param option
*/
export const createLinearGradient = (
ctx: CanvasRenderingContext2D,
option: LinearGradientOption
) => {
const { scope, colorSteps } = option;
const [start, end] = scope;
const gradient = ctx.createLinearGradient(start.x, start.y, end.x, end.y);
colorSteps.forEach((step, index) => {
gradient.addColorStop(step.distance, step.color);
});
return gradient;
};
/**
* 获取两个点连线的方向
* @param start IVetex
* @param end IVetex
*/
export function getDirection(start: IVertex, end: IVertex) {
let left: boolean = false;
let top: boolean = false;
let right: boolean = false;
let bottom: boolean = false;
if (start.x <= end.x) {
right = true;
} else {
left = true;
}
if (start.y <= end.y) {
bottom = true;
} else {
top = true;
}
return {
left,
top,
right,
bottom
};
}
/**
* @param start IVertex
* @param end IVertex
* 知道两点, 获取两点连线 斜率 和 纵轴交点
*/
export function getSlopeAndB(
start: IVertex,
end: IVertex
): { slope: number; b: number } {
const { y: y1, x: x1 } = start;
const { y: y2, x: x2 } = end;
const xDistance = x1 - x2;
const yDistance = y1 - y2;
const b = y1 - x1 * (yDistance / xDistance);
return {
| lor, opa | identifier_name |
|
utils.ts | .dashedConfig && options.dashedConfig.length
? options.dashedConfig
: [5, 5, 5];
ctx.setLineDash(_dashedConfig);
}
const { lineColor, weight, opacity, fillColor } = options;
ctx.beginPath();
ctx.arc(vertex.x, vertex.y, radius, 0, 2 * Math.PI, false);
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.fill();
ctx.lineWidth = weight;
ctx.strokeStyle = lineColor;
ctx.stroke();
};
/**
*
* @param ctx
* @param vertexes
* @param drawPolyOption
*/
export const drawPolygon = (
ctx: any,
vertexes: IVertex[],
drawPolyOption: DrawPolygonOption
) => {
const { lineColor, fillColor, weight, opacity } = drawPolyOption;
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
ctx.beginPath();
ctx.moveTo(vertexes[0].x, vertexes[0].y);
for (let i = 1; i < vertexes.length; i++) {
const { x, y } = vertexes[i];
ctx.lineTo(x, y);
}
ctx.lineTo(vertexes[0].x, vertexes[0].y);
ctx.closePath();
ctx.fill();
ctx.stroke();
};
/**
*
* @param ctx
* @param start
* @param end
* @param drawLineOption
*/
export const drawLine = (
ctx: any,
start: IVertex,
end: IVertex,
drawLineOption: DrawLineOption
): any => {
const { color, weight, opacity, strokeStyle, noStrokeStyle } = drawLineOption;
ctx.beginPath();
ctx.moveTo(start.x, start.y);
ctx.lineTo(end.x, end.y);
if (!noStrokeStyle) {
const style = hex2rgba(color, opacity);
ctx.strokeStyle = strokeStyle ? strokeStyle : style;
}
ctx.lineWidth = weight;
ctx.stroke();
return {
start,
end
};
};
export function drawRect(
ctx: any,
rect: [IVertex, IVertex],
drawRectOption: DrawRectOption
) {
const {
lineColor,
fillColor,
weight,
opacity,
dashed,
dashedConfig
} = drawRectOption;
ctx.beginPath();
// 虚线设置
if (dashed) {
const _dashedConfig =
dashedConfig && dashedConfig.length ? dashedConfig : [5, 5, 5];
ctx.setLineDash(_dashedConfig);
} else {
ctx.setLineDash([]);
}
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
if (fillColor) { ctx.fillStyle = hex2rgba(fillColor, opacity) };
const [{ x: startX, y: startY }, { x: endX, y: endY }] = rect;
const width = endX - startX;
const height = endY - startY;
ctx.rect(startX, startY, width, height);
fillColor && ctx.fill()
ctx.stroke();
return rect;
}
export function drawEllipse(
ctx: any,
ellipse: Ellipse,
drawEllipseOption: DrawEllipseOption
) {
const {
vertex: { x, y },
radius: { minorAxis, macroAxis }
} = ellipse;
const {
fillColor,
opacity,
linearFlag,
linearStartPoint,
linearEndPoint,
startRadius,
endRadius,
colorItems
} = drawEllipseOption;
ctx.save();
let grd = null;
if (linearFlag) {
grd = ctx.createLinearGradient(
linearStartPoint.x,
linearStartPoint.y,
linearEndPoint.x,
linearEndPoint.y
);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
} else {
grd = ctx.createRadialGradient(x, y, startRadius, x, y, endRadius);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
}
ctx.fillStyle = grd;
var step = minorAxis > macroAxis ? 1 / minorAxis : 1 / macroAxis;
ctx.beginPath();
ctx.moveTo(x + minorAxis, y);
for (let i = 0; i < 2 * Math.PI; i += step) {
ctx.lineTo(x + minorAxis * Math.cos(i), y + macroAxis * Math.sin(i));
}
ctx.closePath();
ctx.fill();
}
/**
*
* @param ctx
* @param rect
*/
export const clearCanvas = (
ctx: any,
rect: { width: number; height: number }
) => {
const { width, height } = rect;
ctx.clearRect(0, 0, width, height);
};
/**
*
* @param event {mouseEvent}
*/
export function transformVertex(event, zoom = 1): IVertex {
const { offsetX: x, offsetY: y } = event;
return { x: x / zoom, y: y / zoom };
}
export function isInRect(vertex: IVertex, rect: [IVertex, IVertex]): boolean {
if (
vertex.x > rect[0].x &&
vertex.x < rect[1].x &&
vertex.y > rect[0].y &&
vertex.y < rect[1].y
) {
return true;
}
return false;
}
/**
* 在 canvas 上下文新建一个渐变区域
* @param ctx
* @param option
*/
export const createLinearGradient = (
ctx: CanvasRenderingContext2D,
option: LinearGradientOption
) => {
const { scope, colorSteps } = option;
const [start, end] = scope;
const gradient = ctx.createLinearGradient(start.x, start.y, end.x, end.y);
colorSteps.forEach((step, index) => {
gradient.addColorStop(step.distance, step.color);
});
return gradient;
};
/**
* 获取两个点连线的方向
* @param start IVetex
* @param end IVetex | export function getDirection(start: IVertex, end: IVertex) {
let left: boolean = false;
let top: boolean = false;
let right: boolean = false;
let bottom: boolean = false;
if (start.x <= end.x) {
right = true;
} else {
left = true;
}
if (start.y <= end.y) {
bottom = true;
} else {
top = true;
}
return {
left,
top,
right,
bottom
};
}
/**
* @param start IVertex
* @param end IVertex
* 知道两点, 获取两点连线 斜率 和 纵轴交点
*/
export function getSlopeAndB(
start: IVertex,
end: IVertex
): { slope: number; b: number } {
const { y: y1, x: x1 } = start;
const { y: y2, x: x2 } = end;
const xDistance = x1 - x2;
const yDistance = y1 - y2;
const b = y1 - x1 * (yDistance / xDistance);
return {
b,
slope: yDistance / xDistance
};
}
/**
* 按照斜率方程(斜率/纵轴交点) 和 步数以及总步数来 算出下一个点的坐标
* @param start: IVertex,
* @param end: IVertex,
* @param slope: number,
* @param stepIndex: number,
* @param totalStep: number,
* @param b: number
*/
export function getNextVertex(
start: IVertex,
end: IVertex,
slope: number,
stepIndex: number,
totalStep: number,
b: number
): IVertex {
const { y: y1, x: x1 } = start;
const { y: y2, x: x2 } = end;
const xDistance = Math.abs(x1 - x2) * (stepIndex / totalStep);
const direction = getDirection(start, end);
let x = x1 + xDistance;
if (direction.left) {
x = x1 - xDistance;
}
const y = slope * x + b;
return { x, y };
}
export interface ArrowOptions {
strokeStyle: string;
colorFill: [string, string];
}
const defaultArrowOpitons: ArrowOptions = {
strokeStyle: '#68cdfa',
colorFill: ['#68cdfa', '#68cdfa']
};
/* 获取画箭头两端的点 */
export function getArrowPoint(
pixelStart: IVertex,
pixelEnd: IVertex,
length: number = 15
) {
// 绘制箭头的函数
// const length = 12;
const angleValue = Math.PI / 7;
const angle = angleValue; // 箭头和主线的夹角
const r = length; // r/Math.sin(angle)代表箭头长度
let delta = 0; // 主线斜率，垂直时无斜率
let param = 0; // 代码简洁考虑 | */ | random_line_split |
utils.ts |
/**
*
* @param ctx
* @param vertex
* @param radius
* @param options
*/
export const drawCircle = (
ctx: any,
vertex: IVertex,
radius,
options: DrawCircleOption
) => {
if (!options.hasOwnProperty('dashed') || options.dashed === false) {
ctx.setLineDash([]);
} else {
const _dashedConfig =
options.dashedConfig && options.dashedConfig.length
? options.dashedConfig
: [5, 5, 5];
ctx.setLineDash(_dashedConfig);
}
const { lineColor, weight, opacity, fillColor } = options;
ctx.beginPath();
ctx.arc(vertex.x, vertex.y, radius, 0, 2 * Math.PI, false);
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.fill();
ctx.lineWidth = weight;
ctx.strokeStyle = lineColor;
ctx.stroke();
};
/**
*
* @param ctx
* @param vertexes
* @param drawPolyOption
*/
export const drawPolygon = (
ctx: any,
vertexes: IVertex[],
drawPolyOption: DrawPolygonOption
) => {
const { lineColor, fillColor, weight, opacity } = drawPolyOption;
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
ctx.beginPath();
ctx.moveTo(vertexes[0].x, vertexes[0].y);
for (let i = 1; i < vertexes.length; i++) {
const { x, y } = vertexes[i];
ctx.lineTo(x, y);
}
ctx.lineTo(vertexes[0].x, vertexes[0].y);
ctx.closePath();
ctx.fill();
ctx.stroke();
};
/**
*
* @param ctx
* @param start
* @param end
* @param drawLineOption
*/
export const drawLine = (
ctx: any,
start: IVertex,
end: IVertex,
drawLineOption: DrawLineOption
): any => {
const { color, weight, opacity, strokeStyle, noStrokeStyle } = drawLineOption;
ctx.beginPath();
ctx.moveTo(start.x, start.y);
ctx.lineTo(end.x, end.y);
if (!noStrokeStyle) {
const style = hex2rgba(color, opacity);
ctx.strokeStyle = strokeStyle ? strokeStyle : style;
}
ctx.lineWidth = weight;
ctx.stroke();
return {
start,
end
};
};
export function drawRect(
ctx: any,
rect: [IVertex, IVertex],
drawRectOption: DrawRectOption
) {
const {
lineColor,
fillColor,
weight,
opacity,
dashed,
dashedConfig
} = drawRectOption;
ctx.beginPath();
// 虚线设置
if (dashed) {
const _dashedConfig =
dashedConfig && dashedConfig.length ? dashedConfig : [5, 5, 5];
ctx.setLineDash(_dashedConfig);
} else {
ctx.setLineDash([]);
}
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
if (fillColor) { ctx.fillStyle = hex2rgba(fillColor, opacity) };
const [{ x: startX, y: startY }, { x: endX, y: endY }] = rect;
const width = endX - startX;
const height = endY - startY;
ctx.rect(startX, startY, width, height);
fillColor && ctx.fill()
ctx.stroke();
return rect;
}
export function drawEllipse(
ctx: any,
ellipse: Ellipse,
drawEllipseOption: DrawEllipseOption
) {
const {
vertex: { x, y },
radius: { minorAxis, macroAxis }
} = ellipse;
const {
fillColor,
opacity,
linearFlag,
linearStartPoint,
linearEndPoint,
startRadius,
endRadius,
colorItems
} = drawEllipseOption;
ctx.save();
let grd = null;
if (linearFlag) {
grd = ctx.createLinearGradient(
linearStartPoint.x,
linearStartPoint.y,
linearEndPoint.x,
linearEndPoint.y
);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
} else {
grd = ctx.createRadialGradient(x, y, startRadius, x, y, endRadius);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
}
ctx.fillStyle = grd;
var step = minorAxis > macroAxis ? 1 / minorAxis : 1 / macroAxis;
ctx.beginPath();
ctx.moveTo(x + minorAxis, y);
for (let i = 0; i < 2 * Math.PI; i += step) {
ctx.lineTo(x + minorAxis * Math.cos(i), y + macroAxis * Math.sin(i));
}
ctx.closePath();
ctx.fill();
}
/**
*
* @param ctx
* @param rect
*/
export const clearCanvas = (
ctx: any,
rect: { width: number; height: number }
) => {
const { width, height } = rect;
ctx.clearRect(0, 0, width, height);
};
/**
*
* @param event {mouseEvent}
*/
export function transformVertex(event, zoom = 1): IVertex {
const { offsetX: x, offsetY: y } = event;
return { x: x / zoom, y: y / zoom };
}
export function isInRect(vertex: IVertex, rect: [IVertex, IVertex]): boolean {
if (
vertex.x > rect[0].x &&
vertex.x < rect[1].x &&
vertex.y > rect[0].y &&
vertex.y < rect[1].y
) {
return true;
}
return false;
}
/**
* 在 canvas 上下文新建一个渐变区域
* @param ctx
* @param option
*/
export const createLinearGradient = (
ctx: CanvasRenderingContext2D,
option: LinearGradientOption
) => {
const { scope, colorSteps } = option;
const [start, end] = scope;
const gradient = ctx.createLinearGradient(start.x, start.y, end.x, end.y);
colorSteps.forEach((step, index) => {
gradient.addColorStop(step.distance, step.color);
});
return gradient;
};
/**
* 获取两个点连线的方向
* @param start IVetex
* @param end IVetex
*/
export function getDirection(start: IVertex, end: IVertex) {
let left: boolean = false;
let top: boolean = false;
let right: boolean = false;
let bottom: boolean = false;
if (start.x <= end.x) {
right = true;
} else {
left = true;
}
if (start.y <= end.y) {
bottom = true;
} else {
top = true;
}
return {
left,
top,
right,
bottom
};
}
/**
* @param start IVertex
* @param end IVertex
* 知道两点, 获取两点连线 斜率 和 纵轴交点
*/
export function getSlopeAndB(
start: IVertex,
end: IVertex
): { slope: number; b: number } {
const { y: y1, x: x1 } = start;
const { y: y2, x: x2 } = end;
const xDistance = x1 - x2;
const yDistance = y1 - y2;
const b = y1 - x1 * (yDistance / xDistance);
return {
b,
slope: yDistance / xDistance
};
}
/**
* 按照斜率方程(斜率/纵轴交点) 和 步数以及总步数来 算出下一个点的坐标
* @param start: IVertex,
* @param end: IVertex,
* @param slope: number,
* @param stepIndex: number,
* @param totalStep: number,
* @param b: number
*/
export function getNextVertex(
start: IVertex,
end: IVertex,
slope: number,
stepIndex: number,
totalStep: number,
b: number
): IVertex {
const { y: y1, x: x1 } = start;
const { y: y2, x: x2 } = end;
const xDistance = Math.abs(x1 - x2) * (stepIndex / totalStep);
const direction = getDirection(start, end);
let x = x1 + xDistance;
if (direction.left) {
x = x1 - xDistance;
}
const y = slope * x + b;
return { x, y };
}
export interface ArrowOptions {
strokeStyle: string;
colorFill: [string, string];
}
const defaultArrowOpitons: ArrowOptions = {
strokeStyle: '#68cdfa',
colorFill: ['#68cdfa', '#68cdfa']
};
/* 获取画箭头两端的点 */
export function getArrowPoint(
pixelStart: IVertex,
pixelEnd: IVertex,
length | et[key] = options[key];
}
}
});
} | conditional_block |
|
utils.ts | ashedConfig && options.dashedConfig.length
? options.dashedConfig
: [5, 5, 5];
ctx.setLineDash(_dashedConfig);
}
const { lineColor, weight, opacity, fillColor } = options;
ctx.beginPath();
ctx.arc(vertex.x, vertex.y, radius, 0, 2 * Math.PI, false);
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.fill();
ctx.lineWidth = weight;
ctx.strokeStyle = lineColor;
ctx.stroke();
};
/**
*
* @param ctx
* @param vertexes
* @param drawPolyOption
*/
export const drawPolygon = (
ctx: any,
vertexes: IVertex[],
drawPolyOption: DrawPolygonOption
) => {
const { lineColor, fillColor, weight, opacity } = drawPolyOption;
ctx.fillStyle = hex2rgba(fillColor, opacity);
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
ctx.beginPath();
ctx.moveTo(vertexes[0].x, vertexes[0].y);
for (let i = 1; i < vertexes.length; i++) {
const { x, y } = vertexes[i];
ctx.lineTo(x, y);
}
ctx.lineTo(vertexes[0].x, vertexes[0].y);
ctx.closePath();
ctx.fill();
ctx.stroke();
};
/**
*
* @param ctx
* @param start
* @param end
* @param drawLineOption
*/
export const drawLine = (
ctx: any,
start: IVertex,
end: IVertex,
drawLineOption: DrawLineOption
): any => {
const { color, weight, opacity, strokeStyle, noStrokeStyle } = drawLineOption;
ctx.beginPath();
ctx.moveTo(start.x, start.y);
ctx.lineTo(end.x, end.y);
if (!noStrokeStyle) {
const style = hex2rgba(color, opacity);
ctx.strokeStyle = strokeStyle ? strokeStyle : style;
}
ctx.lineWidth = weight;
ctx.stroke();
return {
start,
end
};
};
export function drawRect(
ctx: any,
rect: [IVertex, IVertex],
drawRectOption: DrawRectOption
) {
const {
lineColor,
fillColor,
weight,
opacity,
dashed,
dashedConfig
} = drawRectOption;
ctx.beginPath();
// 虚线设置
if (dashed) {
const _dashedConfig =
dashedConfig && dashedConfig.length ? dashedConfig : [5, 5, 5];
ctx.setLineDash(_dashedConfig);
} else {
ctx.setLineDash([]);
}
ctx.lineWidth = weight;
ctx.strokeStyle = hex2rgba(lineColor, opacity);
if (fillColor) { ctx.fillStyle = hex2rgba(fillColor, opacity) };
const [{ x: startX, y: startY }, { x: endX, y: endY }] = rect;
const width = endX - startX;
const height = endY - startY;
ctx.rect(startX, startY, width, height);
fillColor && ctx.fill()
ctx.stroke();
return rect;
}
export function drawEllipse(
ctx: any,
ellipse: Ellipse,
drawEllipseOption: DrawEllipseOption
) {
const {
vertex: { x, y },
radius: { minorAxis, macroAxis }
} = ellipse;
const {
fillColor,
opacity,
linearFlag,
linearStartPoint,
linearEndPoint,
startRadius,
endRadius,
colorItems
} = drawEllipseOption;
ctx.save();
let grd = null;
if (linearFlag) {
grd = ctx.createLinearGradient(
linearStartPoint.x,
linearStartPoint.y,
linearEndPoint.x,
linearEndPoint.y
);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
} else {
grd = ctx.createRadialGradient(x, y, startRadius, x, y, endRadius);
colorItems.forEach(item => {
grd.addColorStop(item.position, item.color);
});
}
ctx.fillStyle = grd;
var step = minorAxis > macroAxis ? 1 / minorAxis : 1 / macroAxis;
ctx.beginPath();
ctx.moveTo(x + minorAxis, y);
for (let i = 0; i < 2 * Math.PI; i += step) {
ctx.lineTo(x + minorAxis * Math.cos(i), y + macroAxis * Math.sin(i));
}
ctx.closePath();
ctx.fill();
}
/**
*
* @param ctx
* @param rect
*/
export const clearCanvas = (
ctx: any,
rect: { width: number; height: number }
) => {
const { width, height } = rect;
ctx.clearRect(0, 0, width, height);
};
/**
*
* @param event {mouseEvent}
*/
export function transformVertex(event, zoom = 1): IVertex {
const { offsetX: x | Rect(vertex: IVertex, rect: [IVertex, IVertex]): boolean {
if (
vertex.x > rect[0].x &&
vertex.x < rect[1].x &&
vertex.y > rect[0].y &&
vertex.y < rect[1].y
) {
return true;
}
return false;
}
/**
* 在 canvas 上下文新建一个渐变区域
* @param ctx
* @param option
*/
export const createLinearGradient = (
ctx: CanvasRenderingContext2D,
option: LinearGradientOption
) => {
const { scope, colorSteps } = option;
const [start, end] = scope;
const gradient = ctx.createLinearGradient(start.x, start.y, end.x, end.y);
colorSteps.forEach((step, index) => {
gradient.addColorStop(step.distance, step.color);
});
return gradient;
};
/**
* 获取两个点连线的方向
* @param start IVetex
* @param end IVetex
*/
export function getDirection(start: IVertex, end: IVertex) {
let left: boolean = false;
let top: boolean = false;
let right: boolean = false;
let bottom: boolean = false;
if (start.x <= end.x) {
right = true;
} else {
left = true;
}
if (start.y <= end.y) {
bottom = true;
} else {
top = true;
}
return {
left,
top,
right,
bottom
};
}
/**
* @param start IVertex
* @param end IVertex
* 知道两点, 获取两点连线 斜率 和 纵轴交点
*/
export function getSlopeAndB(
start: IVertex,
end: IVertex
): { slope: number; b: number } {
const { y: y1, x: x1 } = start;
const { y: y2, x: x2 } = end;
const xDistance = x1 - x2;
const yDistance = y1 - y2;
const b = y1 - x1 * (yDistance / xDistance);
return {
b,
slope: yDistance / xDistance
};
}
/**
* 按照斜率方程(斜率/纵轴交点) 和 步数以及总步数来 算出下一个点的坐标
* @param start: IVertex,
* @param end: IVertex,
* @param slope: number,
* @param stepIndex: number,
* @param totalStep: number,
* @param b: number
*/
export function getNextVertex(
start: IVertex,
end: IVertex,
slope: number,
stepIndex: number,
totalStep: number,
b: number
): IVertex {
const { y: y1, x: x1 } = start;
const { y: y2, x: x2 } = end;
const xDistance = Math.abs(x1 - x2) * (stepIndex / totalStep);
const direction = getDirection(start, end);
let x = x1 + xDistance;
if (direction.left) {
x = x1 - xDistance;
}
const y = slope * x + b;
return { x, y };
}
export interface ArrowOptions {
strokeStyle: string;
colorFill: [string, string];
}
const defaultArrowOpitons: ArrowOptions = {
strokeStyle: '#68cdfa',
colorFill: ['#68cdfa', '#68cdfa']
};
/* 获取画箭头两端的点 */
export function getArrowPoint(
pixelStart: IVertex,
pixelEnd: IVertex,
length: number = 15
) {
// 绘制箭头的函数
// const length = 12;
const angleValue = Math.PI / 7;
const angle = angleValue; // 箭头和主线的夹角
const r = length; // r/Math.sin(angle)代表箭头长度
let delta = 0; // 主线斜率，垂直时无斜率
let param = 0; // 代码简洁考虑 | , offsetY: y } = event;
return { x: x / zoom, y: y / zoom };
}
export function isIn | identifier_body |
v4-signature.go |
// Sign - local variables
type Sign struct {
accessKeyID string
secretAccessKey string
region string
httpRequest *http.Request
extractedSignedHeaders http.Header
}
// AWS Signature Version '4' constants.
const (
signV4Algorithm = "AWS4-HMAC-SHA256"
iso8601Format = "20060102T150405Z"
yyyymmdd = "20060102"
)
// New - initialize a new authorization checkes.
func New(accessKeyID, secretAccessKey, region string) (*Sign, *probe.Error) {
if !isValidAccessKey.MatchString(accessKeyID) {
return nil, ErrInvalidAccessKeyID("Invalid access key id.", accessKeyID).Trace(accessKeyID)
}
if !isValidSecretKey.MatchString(secretAccessKey) {
return nil, ErrInvalidAccessKeyID("Invalid secret key.", secretAccessKey).Trace(secretAccessKey)
}
if region == "" {
return nil, ErrRegionISEmpty("Region is empty.").Trace()
}
signature := &Sign{
accessKeyID: accessKeyID,
secretAccessKey: secretAccessKey,
region: region,
}
return signature, nil
}
// SetHTTPRequestToVerify - sets the http request which needs to be verified.
func (s *Sign) SetHTTPRequestToVerify(r *http.Request) *Sign {
// Do not set http request if its 'nil'.
if r == nil {
return s
}
s.httpRequest = r
return s
}
// getCanonicalHeaders generate a list of request headers with their values
func (s Sign) getCanonicalHeaders(signedHeaders http.Header) string {
var headers []string
vals := make(http.Header)
for k, vv := range signedHeaders {
headers = append(headers, strings.ToLower(k))
vals[strings.ToLower(k)] = vv
}
headers = append(headers, "host")
sort.Strings(headers)
var buf bytes.Buffer
for _, k := range headers {
buf.WriteString(k)
buf.WriteByte(':')
switch {
case k == "host":
buf.WriteString(s.httpRequest.Host)
fallthrough
default:
for idx, v := range vals[k] {
if idx > 0 {
buf.WriteByte(',')
}
buf.WriteString(v)
}
buf.WriteByte('\n')
}
}
return buf.String()
}
// getSignedHeaders generate a string i.e alphabetically sorted, semicolon-separated list of lowercase request header names
func (s Sign) getSignedHeaders(signedHeaders http.Header) string {
var headers []string
for k := range signedHeaders {
headers = append(headers, strings.ToLower(k))
}
headers = append(headers, "host")
sort.Strings(headers)
return strings.Join(headers, ";")
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s *Sign) getCanonicalRequest() string {
payload := s.httpRequest.Header.Get(http.CanonicalHeaderKey("x-amz-content-sha256"))
s.httpRequest.URL.RawQuery = strings.Replace(s.httpRequest.URL.Query().Encode(), "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
s.httpRequest.URL.RawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
payload,
}, "\n")
return canonicalRequest
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s Sign) getPresignedCanonicalRequest(presignedQuery string) string {
rawQuery := strings.Replace(presignedQuery, "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
rawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
"UNSIGNED-PAYLOAD",
}, "\n")
return canonicalRequest
}
// getScope generate a string of a specific date, an AWS region, and a service.
func (s Sign) getScope(t time.Time) string {
scope := strings.Join([]string{
t.Format(yyyymmdd),
s.region,
"s3",
"aws4_request",
}, "/")
return scope
}
// getStringToSign a string based on selected query values.
func (s Sign) getStringToSign(canonicalRequest string, t time.Time) string {
stringToSign := signV4Algorithm + "\n" + t.Format(iso8601Format) + "\n"
stringToSign = stringToSign + s.getScope(t) + "\n"
canonicalRequestBytes := sha256.Sum256([]byte(canonicalRequest))
stringToSign = stringToSign + hex.EncodeToString(canonicalRequestBytes[:])
return stringToSign
}
// getSigningKey hmac seed to calculate final signature.
func (s Sign) getSigningKey(t time.Time) []byte {
secret := s.secretAccessKey
date := sumHMAC([]byte("AWS4"+secret), []byte(t.Format(yyyymmdd)))
region := sumHMAC(date, []byte(s.region))
service := sumHMAC(region, []byte("s3"))
signingKey := sumHMAC(service, []byte("aws4_request"))
return signingKey
}
// getSignature final signature in hexadecimal form.
func (s Sign) getSignature(signingKey []byte, stringToSign string) string {
return hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
}
// DoesPolicySignatureMatch - Verify query headers with post policy
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPolicySignatureMatch(formValues map[string]string) (bool, *probe.Error) {
// Parse credential tag.
credential, err := parseCredential("Credential=" + formValues["X-Amz-Credential"])
if err != nil {
return false, err.Trace(formValues["X-Amz-Credential"])
}
// Verify if the access key id matches.
if credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", credential.accessKeyID).Trace(credential.accessKeyID)
}
// Verify if the region is valid.
reqRegion := credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Parse date string.
t, e := time.Parse(iso8601Format, formValues["X-Amz-Date"])
if e != nil {
return false, probe.NewError(e)
}
signingKey := s.getSigningKey(t)
newSignature := s.getSignature(signingKey, formValues["Policy"])
if newSignature != formValues["X-Amz-Signature"] {
return false, nil
}
return true, nil
}
// DoesPresignedSignatureMatch - Verify query headers with presigned signature
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPresignedSignatureMatch() (bool, *probe.Error) {
// Parse request query string.
preSignValues, err := parsePreSignV4(s.httpRequest.URL.Query())
if err != nil {
return false, err.Trace(s.httpRequest.URL.String())
}
// Verify if the access key id matches.
if preSignValues.Credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", preSignValues.Credential.accessKeyID).Trace(preSignValues.Credential.accessKeyID)
}
// Verify if region is valid.
reqRegion := preSignValues.Credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Extract all the signed headers along with its values.
s.extractedSignedHeaders = extractSignedHeaders(preSignValues.SignedHeaders, s.httpRequest.Header)
// Construct new query | "github.com/minio/minio/pkg/probe"
) | random_line_split |
|
v4-signature.go | es.
func New(accessKeyID, secretAccessKey, region string) (*Sign, *probe.Error) {
if !isValidAccessKey.MatchString(accessKeyID) {
return nil, ErrInvalidAccessKeyID("Invalid access key id.", accessKeyID).Trace(accessKeyID)
}
if !isValidSecretKey.MatchString(secretAccessKey) {
return nil, ErrInvalidAccessKeyID("Invalid secret key.", secretAccessKey).Trace(secretAccessKey)
}
if region == "" {
return nil, ErrRegionISEmpty("Region is empty.").Trace()
}
signature := &Sign{
accessKeyID: accessKeyID,
secretAccessKey: secretAccessKey,
region: region,
}
return signature, nil
}
// SetHTTPRequestToVerify - sets the http request which needs to be verified.
func (s *Sign) SetHTTPRequestToVerify(r *http.Request) *Sign {
// Do not set http request if its 'nil'.
if r == nil {
return s
}
s.httpRequest = r
return s
}
// getCanonicalHeaders generate a list of request headers with their values
func (s Sign) getCanonicalHeaders(signedHeaders http.Header) string {
var headers []string
vals := make(http.Header)
for k, vv := range signedHeaders {
headers = append(headers, strings.ToLower(k))
vals[strings.ToLower(k)] = vv
}
headers = append(headers, "host")
sort.Strings(headers)
var buf bytes.Buffer
for _, k := range headers {
buf.WriteString(k)
buf.WriteByte(':')
switch {
case k == "host":
buf.WriteString(s.httpRequest.Host)
fallthrough
default:
for idx, v := range vals[k] {
if idx > 0 {
buf.WriteByte(',')
}
buf.WriteString(v)
}
buf.WriteByte('\n')
}
}
return buf.String()
}
// getSignedHeaders generate a string i.e alphabetically sorted, semicolon-separated list of lowercase request header names
func (s Sign) getSignedHeaders(signedHeaders http.Header) string {
var headers []string
for k := range signedHeaders {
headers = append(headers, strings.ToLower(k))
}
headers = append(headers, "host")
sort.Strings(headers)
return strings.Join(headers, ";")
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s *Sign) getCanonicalRequest() string {
payload := s.httpRequest.Header.Get(http.CanonicalHeaderKey("x-amz-content-sha256"))
s.httpRequest.URL.RawQuery = strings.Replace(s.httpRequest.URL.Query().Encode(), "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
s.httpRequest.URL.RawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
payload,
}, "\n")
return canonicalRequest
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s Sign) | (presignedQuery string) string {
rawQuery := strings.Replace(presignedQuery, "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
rawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
"UNSIGNED-PAYLOAD",
}, "\n")
return canonicalRequest
}
// getScope generate a string of a specific date, an AWS region, and a service.
func (s Sign) getScope(t time.Time) string {
scope := strings.Join([]string{
t.Format(yyyymmdd),
s.region,
"s3",
"aws4_request",
}, "/")
return scope
}
// getStringToSign a string based on selected query values.
func (s Sign) getStringToSign(canonicalRequest string, t time.Time) string {
stringToSign := signV4Algorithm + "\n" + t.Format(iso8601Format) + "\n"
stringToSign = stringToSign + s.getScope(t) + "\n"
canonicalRequestBytes := sha256.Sum256([]byte(canonicalRequest))
stringToSign = stringToSign + hex.EncodeToString(canonicalRequestBytes[:])
return stringToSign
}
// getSigningKey hmac seed to calculate final signature.
func (s Sign) getSigningKey(t time.Time) []byte {
secret := s.secretAccessKey
date := sumHMAC([]byte("AWS4"+secret), []byte(t.Format(yyyymmdd)))
region := sumHMAC(date, []byte(s.region))
service := sumHMAC(region, []byte("s3"))
signingKey := sumHMAC(service, []byte("aws4_request"))
return signingKey
}
// getSignature final signature in hexadecimal form.
func (s Sign) getSignature(signingKey []byte, stringToSign string) string {
return hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
}
// DoesPolicySignatureMatch - Verify query headers with post policy
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPolicySignatureMatch(formValues map[string]string) (bool, *probe.Error) {
// Parse credential tag.
credential, err := parseCredential("Credential=" + formValues["X-Amz-Credential"])
if err != nil {
return false, err.Trace(formValues["X-Amz-Credential"])
}
// Verify if the access key id matches.
if credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", credential.accessKeyID).Trace(credential.accessKeyID)
}
// Verify if the region is valid.
reqRegion := credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Parse date string.
t, e := time.Parse(iso8601Format, formValues["X-Amz-Date"])
if e != nil {
return false, probe.NewError(e)
}
signingKey := s.getSigningKey(t)
newSignature := s.getSignature(signingKey, formValues["Policy"])
if newSignature != formValues["X-Amz-Signature"] {
return false, nil
}
return true, nil
}
// DoesPresignedSignatureMatch - Verify query headers with presigned signature
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPresignedSignatureMatch() (bool, *probe.Error) {
// Parse request query string.
preSignValues, err := parsePreSignV4(s.httpRequest.URL.Query())
if err != nil {
return false, err.Trace(s.httpRequest.URL.String())
}
// Verify if the access key id matches.
if preSignValues.Credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", preSignValues.Credential.accessKeyID).Trace(preSignValues.Credential.accessKeyID)
}
// Verify if region is valid.
reqRegion := preSignValues.Credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Extract all the signed headers along with its values.
s.extractedSignedHeaders = extractSignedHeaders(preSignValues.SignedHeaders, s.httpRequest.Header)
// Construct new query.
query := make(url.Values)
query.Set("X-Amz-Algorithm", signV4Algorithm)
if time.Now().UTC().Sub(preSignValues.Date) > time.Duration(preSignValues.Expires) {
return false, ErrExpiredPresignRequest("Presigned request already expired, please initiate a new request.")
}
// Save the date and expires.
t := preSignValues.Date
expireSeconds := int(time.Duration(preSignValues.Expires) / time.Second)
// Construct the query.
query.Set("X-Amz-Date", t.Format(iso8601Format))
query.Set("X-Amz-Expires", strconv.Itoa | getPresignedCanonicalRequest | identifier_name |
v4-signature.go | secretAccessKey).Trace(secretAccessKey)
}
if region == "" {
return nil, ErrRegionISEmpty("Region is empty.").Trace()
}
signature := &Sign{
accessKeyID: accessKeyID,
secretAccessKey: secretAccessKey,
region: region,
}
return signature, nil
}
// SetHTTPRequestToVerify - sets the http request which needs to be verified.
func (s *Sign) SetHTTPRequestToVerify(r *http.Request) *Sign {
// Do not set http request if its 'nil'.
if r == nil {
return s
}
s.httpRequest = r
return s
}
// getCanonicalHeaders generate a list of request headers with their values
func (s Sign) getCanonicalHeaders(signedHeaders http.Header) string {
var headers []string
vals := make(http.Header)
for k, vv := range signedHeaders {
headers = append(headers, strings.ToLower(k))
vals[strings.ToLower(k)] = vv
}
headers = append(headers, "host")
sort.Strings(headers)
var buf bytes.Buffer
for _, k := range headers {
buf.WriteString(k)
buf.WriteByte(':')
switch {
case k == "host":
buf.WriteString(s.httpRequest.Host)
fallthrough
default:
for idx, v := range vals[k] {
if idx > 0 {
buf.WriteByte(',')
}
buf.WriteString(v)
}
buf.WriteByte('\n')
}
}
return buf.String()
}
// getSignedHeaders generate a string i.e alphabetically sorted, semicolon-separated list of lowercase request header names
func (s Sign) getSignedHeaders(signedHeaders http.Header) string {
var headers []string
for k := range signedHeaders {
headers = append(headers, strings.ToLower(k))
}
headers = append(headers, "host")
sort.Strings(headers)
return strings.Join(headers, ";")
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s *Sign) getCanonicalRequest() string {
payload := s.httpRequest.Header.Get(http.CanonicalHeaderKey("x-amz-content-sha256"))
s.httpRequest.URL.RawQuery = strings.Replace(s.httpRequest.URL.Query().Encode(), "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
s.httpRequest.URL.RawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
payload,
}, "\n")
return canonicalRequest
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s Sign) getPresignedCanonicalRequest(presignedQuery string) string {
rawQuery := strings.Replace(presignedQuery, "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
rawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
"UNSIGNED-PAYLOAD",
}, "\n")
return canonicalRequest
}
// getScope generate a string of a specific date, an AWS region, and a service.
func (s Sign) getScope(t time.Time) string {
scope := strings.Join([]string{
t.Format(yyyymmdd),
s.region,
"s3",
"aws4_request",
}, "/")
return scope
}
// getStringToSign a string based on selected query values.
func (s Sign) getStringToSign(canonicalRequest string, t time.Time) string {
stringToSign := signV4Algorithm + "\n" + t.Format(iso8601Format) + "\n"
stringToSign = stringToSign + s.getScope(t) + "\n"
canonicalRequestBytes := sha256.Sum256([]byte(canonicalRequest))
stringToSign = stringToSign + hex.EncodeToString(canonicalRequestBytes[:])
return stringToSign
}
// getSigningKey hmac seed to calculate final signature.
func (s Sign) getSigningKey(t time.Time) []byte {
secret := s.secretAccessKey
date := sumHMAC([]byte("AWS4"+secret), []byte(t.Format(yyyymmdd)))
region := sumHMAC(date, []byte(s.region))
service := sumHMAC(region, []byte("s3"))
signingKey := sumHMAC(service, []byte("aws4_request"))
return signingKey
}
// getSignature final signature in hexadecimal form.
func (s Sign) getSignature(signingKey []byte, stringToSign string) string {
return hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
}
// DoesPolicySignatureMatch - Verify query headers with post policy
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPolicySignatureMatch(formValues map[string]string) (bool, *probe.Error) {
// Parse credential tag.
credential, err := parseCredential("Credential=" + formValues["X-Amz-Credential"])
if err != nil {
return false, err.Trace(formValues["X-Amz-Credential"])
}
// Verify if the access key id matches.
if credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", credential.accessKeyID).Trace(credential.accessKeyID)
}
// Verify if the region is valid.
reqRegion := credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Parse date string.
t, e := time.Parse(iso8601Format, formValues["X-Amz-Date"])
if e != nil {
return false, probe.NewError(e)
}
signingKey := s.getSigningKey(t)
newSignature := s.getSignature(signingKey, formValues["Policy"])
if newSignature != formValues["X-Amz-Signature"] {
return false, nil
}
return true, nil
}
// DoesPresignedSignatureMatch - Verify query headers with presigned signature
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPresignedSignatureMatch() (bool, *probe.Error) {
// Parse request query string.
preSignValues, err := parsePreSignV4(s.httpRequest.URL.Query())
if err != nil {
return false, err.Trace(s.httpRequest.URL.String())
}
// Verify if the access key id matches.
if preSignValues.Credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", preSignValues.Credential.accessKeyID).Trace(preSignValues.Credential.accessKeyID)
}
// Verify if region is valid.
reqRegion := preSignValues.Credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Extract all the signed headers along with its values.
s.extractedSignedHeaders = extractSignedHeaders(preSignValues.SignedHeaders, s.httpRequest.Header)
// Construct new query.
query := make(url.Values)
query.Set("X-Amz-Algorithm", signV4Algorithm)
if time.Now().UTC().Sub(preSignValues.Date) > time.Duration(preSignValues.Expires) {
return false, ErrExpiredPresignRequest("Presigned request already expired, please initiate a new request.")
}
// Save the date and expires.
t := preSignValues.Date
expireSeconds := int(time.Duration(preSignValues.Expires) / time.Second)
// Construct the query.
query.Set("X-Amz-Date", t.Format(iso8601Format))
query.Set("X-Amz-Expires", strconv.Itoa(expireSeconds))
query.Set("X-Amz-SignedHeaders", s.getSignedHeaders(s.extractedSignedHeaders))
query.Set("X-Amz-Credential", s.accessKeyID+"/"+s.getScope(t))
// Save other headers available in the request parameters.
for k, v := range s.httpRequest.URL.Query() {
if strings.HasPrefix(strings.ToLower(k), "x-amz") | {
continue
} | conditional_block |
|
v4-signature.go | .
func New(accessKeyID, secretAccessKey, region string) (*Sign, *probe.Error) |
// SetHTTPRequestToVerify - sets the http request which needs to be verified.
func (s *Sign) SetHTTPRequestToVerify(r *http.Request) *Sign {
// Do not set http request if its 'nil'.
if r == nil {
return s
}
s.httpRequest = r
return s
}
// getCanonicalHeaders generate a list of request headers with their values
func (s Sign) getCanonicalHeaders(signedHeaders http.Header) string {
var headers []string
vals := make(http.Header)
for k, vv := range signedHeaders {
headers = append(headers, strings.ToLower(k))
vals[strings.ToLower(k)] = vv
}
headers = append(headers, "host")
sort.Strings(headers)
var buf bytes.Buffer
for _, k := range headers {
buf.WriteString(k)
buf.WriteByte(':')
switch {
case k == "host":
buf.WriteString(s.httpRequest.Host)
fallthrough
default:
for idx, v := range vals[k] {
if idx > 0 {
buf.WriteByte(',')
}
buf.WriteString(v)
}
buf.WriteByte('\n')
}
}
return buf.String()
}
// getSignedHeaders generate a string i.e alphabetically sorted, semicolon-separated list of lowercase request header names
func (s Sign) getSignedHeaders(signedHeaders http.Header) string {
var headers []string
for k := range signedHeaders {
headers = append(headers, strings.ToLower(k))
}
headers = append(headers, "host")
sort.Strings(headers)
return strings.Join(headers, ";")
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s *Sign) getCanonicalRequest() string {
payload := s.httpRequest.Header.Get(http.CanonicalHeaderKey("x-amz-content-sha256"))
s.httpRequest.URL.RawQuery = strings.Replace(s.httpRequest.URL.Query().Encode(), "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
s.httpRequest.URL.RawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
payload,
}, "\n")
return canonicalRequest
}
// getCanonicalRequest generate a canonical request of style
//
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
func (s Sign) getPresignedCanonicalRequest(presignedQuery string) string {
rawQuery := strings.Replace(presignedQuery, "+", "%20", -1)
encodedPath := getURLEncodedName(s.httpRequest.URL.Path)
// Convert any space strings back to "+".
encodedPath = strings.Replace(encodedPath, "+", "%20", -1)
canonicalRequest := strings.Join([]string{
s.httpRequest.Method,
encodedPath,
rawQuery,
s.getCanonicalHeaders(s.extractedSignedHeaders),
s.getSignedHeaders(s.extractedSignedHeaders),
"UNSIGNED-PAYLOAD",
}, "\n")
return canonicalRequest
}
// getScope generate a string of a specific date, an AWS region, and a service.
func (s Sign) getScope(t time.Time) string {
scope := strings.Join([]string{
t.Format(yyyymmdd),
s.region,
"s3",
"aws4_request",
}, "/")
return scope
}
// getStringToSign a string based on selected query values.
func (s Sign) getStringToSign(canonicalRequest string, t time.Time) string {
stringToSign := signV4Algorithm + "\n" + t.Format(iso8601Format) + "\n"
stringToSign = stringToSign + s.getScope(t) + "\n"
canonicalRequestBytes := sha256.Sum256([]byte(canonicalRequest))
stringToSign = stringToSign + hex.EncodeToString(canonicalRequestBytes[:])
return stringToSign
}
// getSigningKey hmac seed to calculate final signature.
func (s Sign) getSigningKey(t time.Time) []byte {
secret := s.secretAccessKey
date := sumHMAC([]byte("AWS4"+secret), []byte(t.Format(yyyymmdd)))
region := sumHMAC(date, []byte(s.region))
service := sumHMAC(region, []byte("s3"))
signingKey := sumHMAC(service, []byte("aws4_request"))
return signingKey
}
// getSignature final signature in hexadecimal form.
func (s Sign) getSignature(signingKey []byte, stringToSign string) string {
return hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
}
// DoesPolicySignatureMatch - Verify query headers with post policy
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-HTTPPOSTConstructPolicy.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPolicySignatureMatch(formValues map[string]string) (bool, *probe.Error) {
// Parse credential tag.
credential, err := parseCredential("Credential=" + formValues["X-Amz-Credential"])
if err != nil {
return false, err.Trace(formValues["X-Amz-Credential"])
}
// Verify if the access key id matches.
if credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", credential.accessKeyID).Trace(credential.accessKeyID)
}
// Verify if the region is valid.
reqRegion := credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Parse date string.
t, e := time.Parse(iso8601Format, formValues["X-Amz-Date"])
if e != nil {
return false, probe.NewError(e)
}
signingKey := s.getSigningKey(t)
newSignature := s.getSignature(signingKey, formValues["Policy"])
if newSignature != formValues["X-Amz-Signature"] {
return false, nil
}
return true, nil
}
// DoesPresignedSignatureMatch - Verify query headers with presigned signature
// - http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
// returns true if matches, false otherwise. if error is not nil then it is always false
func (s *Sign) DoesPresignedSignatureMatch() (bool, *probe.Error) {
// Parse request query string.
preSignValues, err := parsePreSignV4(s.httpRequest.URL.Query())
if err != nil {
return false, err.Trace(s.httpRequest.URL.String())
}
// Verify if the access key id matches.
if preSignValues.Credential.accessKeyID != s.accessKeyID {
return false, ErrInvalidAccessKeyID("Access key id does not match with our records.", preSignValues.Credential.accessKeyID).Trace(preSignValues.Credential.accessKeyID)
}
// Verify if region is valid.
reqRegion := preSignValues.Credential.scope.region
if !isValidRegion(reqRegion, s.region) {
return false, ErrInvalidRegion("Requested region is not recognized.", reqRegion).Trace(reqRegion)
}
// Save region.
s.region = reqRegion
// Extract all the signed headers along with its values.
s.extractedSignedHeaders = extractSignedHeaders(preSignValues.SignedHeaders, s.httpRequest.Header)
// Construct new query.
query := make(url.Values)
query.Set("X-Amz-Algorithm", signV4Algorithm)
if time.Now().UTC().Sub(preSignValues.Date) > time.Duration(preSignValues.Expires) {
return false, ErrExpiredPresignRequest("Presigned request already expired, please initiate a new request.")
}
// Save the date and expires.
t := preSignValues.Date
expireSeconds := int(time.Duration(preSignValues.Expires) / time.Second)
// Construct the query.
query.Set("X-Amz-Date", t.Format(iso8601Format))
query.Set("X-Amz-Expires", strconv.Itoa | {
if !isValidAccessKey.MatchString(accessKeyID) {
return nil, ErrInvalidAccessKeyID("Invalid access key id.", accessKeyID).Trace(accessKeyID)
}
if !isValidSecretKey.MatchString(secretAccessKey) {
return nil, ErrInvalidAccessKeyID("Invalid secret key.", secretAccessKey).Trace(secretAccessKey)
}
if region == "" {
return nil, ErrRegionISEmpty("Region is empty.").Trace()
}
signature := &Sign{
accessKeyID: accessKeyID,
secretAccessKey: secretAccessKey,
region: region,
}
return signature, nil
} | identifier_body |
policy_row.ts | _element.js';
import {loadTimeData} from 'chrome://resources/js/load_time_data.js';
import {Conflict, PolicyConflictElement} from './policy_conflict.js';
import {getTemplate} from './policy_row.html.js';
export interface Policy {
ignored?: boolean;
name: string;
level: string;
link?: string;
scope: string;
source: string;
error: string;
warning: string;
info: string;
value: any;
deprecated?: boolean;
future?: boolean;
allSourcesMerged?: boolean;
conflicts?: Conflict[];
superseded?: Conflict[];
forSigninScreen: boolean;
isExtension: boolean;
}
export class | extends CustomElement {
static override get template() {
return getTemplate();
}
policy: Policy;
private unset_: boolean;
private hasErrors_: boolean;
private hasWarnings_: boolean;
private hasInfos_: boolean;
private hasConflicts_: boolean;
private hasSuperseded_: boolean;
private isMergedValue_: boolean;
private deprecated_: boolean;
private future_: boolean;
connectedCallback() {
const toggle = this.shadowRoot!.querySelector('.policy.row .toggle');
toggle!.addEventListener('click', () => this.toggleExpanded());
const copy = this.shadowRoot!.querySelector('.copy-value');
copy!.addEventListener('click', () => this.copyValue_());
this.setAttribute('role', 'rowgroup');
this.classList.add('policy-data');
}
initialize(policy: Policy) {
this.policy = policy;
this.unset_ = policy.value === undefined;
this.hasErrors_ = !!policy.error;
this.hasWarnings_ = !!policy.warning;
this.hasInfos_ = !!policy.info;
this.hasConflicts_ = !!policy.conflicts;
this.hasSuperseded_ = !!policy.superseded;
this.isMergedValue_ = !!policy.allSourcesMerged;
this.deprecated_ = !!policy.deprecated;
this.future_ = !!policy.future;
// Populate the name column.
const nameDisplay = this.shadowRoot!.querySelector('.name .link span');
nameDisplay!.textContent = policy.name;
if (policy.link) {
const link =
this.shadowRoot!.querySelector('.name .link') as HTMLAnchorElement;
link.href = policy.link;
link.title = loadTimeData.getStringF('policyLearnMore', policy.name);
this.toggleAttribute('no-help-link', false);
} else {
this.toggleAttribute('no-help-link', true);
}
// Populate the remaining columns with policy scope, level and value if a
// value has been set. Otherwise, leave them blank.
if (!this.unset_) {
const scopeDisplay = this.shadowRoot!.querySelector('.scope');
let scope = 'scopeDevice';
if (policy.scope === 'user') {
scope = 'scopeUser';
} else if (policy.scope === 'allUsers') {
scope = 'scopeAllUsers';
}
scopeDisplay!.textContent = loadTimeData.getString(scope);
// Display scope and level as rows instead of columns on space constraint
// devices.
// <if expr="is_android or is_ios">
const scopeRowContentDisplay =
this.shadowRoot!.querySelector('.scope.row .value');
scopeRowContentDisplay!.textContent = loadTimeData.getString(scope);
const levelRowContentDisplay =
this.shadowRoot!.querySelector('.level.row .value');
levelRowContentDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
// </if>
const levelDisplay = this.shadowRoot!.querySelector('.level');
levelDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
const sourceDisplay = this.shadowRoot!.querySelector('.source');
sourceDisplay!.textContent = loadTimeData.getString(policy.source);
// Reduces load on the DOM for long values;
const convertValue = (value: string, format?: boolean) => {
// Skip 'string' policy to avoid unnecessary conversions.
if (typeof value == 'string') {
return value;
}
if (format) {
return JSON.stringify(value, null, 2);
} else {
return JSON.stringify(value, null);
}
};
// If value is longer than 256 characters, truncate and add ellipsis.
const policyValueStr = convertValue(policy.value);
const truncatedValue = policyValueStr.length > 256 ?
`${policyValueStr.substring(0, 256)}\u2026` :
policyValueStr;
const valueDisplay = this.shadowRoot!.querySelector('.value');
valueDisplay!.textContent = truncatedValue;
const copyLink =
this.shadowRoot!.querySelector('.copy .link') as HTMLElement;
copyLink!.title = loadTimeData.getStringF('policyCopyValue', policy.name);
const valueRowContentDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Expanded policy value is formatted.
valueRowContentDisplay!.textContent =
convertValue(policy.value, /*format=*/ true);
const errorRowContentDisplay =
this.shadowRoot!.querySelector('.errors.row .value');
errorRowContentDisplay!.textContent = policy.error;
const warningRowContentDisplay =
this.shadowRoot!.querySelector('.warnings.row .value');
warningRowContentDisplay!.textContent = policy.warning;
const infoRowContentDisplay =
this.shadowRoot!.querySelector('.infos.row .value');
infoRowContentDisplay!.textContent = policy.info;
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
const errorsNotice =
this.hasErrors_ ? loadTimeData.getString('error') : '';
const deprecationNotice =
this.deprecated_ ? loadTimeData.getString('deprecated') : '';
const futureNotice = this.future_ ? loadTimeData.getString('future') : '';
const warningsNotice =
this.hasWarnings_ ? loadTimeData.getString('warning') : '';
const conflictsNotice = this.hasConflicts_ && !this.isMergedValue_ ?
loadTimeData.getString('conflict') :
'';
const ignoredNotice =
this.policy.ignored ? loadTimeData.getString('ignored') : '';
let notice =
[
errorsNotice,
deprecationNotice,
futureNotice,
warningsNotice,
ignoredNotice,
conflictsNotice,
].filter(x => !!x)
.join(', ') ||
loadTimeData.getString('ok');
const supersededNotice = this.hasSuperseded_ && !this.isMergedValue_ ?
loadTimeData.getString('superseding') :
'';
if (supersededNotice) {
// Include superseded notice regardless of other notices
notice += `, ${supersededNotice}`;
}
messagesDisplay!.textContent = notice;
if (policy.conflicts) {
policy.conflicts.forEach(conflict => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(conflict, 'conflictValue');
row.classList!.add('policy-conflict-data');
this.shadowRoot!.appendChild(row);
});
}
if (policy.superseded) {
policy.superseded.forEach(superseded => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(superseded, 'supersededValue');
row.classList!.add('policy-superseded-data');
this.shadowRoot!.appendChild(row);
});
}
} else {
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
messagesDisplay!.textContent = loadTimeData.getString('unset');
}
}
// Copies the policy's value to the clipboard.
private copyValue_() {
const policyValueDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Select the text that will be copied.
const selection = window.getSelection();
const range = window.document.createRange();
range.selectNodeContents(policyValueDisplay as Node);
selection!.removeAllRanges();
selection!.addRange(range);
// Copy the policy value to the clipboard.
navigator.clipboard
.writeText((policyValueDisplay as CustomElement)!.innerText)
.catch(error => {
console.error('Unable to copy policy value to clipboard:', error);
});
}
// Toggle the visibility of an additional row containing the complete text.
private toggleExpanded() {
const warningRowDisplay =
this.shadowRoot!.querySelector('.warnings.row') as CustomElement;
const errorRowDisplay =
this.shadowRoot!.querySelector('.errors.row') as CustomElement;
const infoRowDisplay =
this.shadowRoot!.querySelector('.infos.row') as CustomElement;
const valueRowDisplay =
this.shadowRoot!.querySelector('.value.row') as CustomElement;
// <if expr="is_android or is_ios">
const scopeRowDisplay =
this.shadowRoot!.querySelector('.scope.row') as CustomElement;
scopeRowDisplay.hidden = !scopeRowDisplay.hidden;
const levelRowDisplay =
this.shadowRoot!.querySelector('.level.row') as CustomElement;
levelRowDisplay.hidden = !levelRowDisplay.hidden;
// </if>
valueRowDisplay.hidden = !valueRowDisplay.hidden;
this.classList!.toggle('expanded', !valueRowDisplay.hidden);
this.shadowRoot!.querySelector<CustomElement>('.show-more')!.hidden =
!valueRowDisplay.hidden;
this.shadowRoot!.querySelector<CustomElement>('.show-less')!.hidden =
valueRowDisplay!.hidden;
| PolicyRowElement | identifier_name |
policy_row.ts | _element.js';
import {loadTimeData} from 'chrome://resources/js/load_time_data.js';
import {Conflict, PolicyConflictElement} from './policy_conflict.js';
import {getTemplate} from './policy_row.html.js';
export interface Policy {
ignored?: boolean;
name: string;
level: string;
link?: string;
scope: string;
source: string;
error: string;
warning: string;
info: string;
value: any;
deprecated?: boolean;
future?: boolean;
allSourcesMerged?: boolean;
conflicts?: Conflict[];
superseded?: Conflict[];
forSigninScreen: boolean;
isExtension: boolean;
}
export class PolicyRowElement extends CustomElement {
static override get template() {
return getTemplate();
}
policy: Policy;
private unset_: boolean;
private hasErrors_: boolean;
private hasWarnings_: boolean;
private hasInfos_: boolean;
private hasConflicts_: boolean;
private hasSuperseded_: boolean;
private isMergedValue_: boolean;
private deprecated_: boolean;
private future_: boolean;
connectedCallback() {
const toggle = this.shadowRoot!.querySelector('.policy.row .toggle');
toggle!.addEventListener('click', () => this.toggleExpanded());
const copy = this.shadowRoot!.querySelector('.copy-value');
copy!.addEventListener('click', () => this.copyValue_());
this.setAttribute('role', 'rowgroup');
this.classList.add('policy-data');
}
initialize(policy: Policy) {
this.policy = policy;
this.unset_ = policy.value === undefined;
this.hasErrors_ = !!policy.error;
this.hasWarnings_ = !!policy.warning;
this.hasInfos_ = !!policy.info;
this.hasConflicts_ = !!policy.conflicts;
this.hasSuperseded_ = !!policy.superseded;
this.isMergedValue_ = !!policy.allSourcesMerged;
this.deprecated_ = !!policy.deprecated;
this.future_ = !!policy.future;
// Populate the name column.
const nameDisplay = this.shadowRoot!.querySelector('.name .link span');
nameDisplay!.textContent = policy.name;
if (policy.link) {
const link =
this.shadowRoot!.querySelector('.name .link') as HTMLAnchorElement;
link.href = policy.link;
link.title = loadTimeData.getStringF('policyLearnMore', policy.name);
this.toggleAttribute('no-help-link', false);
} else {
this.toggleAttribute('no-help-link', true);
}
// Populate the remaining columns with policy scope, level and value if a
// value has been set. Otherwise, leave them blank.
if (!this.unset_) {
const scopeDisplay = this.shadowRoot!.querySelector('.scope');
let scope = 'scopeDevice';
if (policy.scope === 'user') {
scope = 'scopeUser';
} else if (policy.scope === 'allUsers') {
scope = 'scopeAllUsers';
}
scopeDisplay!.textContent = loadTimeData.getString(scope);
// Display scope and level as rows instead of columns on space constraint
// devices.
// <if expr="is_android or is_ios">
const scopeRowContentDisplay =
this.shadowRoot!.querySelector('.scope.row .value');
scopeRowContentDisplay!.textContent = loadTimeData.getString(scope);
const levelRowContentDisplay =
this.shadowRoot!.querySelector('.level.row .value');
levelRowContentDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
// </if>
const levelDisplay = this.shadowRoot!.querySelector('.level');
levelDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
const sourceDisplay = this.shadowRoot!.querySelector('.source');
sourceDisplay!.textContent = loadTimeData.getString(policy.source);
// Reduces load on the DOM for long values;
const convertValue = (value: string, format?: boolean) => {
// Skip 'string' policy to avoid unnecessary conversions.
if (typeof value == 'string') |
if (format) {
return JSON.stringify(value, null, 2);
} else {
return JSON.stringify(value, null);
}
};
// If value is longer than 256 characters, truncate and add ellipsis.
const policyValueStr = convertValue(policy.value);
const truncatedValue = policyValueStr.length > 256 ?
`${policyValueStr.substring(0, 256)}\u2026` :
policyValueStr;
const valueDisplay = this.shadowRoot!.querySelector('.value');
valueDisplay!.textContent = truncatedValue;
const copyLink =
this.shadowRoot!.querySelector('.copy .link') as HTMLElement;
copyLink!.title = loadTimeData.getStringF('policyCopyValue', policy.name);
const valueRowContentDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Expanded policy value is formatted.
valueRowContentDisplay!.textContent =
convertValue(policy.value, /*format=*/ true);
const errorRowContentDisplay =
this.shadowRoot!.querySelector('.errors.row .value');
errorRowContentDisplay!.textContent = policy.error;
const warningRowContentDisplay =
this.shadowRoot!.querySelector('.warnings.row .value');
warningRowContentDisplay!.textContent = policy.warning;
const infoRowContentDisplay =
this.shadowRoot!.querySelector('.infos.row .value');
infoRowContentDisplay!.textContent = policy.info;
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
const errorsNotice =
this.hasErrors_ ? loadTimeData.getString('error') : '';
const deprecationNotice =
this.deprecated_ ? loadTimeData.getString('deprecated') : '';
const futureNotice = this.future_ ? loadTimeData.getString('future') : '';
const warningsNotice =
this.hasWarnings_ ? loadTimeData.getString('warning') : '';
const conflictsNotice = this.hasConflicts_ && !this.isMergedValue_ ?
loadTimeData.getString('conflict') :
'';
const ignoredNotice =
this.policy.ignored ? loadTimeData.getString('ignored') : '';
let notice =
[
errorsNotice,
deprecationNotice,
futureNotice,
warningsNotice,
ignoredNotice,
conflictsNotice,
].filter(x => !!x)
.join(', ') ||
loadTimeData.getString('ok');
const supersededNotice = this.hasSuperseded_ && !this.isMergedValue_ ?
loadTimeData.getString('superseding') :
'';
if (supersededNotice) {
// Include superseded notice regardless of other notices
notice += `, ${supersededNotice}`;
}
messagesDisplay!.textContent = notice;
if (policy.conflicts) {
policy.conflicts.forEach(conflict => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(conflict, 'conflictValue');
row.classList!.add('policy-conflict-data');
this.shadowRoot!.appendChild(row);
});
}
if (policy.superseded) {
policy.superseded.forEach(superseded => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(superseded, 'supersededValue');
row.classList!.add('policy-superseded-data');
this.shadowRoot!.appendChild(row);
});
}
} else {
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
messagesDisplay!.textContent = loadTimeData.getString('unset');
}
}
// Copies the policy's value to the clipboard.
private copyValue_() {
const policyValueDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Select the text that will be copied.
const selection = window.getSelection();
const range = window.document.createRange();
range.selectNodeContents(policyValueDisplay as Node);
selection!.removeAllRanges();
selection!.addRange(range);
// Copy the policy value to the clipboard.
navigator.clipboard
.writeText((policyValueDisplay as CustomElement)!.innerText)
.catch(error => {
console.error('Unable to copy policy value to clipboard:', error);
});
}
// Toggle the visibility of an additional row containing the complete text.
private toggleExpanded() {
const warningRowDisplay =
this.shadowRoot!.querySelector('.warnings.row') as CustomElement;
const errorRowDisplay =
this.shadowRoot!.querySelector('.errors.row') as CustomElement;
const infoRowDisplay =
this.shadowRoot!.querySelector('.infos.row') as CustomElement;
const valueRowDisplay =
this.shadowRoot!.querySelector('.value.row') as CustomElement;
// <if expr="is_android or is_ios">
const scopeRowDisplay =
this.shadowRoot!.querySelector('.scope.row') as CustomElement;
scopeRowDisplay.hidden = !scopeRowDisplay.hidden;
const levelRowDisplay =
this.shadowRoot!.querySelector('.level.row') as CustomElement;
levelRowDisplay.hidden = !levelRowDisplay.hidden;
// </if>
valueRowDisplay.hidden = !valueRowDisplay.hidden;
this.classList!.toggle('expanded', !valueRowDisplay.hidden);
this.shadowRoot!.querySelector<CustomElement>('.show-more')!.hidden =
!valueRowDisplay.hidden;
this.shadowRoot!.querySelector<CustomElement>('.show-less')!.hidden =
valueRowDisplay!.hidden;
| {
return value;
} | conditional_block |
policy_row.ts | _element.js';
import {loadTimeData} from 'chrome://resources/js/load_time_data.js';
import {Conflict, PolicyConflictElement} from './policy_conflict.js';
import {getTemplate} from './policy_row.html.js';
export interface Policy {
ignored?: boolean;
name: string;
level: string;
link?: string;
scope: string;
source: string;
error: string;
warning: string;
info: string;
value: any;
deprecated?: boolean;
future?: boolean;
allSourcesMerged?: boolean;
conflicts?: Conflict[];
superseded?: Conflict[];
forSigninScreen: boolean;
isExtension: boolean;
}
export class PolicyRowElement extends CustomElement {
static override get template() |
policy: Policy;
private unset_: boolean;
private hasErrors_: boolean;
private hasWarnings_: boolean;
private hasInfos_: boolean;
private hasConflicts_: boolean;
private hasSuperseded_: boolean;
private isMergedValue_: boolean;
private deprecated_: boolean;
private future_: boolean;
connectedCallback() {
const toggle = this.shadowRoot!.querySelector('.policy.row .toggle');
toggle!.addEventListener('click', () => this.toggleExpanded());
const copy = this.shadowRoot!.querySelector('.copy-value');
copy!.addEventListener('click', () => this.copyValue_());
this.setAttribute('role', 'rowgroup');
this.classList.add('policy-data');
}
initialize(policy: Policy) {
this.policy = policy;
this.unset_ = policy.value === undefined;
this.hasErrors_ = !!policy.error;
this.hasWarnings_ = !!policy.warning;
this.hasInfos_ = !!policy.info;
this.hasConflicts_ = !!policy.conflicts;
this.hasSuperseded_ = !!policy.superseded;
this.isMergedValue_ = !!policy.allSourcesMerged;
this.deprecated_ = !!policy.deprecated;
this.future_ = !!policy.future;
// Populate the name column.
const nameDisplay = this.shadowRoot!.querySelector('.name .link span');
nameDisplay!.textContent = policy.name;
if (policy.link) {
const link =
this.shadowRoot!.querySelector('.name .link') as HTMLAnchorElement;
link.href = policy.link;
link.title = loadTimeData.getStringF('policyLearnMore', policy.name);
this.toggleAttribute('no-help-link', false);
} else {
this.toggleAttribute('no-help-link', true);
}
// Populate the remaining columns with policy scope, level and value if a
// value has been set. Otherwise, leave them blank.
if (!this.unset_) {
const scopeDisplay = this.shadowRoot!.querySelector('.scope');
let scope = 'scopeDevice';
if (policy.scope === 'user') {
scope = 'scopeUser';
} else if (policy.scope === 'allUsers') {
scope = 'scopeAllUsers';
}
scopeDisplay!.textContent = loadTimeData.getString(scope);
// Display scope and level as rows instead of columns on space constraint
// devices.
// <if expr="is_android or is_ios">
const scopeRowContentDisplay =
this.shadowRoot!.querySelector('.scope.row .value');
scopeRowContentDisplay!.textContent = loadTimeData.getString(scope);
const levelRowContentDisplay =
this.shadowRoot!.querySelector('.level.row .value');
levelRowContentDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
// </if>
const levelDisplay = this.shadowRoot!.querySelector('.level');
levelDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
const sourceDisplay = this.shadowRoot!.querySelector('.source');
sourceDisplay!.textContent = loadTimeData.getString(policy.source);
// Reduces load on the DOM for long values;
const convertValue = (value: string, format?: boolean) => {
// Skip 'string' policy to avoid unnecessary conversions.
if (typeof value == 'string') {
return value;
}
if (format) {
return JSON.stringify(value, null, 2);
} else {
return JSON.stringify(value, null);
}
};
// If value is longer than 256 characters, truncate and add ellipsis.
const policyValueStr = convertValue(policy.value);
const truncatedValue = policyValueStr.length > 256 ?
`${policyValueStr.substring(0, 256)}\u2026` :
policyValueStr;
const valueDisplay = this.shadowRoot!.querySelector('.value');
valueDisplay!.textContent = truncatedValue;
const copyLink =
this.shadowRoot!.querySelector('.copy .link') as HTMLElement;
copyLink!.title = loadTimeData.getStringF('policyCopyValue', policy.name);
const valueRowContentDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Expanded policy value is formatted.
valueRowContentDisplay!.textContent =
convertValue(policy.value, /*format=*/ true);
const errorRowContentDisplay =
this.shadowRoot!.querySelector('.errors.row .value');
errorRowContentDisplay!.textContent = policy.error;
const warningRowContentDisplay =
this.shadowRoot!.querySelector('.warnings.row .value');
warningRowContentDisplay!.textContent = policy.warning;
const infoRowContentDisplay =
this.shadowRoot!.querySelector('.infos.row .value');
infoRowContentDisplay!.textContent = policy.info;
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
const errorsNotice =
this.hasErrors_ ? loadTimeData.getString('error') : '';
const deprecationNotice =
this.deprecated_ ? loadTimeData.getString('deprecated') : '';
const futureNotice = this.future_ ? loadTimeData.getString('future') : '';
const warningsNotice =
this.hasWarnings_ ? loadTimeData.getString('warning') : '';
const conflictsNotice = this.hasConflicts_ && !this.isMergedValue_ ?
loadTimeData.getString('conflict') :
'';
const ignoredNotice =
this.policy.ignored ? loadTimeData.getString('ignored') : '';
let notice =
[
errorsNotice,
deprecationNotice,
futureNotice,
warningsNotice,
ignoredNotice,
conflictsNotice,
].filter(x => !!x)
.join(', ') ||
loadTimeData.getString('ok');
const supersededNotice = this.hasSuperseded_ && !this.isMergedValue_ ?
loadTimeData.getString('superseding') :
'';
if (supersededNotice) {
// Include superseded notice regardless of other notices
notice += `, ${supersededNotice}`;
}
messagesDisplay!.textContent = notice;
if (policy.conflicts) {
policy.conflicts.forEach(conflict => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(conflict, 'conflictValue');
row.classList!.add('policy-conflict-data');
this.shadowRoot!.appendChild(row);
});
}
if (policy.superseded) {
policy.superseded.forEach(superseded => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(superseded, 'supersededValue');
row.classList!.add('policy-superseded-data');
this.shadowRoot!.appendChild(row);
});
}
} else {
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
messagesDisplay!.textContent = loadTimeData.getString('unset');
}
}
// Copies the policy's value to the clipboard.
private copyValue_() {
const policyValueDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Select the text that will be copied.
const selection = window.getSelection();
const range = window.document.createRange();
range.selectNodeContents(policyValueDisplay as Node);
selection!.removeAllRanges();
selection!.addRange(range);
// Copy the policy value to the clipboard.
navigator.clipboard
.writeText((policyValueDisplay as CustomElement)!.innerText)
.catch(error => {
console.error('Unable to copy policy value to clipboard:', error);
});
}
// Toggle the visibility of an additional row containing the complete text.
private toggleExpanded() {
const warningRowDisplay =
this.shadowRoot!.querySelector('.warnings.row') as CustomElement;
const errorRowDisplay =
this.shadowRoot!.querySelector('.errors.row') as CustomElement;
const infoRowDisplay =
this.shadowRoot!.querySelector('.infos.row') as CustomElement;
const valueRowDisplay =
this.shadowRoot!.querySelector('.value.row') as CustomElement;
// <if expr="is_android or is_ios">
const scopeRowDisplay =
this.shadowRoot!.querySelector('.scope.row') as CustomElement;
scopeRowDisplay.hidden = !scopeRowDisplay.hidden;
const levelRowDisplay =
this.shadowRoot!.querySelector('.level.row') as CustomElement;
levelRowDisplay.hidden = !levelRowDisplay.hidden;
// </if>
valueRowDisplay.hidden = !valueRowDisplay.hidden;
this.classList!.toggle('expanded', !valueRowDisplay.hidden);
this.shadowRoot!.querySelector<CustomElement>('.show-more')!.hidden =
!valueRowDisplay.hidden;
this.shadowRoot!.querySelector<CustomElement>('.show-less')!.hidden =
valueRowDisplay!.hidden;
| {
return getTemplate();
} | identifier_body |
policy_row.ts | /custom_element.js';
import {loadTimeData} from 'chrome://resources/js/load_time_data.js';
import {Conflict, PolicyConflictElement} from './policy_conflict.js';
import {getTemplate} from './policy_row.html.js';
export interface Policy {
ignored?: boolean;
name: string;
level: string;
link?: string;
scope: string;
source: string;
error: string;
warning: string;
info: string;
value: any;
deprecated?: boolean;
future?: boolean;
allSourcesMerged?: boolean;
conflicts?: Conflict[];
superseded?: Conflict[];
forSigninScreen: boolean;
isExtension: boolean;
}
export class PolicyRowElement extends CustomElement {
static override get template() {
return getTemplate();
}
policy: Policy;
private unset_: boolean;
private hasErrors_: boolean;
private hasWarnings_: boolean;
private hasInfos_: boolean;
private hasConflicts_: boolean;
private hasSuperseded_: boolean;
private isMergedValue_: boolean;
private deprecated_: boolean;
private future_: boolean;
connectedCallback() {
const toggle = this.shadowRoot!.querySelector('.policy.row .toggle');
toggle!.addEventListener('click', () => this.toggleExpanded());
const copy = this.shadowRoot!.querySelector('.copy-value');
copy!.addEventListener('click', () => this.copyValue_());
this.setAttribute('role', 'rowgroup');
this.classList.add('policy-data');
}
initialize(policy: Policy) {
this.policy = policy;
this.unset_ = policy.value === undefined;
this.hasErrors_ = !!policy.error;
this.hasWarnings_ = !!policy.warning;
this.hasInfos_ = !!policy.info;
this.hasConflicts_ = !!policy.conflicts;
this.hasSuperseded_ = !!policy.superseded;
this.isMergedValue_ = !!policy.allSourcesMerged;
this.deprecated_ = !!policy.deprecated;
this.future_ = !!policy.future;
// Populate the name column.
const nameDisplay = this.shadowRoot!.querySelector('.name .link span');
nameDisplay!.textContent = policy.name;
if (policy.link) {
const link =
this.shadowRoot!.querySelector('.name .link') as HTMLAnchorElement;
link.href = policy.link;
link.title = loadTimeData.getStringF('policyLearnMore', policy.name);
this.toggleAttribute('no-help-link', false);
} else {
this.toggleAttribute('no-help-link', true);
}
// Populate the remaining columns with policy scope, level and value if a
// value has been set. Otherwise, leave them blank.
if (!this.unset_) {
const scopeDisplay = this.shadowRoot!.querySelector('.scope');
let scope = 'scopeDevice';
if (policy.scope === 'user') {
scope = 'scopeUser';
} else if (policy.scope === 'allUsers') {
scope = 'scopeAllUsers';
}
scopeDisplay!.textContent = loadTimeData.getString(scope);
// Display scope and level as rows instead of columns on space constraint
// devices.
// <if expr="is_android or is_ios">
const scopeRowContentDisplay =
this.shadowRoot!.querySelector('.scope.row .value');
scopeRowContentDisplay!.textContent = loadTimeData.getString(scope);
const levelRowContentDisplay =
this.shadowRoot!.querySelector('.level.row .value');
levelRowContentDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
// </if>
const levelDisplay = this.shadowRoot!.querySelector('.level');
levelDisplay!.textContent = loadTimeData.getString(
policy.level === 'recommended' ? 'levelRecommended' :
'levelMandatory');
const sourceDisplay = this.shadowRoot!.querySelector('.source');
sourceDisplay!.textContent = loadTimeData.getString(policy.source);
// Reduces load on the DOM for long values;
const convertValue = (value: string, format?: boolean) => { | }
if (format) {
return JSON.stringify(value, null, 2);
} else {
return JSON.stringify(value, null);
}
};
// If value is longer than 256 characters, truncate and add ellipsis.
const policyValueStr = convertValue(policy.value);
const truncatedValue = policyValueStr.length > 256 ?
`${policyValueStr.substring(0, 256)}\u2026` :
policyValueStr;
const valueDisplay = this.shadowRoot!.querySelector('.value');
valueDisplay!.textContent = truncatedValue;
const copyLink =
this.shadowRoot!.querySelector('.copy .link') as HTMLElement;
copyLink!.title = loadTimeData.getStringF('policyCopyValue', policy.name);
const valueRowContentDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Expanded policy value is formatted.
valueRowContentDisplay!.textContent =
convertValue(policy.value, /*format=*/ true);
const errorRowContentDisplay =
this.shadowRoot!.querySelector('.errors.row .value');
errorRowContentDisplay!.textContent = policy.error;
const warningRowContentDisplay =
this.shadowRoot!.querySelector('.warnings.row .value');
warningRowContentDisplay!.textContent = policy.warning;
const infoRowContentDisplay =
this.shadowRoot!.querySelector('.infos.row .value');
infoRowContentDisplay!.textContent = policy.info;
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
const errorsNotice =
this.hasErrors_ ? loadTimeData.getString('error') : '';
const deprecationNotice =
this.deprecated_ ? loadTimeData.getString('deprecated') : '';
const futureNotice = this.future_ ? loadTimeData.getString('future') : '';
const warningsNotice =
this.hasWarnings_ ? loadTimeData.getString('warning') : '';
const conflictsNotice = this.hasConflicts_ && !this.isMergedValue_ ?
loadTimeData.getString('conflict') :
'';
const ignoredNotice =
this.policy.ignored ? loadTimeData.getString('ignored') : '';
let notice =
[
errorsNotice,
deprecationNotice,
futureNotice,
warningsNotice,
ignoredNotice,
conflictsNotice,
].filter(x => !!x)
.join(', ') ||
loadTimeData.getString('ok');
const supersededNotice = this.hasSuperseded_ && !this.isMergedValue_ ?
loadTimeData.getString('superseding') :
'';
if (supersededNotice) {
// Include superseded notice regardless of other notices
notice += `, ${supersededNotice}`;
}
messagesDisplay!.textContent = notice;
if (policy.conflicts) {
policy.conflicts.forEach(conflict => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(conflict, 'conflictValue');
row.classList!.add('policy-conflict-data');
this.shadowRoot!.appendChild(row);
});
}
if (policy.superseded) {
policy.superseded.forEach(superseded => {
const row = document.createElement('policy-conflict') as
PolicyConflictElement;
row.initialize(superseded, 'supersededValue');
row.classList!.add('policy-superseded-data');
this.shadowRoot!.appendChild(row);
});
}
} else {
const messagesDisplay = this.shadowRoot!.querySelector('.messages');
messagesDisplay!.textContent = loadTimeData.getString('unset');
}
}
// Copies the policy's value to the clipboard.
private copyValue_() {
const policyValueDisplay =
this.shadowRoot!.querySelector('.value.row .value');
// Select the text that will be copied.
const selection = window.getSelection();
const range = window.document.createRange();
range.selectNodeContents(policyValueDisplay as Node);
selection!.removeAllRanges();
selection!.addRange(range);
// Copy the policy value to the clipboard.
navigator.clipboard
.writeText((policyValueDisplay as CustomElement)!.innerText)
.catch(error => {
console.error('Unable to copy policy value to clipboard:', error);
});
}
// Toggle the visibility of an additional row containing the complete text.
private toggleExpanded() {
const warningRowDisplay =
this.shadowRoot!.querySelector('.warnings.row') as CustomElement;
const errorRowDisplay =
this.shadowRoot!.querySelector('.errors.row') as CustomElement;
const infoRowDisplay =
this.shadowRoot!.querySelector('.infos.row') as CustomElement;
const valueRowDisplay =
this.shadowRoot!.querySelector('.value.row') as CustomElement;
// <if expr="is_android or is_ios">
const scopeRowDisplay =
this.shadowRoot!.querySelector('.scope.row') as CustomElement;
scopeRowDisplay.hidden = !scopeRowDisplay.hidden;
const levelRowDisplay =
this.shadowRoot!.querySelector('.level.row') as CustomElement;
levelRowDisplay.hidden = !levelRowDisplay.hidden;
// </if>
valueRowDisplay.hidden = !valueRowDisplay.hidden;
this.classList!.toggle('expanded', !valueRowDisplay.hidden);
this.shadowRoot!.querySelector<CustomElement>('.show-more')!.hidden =
!valueRowDisplay.hidden;
this.shadowRoot!.querySelector<CustomElement>('.show-less')!.hidden =
valueRowDisplay!.hidden;
| // Skip 'string' policy to avoid unnecessary conversions.
if (typeof value == 'string') {
return value; | random_line_split |
server.go | ok := privateKey.(*ecdsa.PrivateKey); ok {
keyType = cert.ECPrivateKeyBlockType
bytes, err = x509.MarshalECPrivateKey(key)
} else if key, ok := privateKey.(*rsa.PrivateKey); ok {
keyType = cert.RSAPrivateKeyBlockType
bytes = x509.MarshalPKCS1PrivateKey(key)
} else {
keyType = cert.PrivateKeyBlockType
bytes, err = x509.MarshalPKCS8PrivateKey(privateKey)
}
if err != nil {
logrus.Errorf("Unable to marshal private key: %v", err)
}
return keyType, bytes, err
}
func newPrivateKey() (crypto.Signer, error) {
caKeyBytes, err := cert.MakeEllipticPrivateKeyPEM()
if err != nil {
return nil, err
}
caKeyIFace, err := cert.ParsePrivateKeyPEM(caKeyBytes)
if err != nil {
return nil, err
}
return caKeyIFace.(crypto.Signer), nil
}
func (s *server) save() (_err error) {
defer func() {
if _err != nil {
logrus.Errorf("Saving cert error: %s", _err)
}
}()
certStr, err := certToString(s.tlsCert)
if err != nil {
return err
}
cfg, err := s.listenConfigStorage.Get()
if err != nil {
return err
}
cfg.GeneratedCerts = map[string]string{s.cn: certStr}
_, err = s.listenConfigStorage.Set(cfg)
return err
}
func (s *server) userConfigure() error {
if s.userConfig.HTTPSPort == 0 {
s.userConfig.HTTPSPort = 8443
}
for _, d := range s.userConfig.Domains {
s.domains[d] = true
}
for _, ip := range s.userConfig.KnownIPs {
if netIP := net.ParseIP(ip); netIP != nil {
s.ips[ip] = true
}
}
if bindAddress := net.ParseIP(s.userConfig.BindAddress); bindAddress != nil {
s.ips[s.userConfig.BindAddress] = true
}
if s.activeCA == nil && s.activeCAKey == nil {
if s.userConfig.CACerts != "" && s.userConfig.CAKey != "" {
ca, err := cert.ParseCertsPEM([]byte(s.userConfig.CACerts))
if err != nil {
return err
}
key, err := cert.ParsePrivateKeyPEM([]byte(s.userConfig.CAKey))
if err != nil {
return err
}
s.activeCA = ca[0]
s.activeCAKey = key.(crypto.Signer)
} else {
ca, key, err := genCA()
if err != nil {
return err
}
s.activeCA = ca
s.activeCAKey = key
}
}
return nil
}
func genCA() (*x509.Certificate, crypto.Signer, error) {
caKey, err := newPrivateKey()
if err != nil {
return nil, nil, err
}
caCert, err := cert.NewSelfSignedCACert(cert.Config{
CommonName: "k3s-ca",
Organization: []string{"k3s-org"},
}, caKey)
if err != nil {
return nil, nil, err
}
return caCert, caKey, nil
}
func (s *server) Update(status *ListenerStatus) (_err error) {
s.Lock()
defer func() {
s.Unlock()
if _err != nil {
logrus.Errorf("Update cert error: %s", _err)
}
if s.tlsCert == nil {
s.getCertificate(&tls.ClientHelloInfo{ServerName: "localhost"})
}
}()
certString := status.GeneratedCerts[s.cn]
tlsCert, err := stringToCert(certString)
if err != nil {
logrus.Errorf("Update cert unable to convert string to cert: %s", err)
s.tlsCert = nil
}
if tlsCert != nil {
s.tlsCert = tlsCert
for i, certBytes := range tlsCert.Certificate {
cert, err := x509.ParseCertificate(certBytes)
if err != nil {
logrus.Errorf("Update cert %d parse error: %s", i, err)
s.tlsCert = nil
break
}
ips := map[string]bool{}
for _, ip := range cert.IPAddresses {
ips[ip.String()] = true
}
domains := map[string]bool{}
for _, domain := range cert.DNSNames {
domains[domain] = true
}
if !(reflect.DeepEqual(ips, s.ips) && reflect.DeepEqual(domains, s.domains)) {
subset := true
for ip := range s.ips {
if !ips[ip] {
subset = false
break
}
}
if subset {
for domain := range s.domains {
if !domains[domain] {
subset = false
break
}
}
}
if !subset {
s.tlsCert = nil
}
for ip := range ips {
s.ips[ip] = true
}
for domain := range domains {
s.domains[domain] = true
}
}
}
}
return s.reload()
}
func (s *server) shutdown() error {
for _, listener := range s.listeners {
if err := listener.Close(); err != nil {
return err
}
}
s.listeners = nil
for _, server := range s.servers {
go server.Shutdown(context.Background())
}
s.servers = nil
return nil
}
func (s *server) reload() error {
if len(s.listeners) > 0 {
return nil
}
if err := s.shutdown(); err != nil |
if err := s.serveHTTPS(); err != nil {
return err
}
return nil
}
func (s *server) getCertificate(hello *tls.ClientHelloInfo) (_servingCert *tls.Certificate, _err error) {
s.Lock()
changed := false
defer func() {
defer s.Unlock()
if _err != nil {
logrus.Errorf("Get certificate error: %s", _err)
return
}
if changed {
s.save()
}
}()
if hello.ServerName != "" && !s.domains[hello.ServerName] {
s.tlsCert = nil
s.domains[hello.ServerName] = true
}
if s.tlsCert != nil {
return s.tlsCert, nil
}
ips := []net.IP{}
for ipStr := range s.ips {
if ip := net.ParseIP(ipStr); ip != nil {
ips = append(ips, ip)
}
}
dnsNames := []string{}
for domain := range s.domains {
dnsNames = append(dnsNames, domain)
}
cfg := cert.Config{
CommonName: s.cn,
Organization: s.activeCA.Subject.Organization,
Usages: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
AltNames: cert.AltNames{
DNSNames: dnsNames,
IPs: ips,
},
}
key, err := newPrivateKey()
if err != nil {
return nil, err
}
cert, err := cert.NewSignedCert(cfg, key, s.activeCA, s.activeCAKey)
if err != nil {
return nil, err
}
tlsCert := &tls.Certificate{
Certificate: [][]byte{
cert.Raw,
},
PrivateKey: key,
}
changed = true
s.tlsCert = tlsCert
return tlsCert, nil
}
func (s *server) cacheHandler(handler http.Handler) http.Handler {
return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
h, _, err := net.SplitHostPort(req.Host)
if err != nil {
h = req.Host
}
s.Lock()
if ip := net.ParseIP(h); ip != nil {
if !s.ips[h] {
s.ips[h] = true
s.tlsCert = nil
}
} else {
if !s.domains[h] {
s.domains[h] = true
s.tlsCert = nil
}
}
s.Unlock()
handler.ServeHTTP(resp, req)
})
}
func (s *server) serveHTTPS() error {
conf := &tls.Config{
ClientAuth: tls.RequestClientCert,
GetCertificate: s.getCertificate,
PreferServerCipherSuites: true,
}
listener, err := s.newListener(s.userConfig.BindAddress, s.userConfig.HTTPSPort, conf)
if err != nil {
return err
}
logger := logrus.StandardLogger()
server := &http.Server{
Handler: s.cacheHandler(s.Handler()),
ErrorLog: log.New(logger.WriterLevel(logrus.DebugLevel), "", log.LstdFlags),
}
s.servers = append(s.servers, server)
s.start | {
return err
} | conditional_block |
server.go | if err := s.userConfigure(); err != nil {
return nil, err
}
lc, err := listenConfigStorage.Get()
if err != nil {
return nil, err
}
return s, s.Update(lc)
}
func (s *server) CACert() (string, error) {
if s.userConfig.NoCACerts {
return "", nil
}
if s.userConfig.CACerts != "" {
return s.userConfig.CACerts, nil
}
return "", fmt.Errorf("ca cert not found")
}
func marshalPrivateKey(privateKey crypto.Signer) (string, []byte, error) {
var (
keyType string
bytes []byte
err error
)
if key, ok := privateKey.(*ecdsa.PrivateKey); ok {
keyType = cert.ECPrivateKeyBlockType
bytes, err = x509.MarshalECPrivateKey(key)
} else if key, ok := privateKey.(*rsa.PrivateKey); ok {
keyType = cert.RSAPrivateKeyBlockType
bytes = x509.MarshalPKCS1PrivateKey(key)
} else {
keyType = cert.PrivateKeyBlockType
bytes, err = x509.MarshalPKCS8PrivateKey(privateKey)
}
if err != nil {
logrus.Errorf("Unable to marshal private key: %v", err)
}
return keyType, bytes, err
}
func newPrivateKey() (crypto.Signer, error) {
caKeyBytes, err := cert.MakeEllipticPrivateKeyPEM()
if err != nil {
return nil, err
}
caKeyIFace, err := cert.ParsePrivateKeyPEM(caKeyBytes)
if err != nil {
return nil, err
}
return caKeyIFace.(crypto.Signer), nil
}
func (s *server) save() (_err error) {
defer func() {
if _err != nil {
logrus.Errorf("Saving cert error: %s", _err)
}
}()
certStr, err := certToString(s.tlsCert)
if err != nil {
return err
}
cfg, err := s.listenConfigStorage.Get()
if err != nil {
return err
}
cfg.GeneratedCerts = map[string]string{s.cn: certStr}
_, err = s.listenConfigStorage.Set(cfg)
return err
}
func (s *server) userConfigure() error {
if s.userConfig.HTTPSPort == 0 {
s.userConfig.HTTPSPort = 8443
}
for _, d := range s.userConfig.Domains {
s.domains[d] = true
}
for _, ip := range s.userConfig.KnownIPs {
if netIP := net.ParseIP(ip); netIP != nil {
s.ips[ip] = true
}
}
if bindAddress := net.ParseIP(s.userConfig.BindAddress); bindAddress != nil {
s.ips[s.userConfig.BindAddress] = true
}
if s.activeCA == nil && s.activeCAKey == nil {
if s.userConfig.CACerts != "" && s.userConfig.CAKey != "" {
ca, err := cert.ParseCertsPEM([]byte(s.userConfig.CACerts))
if err != nil {
return err
}
key, err := cert.ParsePrivateKeyPEM([]byte(s.userConfig.CAKey))
if err != nil {
return err
}
s.activeCA = ca[0]
s.activeCAKey = key.(crypto.Signer)
} else {
ca, key, err := genCA()
if err != nil {
return err
}
s.activeCA = ca
s.activeCAKey = key
}
}
return nil
}
func genCA() (*x509.Certificate, crypto.Signer, error) {
caKey, err := newPrivateKey()
if err != nil {
return nil, nil, err
}
caCert, err := cert.NewSelfSignedCACert(cert.Config{
CommonName: "k3s-ca",
Organization: []string{"k3s-org"},
}, caKey)
if err != nil {
return nil, nil, err
}
return caCert, caKey, nil
}
func (s *server) Update(status *ListenerStatus) (_err error) {
s.Lock()
defer func() {
s.Unlock()
if _err != nil {
logrus.Errorf("Update cert error: %s", _err)
}
if s.tlsCert == nil {
s.getCertificate(&tls.ClientHelloInfo{ServerName: "localhost"})
}
}()
certString := status.GeneratedCerts[s.cn]
tlsCert, err := stringToCert(certString)
if err != nil {
logrus.Errorf("Update cert unable to convert string to cert: %s", err)
s.tlsCert = nil
}
if tlsCert != nil {
s.tlsCert = tlsCert
for i, certBytes := range tlsCert.Certificate {
cert, err := x509.ParseCertificate(certBytes)
if err != nil {
logrus.Errorf("Update cert %d parse error: %s", i, err)
s.tlsCert = nil
break
}
ips := map[string]bool{}
for _, ip := range cert.IPAddresses {
ips[ip.String()] = true
}
domains := map[string]bool{}
for _, domain := range cert.DNSNames {
domains[domain] = true
}
if !(reflect.DeepEqual(ips, s.ips) && reflect.DeepEqual(domains, s.domains)) {
subset := true
for ip := range s.ips {
if !ips[ip] {
subset = false
break
}
}
if subset {
for domain := range s.domains {
if !domains[domain] {
subset = false
break
}
}
}
if !subset {
s.tlsCert = nil
}
for ip := range ips {
s.ips[ip] = true
}
for domain := range domains {
s.domains[domain] = true
}
}
}
}
return s.reload()
}
func (s *server) shutdown() error {
for _, listener := range s.listeners {
if err := listener.Close(); err != nil {
return err
}
}
s.listeners = nil
for _, server := range s.servers {
go server.Shutdown(context.Background())
}
s.servers = nil
return nil
}
func (s *server) reload() error {
if len(s.listeners) > 0 {
return nil
}
if err := s.shutdown(); err != nil {
return err
}
if err := s.serveHTTPS(); err != nil {
return err
}
return nil
}
func (s *server) getCertificate(hello *tls.ClientHelloInfo) (_servingCert *tls.Certificate, _err error) {
s.Lock()
changed := false
defer func() {
defer s.Unlock()
if _err != nil {
logrus.Errorf("Get certificate error: %s", _err)
return
}
if changed {
s.save()
}
}()
if hello.ServerName != "" && !s.domains[hello.ServerName] {
s.tlsCert = nil
s.domains[hello.ServerName] = true
}
if s.tlsCert != nil {
return s.tlsCert, nil
}
ips := []net.IP{}
for ipStr := range s.ips {
if ip := net.ParseIP(ipStr); ip != nil {
ips = append(ips, ip)
}
}
dnsNames := []string{}
for domain := range s.domains {
dnsNames = append(dnsNames, domain)
}
cfg := cert.Config{
CommonName: s.cn,
Organization: s.activeCA.Subject.Organization,
Usages: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
AltNames: cert.AltNames{
DNSNames: dnsNames,
IPs: ips,
},
}
key, err := newPrivateKey()
if err != nil {
return nil, err
}
cert, err := cert.NewSignedCert(cfg, key, s.activeCA, s.activeCAKey)
if err != nil {
return nil, err
}
tlsCert := &tls.Certificate{
Certificate: [][]byte{
cert.Raw,
},
PrivateKey: key,
}
changed = true
s.tlsCert = tlsCert
return tlsCert, nil
}
func (s *server) cacheHandler(handler http.Handler) http.Handler {
return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
h, _, err := net.SplitHostPort(req.Host)
if err != nil {
h = req.Host
}
s.Lock()
if ip := net.ParseIP(h); ip != nil {
if !s.ips[h] {
s.ips[h] = true
s.tlsCert = nil
}
} else {
if !s.domains[h] {
s.domains[h] = | s.ips = map[string]bool{}
s.domains = map[string]bool{}
| random_line_split |
|
server.go | , ok := privateKey.(*ecdsa.PrivateKey); ok {
keyType = cert.ECPrivateKeyBlockType
bytes, err = x509.MarshalECPrivateKey(key)
} else if key, ok := privateKey.(*rsa.PrivateKey); ok {
keyType = cert.RSAPrivateKeyBlockType
bytes = x509.MarshalPKCS1PrivateKey(key)
} else {
keyType = cert.PrivateKeyBlockType
bytes, err = x509.MarshalPKCS8PrivateKey(privateKey)
}
if err != nil {
logrus.Errorf("Unable to marshal private key: %v", err)
}
return keyType, bytes, err
}
func newPrivateKey() (crypto.Signer, error) {
caKeyBytes, err := cert.MakeEllipticPrivateKeyPEM()
if err != nil {
return nil, err
}
caKeyIFace, err := cert.ParsePrivateKeyPEM(caKeyBytes)
if err != nil {
return nil, err
}
return caKeyIFace.(crypto.Signer), nil
}
func (s *server) save() (_err error) {
defer func() {
if _err != nil {
logrus.Errorf("Saving cert error: %s", _err)
}
}()
certStr, err := certToString(s.tlsCert)
if err != nil {
return err
}
cfg, err := s.listenConfigStorage.Get()
if err != nil {
return err
}
cfg.GeneratedCerts = map[string]string{s.cn: certStr}
_, err = s.listenConfigStorage.Set(cfg)
return err
}
func (s *server) | () error {
if s.userConfig.HTTPSPort == 0 {
s.userConfig.HTTPSPort = 8443
}
for _, d := range s.userConfig.Domains {
s.domains[d] = true
}
for _, ip := range s.userConfig.KnownIPs {
if netIP := net.ParseIP(ip); netIP != nil {
s.ips[ip] = true
}
}
if bindAddress := net.ParseIP(s.userConfig.BindAddress); bindAddress != nil {
s.ips[s.userConfig.BindAddress] = true
}
if s.activeCA == nil && s.activeCAKey == nil {
if s.userConfig.CACerts != "" && s.userConfig.CAKey != "" {
ca, err := cert.ParseCertsPEM([]byte(s.userConfig.CACerts))
if err != nil {
return err
}
key, err := cert.ParsePrivateKeyPEM([]byte(s.userConfig.CAKey))
if err != nil {
return err
}
s.activeCA = ca[0]
s.activeCAKey = key.(crypto.Signer)
} else {
ca, key, err := genCA()
if err != nil {
return err
}
s.activeCA = ca
s.activeCAKey = key
}
}
return nil
}
func genCA() (*x509.Certificate, crypto.Signer, error) {
caKey, err := newPrivateKey()
if err != nil {
return nil, nil, err
}
caCert, err := cert.NewSelfSignedCACert(cert.Config{
CommonName: "k3s-ca",
Organization: []string{"k3s-org"},
}, caKey)
if err != nil {
return nil, nil, err
}
return caCert, caKey, nil
}
func (s *server) Update(status *ListenerStatus) (_err error) {
s.Lock()
defer func() {
s.Unlock()
if _err != nil {
logrus.Errorf("Update cert error: %s", _err)
}
if s.tlsCert == nil {
s.getCertificate(&tls.ClientHelloInfo{ServerName: "localhost"})
}
}()
certString := status.GeneratedCerts[s.cn]
tlsCert, err := stringToCert(certString)
if err != nil {
logrus.Errorf("Update cert unable to convert string to cert: %s", err)
s.tlsCert = nil
}
if tlsCert != nil {
s.tlsCert = tlsCert
for i, certBytes := range tlsCert.Certificate {
cert, err := x509.ParseCertificate(certBytes)
if err != nil {
logrus.Errorf("Update cert %d parse error: %s", i, err)
s.tlsCert = nil
break
}
ips := map[string]bool{}
for _, ip := range cert.IPAddresses {
ips[ip.String()] = true
}
domains := map[string]bool{}
for _, domain := range cert.DNSNames {
domains[domain] = true
}
if !(reflect.DeepEqual(ips, s.ips) && reflect.DeepEqual(domains, s.domains)) {
subset := true
for ip := range s.ips {
if !ips[ip] {
subset = false
break
}
}
if subset {
for domain := range s.domains {
if !domains[domain] {
subset = false
break
}
}
}
if !subset {
s.tlsCert = nil
}
for ip := range ips {
s.ips[ip] = true
}
for domain := range domains {
s.domains[domain] = true
}
}
}
}
return s.reload()
}
func (s *server) shutdown() error {
for _, listener := range s.listeners {
if err := listener.Close(); err != nil {
return err
}
}
s.listeners = nil
for _, server := range s.servers {
go server.Shutdown(context.Background())
}
s.servers = nil
return nil
}
func (s *server) reload() error {
if len(s.listeners) > 0 {
return nil
}
if err := s.shutdown(); err != nil {
return err
}
if err := s.serveHTTPS(); err != nil {
return err
}
return nil
}
func (s *server) getCertificate(hello *tls.ClientHelloInfo) (_servingCert *tls.Certificate, _err error) {
s.Lock()
changed := false
defer func() {
defer s.Unlock()
if _err != nil {
logrus.Errorf("Get certificate error: %s", _err)
return
}
if changed {
s.save()
}
}()
if hello.ServerName != "" && !s.domains[hello.ServerName] {
s.tlsCert = nil
s.domains[hello.ServerName] = true
}
if s.tlsCert != nil {
return s.tlsCert, nil
}
ips := []net.IP{}
for ipStr := range s.ips {
if ip := net.ParseIP(ipStr); ip != nil {
ips = append(ips, ip)
}
}
dnsNames := []string{}
for domain := range s.domains {
dnsNames = append(dnsNames, domain)
}
cfg := cert.Config{
CommonName: s.cn,
Organization: s.activeCA.Subject.Organization,
Usages: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
AltNames: cert.AltNames{
DNSNames: dnsNames,
IPs: ips,
},
}
key, err := newPrivateKey()
if err != nil {
return nil, err
}
cert, err := cert.NewSignedCert(cfg, key, s.activeCA, s.activeCAKey)
if err != nil {
return nil, err
}
tlsCert := &tls.Certificate{
Certificate: [][]byte{
cert.Raw,
},
PrivateKey: key,
}
changed = true
s.tlsCert = tlsCert
return tlsCert, nil
}
func (s *server) cacheHandler(handler http.Handler) http.Handler {
return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
h, _, err := net.SplitHostPort(req.Host)
if err != nil {
h = req.Host
}
s.Lock()
if ip := net.ParseIP(h); ip != nil {
if !s.ips[h] {
s.ips[h] = true
s.tlsCert = nil
}
} else {
if !s.domains[h] {
s.domains[h] = true
s.tlsCert = nil
}
}
s.Unlock()
handler.ServeHTTP(resp, req)
})
}
func (s *server) serveHTTPS() error {
conf := &tls.Config{
ClientAuth: tls.RequestClientCert,
GetCertificate: s.getCertificate,
PreferServerCipherSuites: true,
}
listener, err := s.newListener(s.userConfig.BindAddress, s.userConfig.HTTPSPort, conf)
if err != nil {
return err
}
logger := logrus.StandardLogger()
server := &http.Server{
Handler: s.cacheHandler(s.Handler()),
ErrorLog: log.New(logger.WriterLevel(logrus.DebugLevel), "", log.LstdFlags),
}
s.servers = append(s.servers, server)
s.start | userConfigure | identifier_name |
server.go | ok := privateKey.(*ecdsa.PrivateKey); ok {
keyType = cert.ECPrivateKeyBlockType
bytes, err = x509.MarshalECPrivateKey(key)
} else if key, ok := privateKey.(*rsa.PrivateKey); ok {
keyType = cert.RSAPrivateKeyBlockType
bytes = x509.MarshalPKCS1PrivateKey(key)
} else {
keyType = cert.PrivateKeyBlockType
bytes, err = x509.MarshalPKCS8PrivateKey(privateKey)
}
if err != nil {
logrus.Errorf("Unable to marshal private key: %v", err)
}
return keyType, bytes, err
}
func newPrivateKey() (crypto.Signer, error) {
caKeyBytes, err := cert.MakeEllipticPrivateKeyPEM()
if err != nil {
return nil, err
}
caKeyIFace, err := cert.ParsePrivateKeyPEM(caKeyBytes)
if err != nil {
return nil, err
}
return caKeyIFace.(crypto.Signer), nil
}
func (s *server) save() (_err error) {
defer func() {
if _err != nil {
logrus.Errorf("Saving cert error: %s", _err)
}
}()
certStr, err := certToString(s.tlsCert)
if err != nil {
return err
}
cfg, err := s.listenConfigStorage.Get()
if err != nil {
return err
}
cfg.GeneratedCerts = map[string]string{s.cn: certStr}
_, err = s.listenConfigStorage.Set(cfg)
return err
}
func (s *server) userConfigure() error {
if s.userConfig.HTTPSPort == 0 {
s.userConfig.HTTPSPort = 8443
}
for _, d := range s.userConfig.Domains {
s.domains[d] = true
}
for _, ip := range s.userConfig.KnownIPs {
if netIP := net.ParseIP(ip); netIP != nil {
s.ips[ip] = true
}
}
if bindAddress := net.ParseIP(s.userConfig.BindAddress); bindAddress != nil {
s.ips[s.userConfig.BindAddress] = true
}
if s.activeCA == nil && s.activeCAKey == nil {
if s.userConfig.CACerts != "" && s.userConfig.CAKey != "" {
ca, err := cert.ParseCertsPEM([]byte(s.userConfig.CACerts))
if err != nil {
return err
}
key, err := cert.ParsePrivateKeyPEM([]byte(s.userConfig.CAKey))
if err != nil {
return err
}
s.activeCA = ca[0]
s.activeCAKey = key.(crypto.Signer)
} else {
ca, key, err := genCA()
if err != nil {
return err
}
s.activeCA = ca
s.activeCAKey = key
}
}
return nil
}
func genCA() (*x509.Certificate, crypto.Signer, error) {
caKey, err := newPrivateKey()
if err != nil {
return nil, nil, err
}
caCert, err := cert.NewSelfSignedCACert(cert.Config{
CommonName: "k3s-ca",
Organization: []string{"k3s-org"},
}, caKey)
if err != nil {
return nil, nil, err
}
return caCert, caKey, nil
}
func (s *server) Update(status *ListenerStatus) (_err error) {
s.Lock()
defer func() {
s.Unlock()
if _err != nil {
logrus.Errorf("Update cert error: %s", _err)
}
if s.tlsCert == nil {
s.getCertificate(&tls.ClientHelloInfo{ServerName: "localhost"})
}
}()
certString := status.GeneratedCerts[s.cn]
tlsCert, err := stringToCert(certString)
if err != nil {
logrus.Errorf("Update cert unable to convert string to cert: %s", err)
s.tlsCert = nil
}
if tlsCert != nil {
s.tlsCert = tlsCert
for i, certBytes := range tlsCert.Certificate {
cert, err := x509.ParseCertificate(certBytes)
if err != nil {
logrus.Errorf("Update cert %d parse error: %s", i, err)
s.tlsCert = nil
break
}
ips := map[string]bool{}
for _, ip := range cert.IPAddresses {
ips[ip.String()] = true
}
domains := map[string]bool{}
for _, domain := range cert.DNSNames {
domains[domain] = true
}
if !(reflect.DeepEqual(ips, s.ips) && reflect.DeepEqual(domains, s.domains)) {
subset := true
for ip := range s.ips {
if !ips[ip] {
subset = false
break
}
}
if subset {
for domain := range s.domains {
if !domains[domain] {
subset = false
break
}
}
}
if !subset {
s.tlsCert = nil
}
for ip := range ips {
s.ips[ip] = true
}
for domain := range domains {
s.domains[domain] = true
}
}
}
}
return s.reload()
}
func (s *server) shutdown() error {
for _, listener := range s.listeners {
if err := listener.Close(); err != nil {
return err
}
}
s.listeners = nil
for _, server := range s.servers {
go server.Shutdown(context.Background())
}
s.servers = nil
return nil
}
func (s *server) reload() error |
func (s *server) getCertificate(hello *tls.ClientHelloInfo) (_servingCert *tls.Certificate, _err error) {
s.Lock()
changed := false
defer func() {
defer s.Unlock()
if _err != nil {
logrus.Errorf("Get certificate error: %s", _err)
return
}
if changed {
s.save()
}
}()
if hello.ServerName != "" && !s.domains[hello.ServerName] {
s.tlsCert = nil
s.domains[hello.ServerName] = true
}
if s.tlsCert != nil {
return s.tlsCert, nil
}
ips := []net.IP{}
for ipStr := range s.ips {
if ip := net.ParseIP(ipStr); ip != nil {
ips = append(ips, ip)
}
}
dnsNames := []string{}
for domain := range s.domains {
dnsNames = append(dnsNames, domain)
}
cfg := cert.Config{
CommonName: s.cn,
Organization: s.activeCA.Subject.Organization,
Usages: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
AltNames: cert.AltNames{
DNSNames: dnsNames,
IPs: ips,
},
}
key, err := newPrivateKey()
if err != nil {
return nil, err
}
cert, err := cert.NewSignedCert(cfg, key, s.activeCA, s.activeCAKey)
if err != nil {
return nil, err
}
tlsCert := &tls.Certificate{
Certificate: [][]byte{
cert.Raw,
},
PrivateKey: key,
}
changed = true
s.tlsCert = tlsCert
return tlsCert, nil
}
func (s *server) cacheHandler(handler http.Handler) http.Handler {
return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
h, _, err := net.SplitHostPort(req.Host)
if err != nil {
h = req.Host
}
s.Lock()
if ip := net.ParseIP(h); ip != nil {
if !s.ips[h] {
s.ips[h] = true
s.tlsCert = nil
}
} else {
if !s.domains[h] {
s.domains[h] = true
s.tlsCert = nil
}
}
s.Unlock()
handler.ServeHTTP(resp, req)
})
}
func (s *server) serveHTTPS() error {
conf := &tls.Config{
ClientAuth: tls.RequestClientCert,
GetCertificate: s.getCertificate,
PreferServerCipherSuites: true,
}
listener, err := s.newListener(s.userConfig.BindAddress, s.userConfig.HTTPSPort, conf)
if err != nil {
return err
}
logger := logrus.StandardLogger()
server := &http.Server{
Handler: s.cacheHandler(s.Handler()),
ErrorLog: log.New(logger.WriterLevel(logrus.DebugLevel), "", log.LstdFlags),
}
s.servers = append(s.servers, server)
s.start | {
if len(s.listeners) > 0 {
return nil
}
if err := s.shutdown(); err != nil {
return err
}
if err := s.serveHTTPS(); err != nil {
return err
}
return nil
} | identifier_body |
cli.rs | mut remaining_v: libc::tcflag_t = v;
let mut s = String::new();
for &(fname, fvalue) in fs {
if (v & fvalue) != 0 {
let was_empty = s.is_empty();
write!(
&mut s,
"{}{}",
match was_empty {
true => "",
false => " | ",
},
fname
)?;
remaining_v &= !v;
}
}
if remaining_v != 0 {
let was_empty = s.is_empty();
write!(
&mut s,
"{}(extra: {:x})",
match was_empty {
true => "",
false => " ",
},
remaining_v
)?;
}
Ok(s)
}
fn debug_format_c_cc_field(c_cc: &[libc::cc_t; 32]) -> std::result::Result<String, fmt::Error> {
use fmt::Write;
const INDICES: &'static [(&'static str, usize)] = &[
("VDISCARD", libc::VDISCARD),
("VEOF", libc::VEOF),
("VEOL", libc::VEOL),
("VEOL2", libc::VEOL2),
("VERASE", libc::VERASE),
("VINTR", libc::VINTR),
("VKILL", libc::VKILL),
("VLNEXT", libc::VLNEXT),
("VMIN", libc::VMIN),
("VQUIT", libc::VQUIT),
("VREPRINT", libc::VREPRINT),
("VSTART", libc::VSTART),
("VSTOP", libc::VSTOP),
("VSUSP", libc::VSUSP),
("VSWTC", libc::VSWTC),
("VTIME", libc::VTIME),
("VWERASE", libc::VWERASE),
];
let mut s = String::new();
for &(name, idx) in INDICES {
let was_empty = s.is_empty();
write!(
&mut s,
"{}{}:{}",
match was_empty {
true => "",
false => ", ",
},
name,
c_cc[idx]
)?;
}
Ok(s)
}
impl fmt::Debug for TerminalAttributes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TerminalAttributes")
.field(
"c_iflag",
&debug_format_flag_field(
self.inner.c_iflag,
&[
("IGNBRK", libc::IGNBRK),
("BRKINT", libc::BRKINT),
("IGNPAR", libc::IGNPAR),
("PARMRK", libc::PARMRK),
("INPCK", libc::INPCK),
("ISTRIP", libc::ISTRIP),
("INLCR", libc::INLCR),
("IGNCR", libc::IGNCR),
("ICRNL", libc::ICRNL),
("IXON", libc::IXON),
("IXANY", libc::IXANY),
("IXOFF", libc::IXOFF),
("IMAXBEL", libc::IMAXBEL),
("IUTF8", libc::IUTF8),
],
)?,
)
.field(
"c_oflag",
&debug_format_flag_field(
self.inner.c_oflag,
&[
("OPOST", libc::OPOST),
("OLCUC", libc::OLCUC),
("ONLCR", libc::ONLCR),
("ONOCR", libc::ONOCR),
("ONLRET", libc::ONLRET),
("OFILL", libc::OFILL),
("OFDEL", libc::OFDEL),
("NLDLY", libc::NLDLY),
("CRDLY", libc::CRDLY),
("TABDLY", libc::TABDLY),
("BSDLY", libc::BSDLY),
("VTDLY", libc::VTDLY),
("FFDLY", libc::FFDLY),
],
)?,
)
.field(
"c_cflag",
&debug_format_flag_field(
self.inner.c_cflag,
&[
("CBAUD", libc::CBAUD),
("CBAUDEX", libc::CBAUDEX),
("CSIZE", libc::CSIZE),
("CSTOPB", libc::CSTOPB),
("CREAD", libc::CREAD),
("PARENB", libc::PARENB),
("PARODD", libc::PARODD),
("HUPCL", libc::HUPCL),
("CLOCAL", libc::CLOCAL),
("CIBAUD", libc::CIBAUD),
("CMSPAR", libc::CMSPAR),
("CRTSCTS", libc::CRTSCTS),
],
)?,
)
.field(
"c_lflag",
&debug_format_flag_field(
self.inner.c_lflag,
&[
("ISIG", libc::ISIG),
("ICANON", libc::ICANON),
("ECHO", libc::ECHO),
("ECHOE", libc::ECHOE),
("ECHOK", libc::ECHOK),
("ECHONL", libc::ECHONL),
("ECHOCTL", libc::ECHOCTL),
("ECHOPRT", libc::ECHOPRT),
("ECHOKE", libc::ECHOKE),
("FLUSHO", libc::FLUSHO),
("NOFLSH", libc::NOFLSH),
("TOSTOP", libc::TOSTOP),
("PENDIN", libc::PENDIN),
("IEXTEN", libc::IEXTEN),
],
)?,
)
.field("c_cc", &debug_format_c_cc_field(&self.inner.c_cc)?)
.field("c_ispeed", unsafe { &libc::cfgetispeed(&self.inner) })
.field("c_ospeed", unsafe { &libc::cfgetospeed(&self.inner) })
.finish()
}
}
impl AbstractTerminalAttributes for TerminalAttributes {
fn enable(&mut self, flag: TerminalFlag) {
self.inner.c_lflag |= flag.to_value();
}
fn disable(&mut self, flag: TerminalFlag) {
self.inner.c_lflag &= !flag.to_value();
}
}
/// This trait describes an abstract input or output stream.
///
/// This trait primarily exists for testing purposes. In almost all cases, users
/// will instead just use the concrete type `Stream` defined below.
pub trait AbstractStream {
/// A type which describes the attributes of this stream / terminal.
type Attributes: AbstractTerminalAttributes + fmt::Debug;
/// Returns whether or not this stream refers to an interactive terminal (a
/// TTY), as opposed to, for example, a pipe.
fn isatty(&self) -> bool;
/// Retrieve the current attributes of this stream / terminal.
fn get_attributes(&self) -> IoResult<Self::Attributes>;
/// Modify this stream's / terminal's attributes to match the given state.
fn set_attributes(&mut self, attributes: &Self::Attributes) -> IoResult<()>;
/// Return a `Read` for this stream, if reading is supported.
fn as_reader(&self) -> Option<Box<dyn Read>>;
/// Return a `Write` for this stream, if writing is supported.
fn as_writer(&self) -> Option<Box<dyn Write>>;
}
/// Standard input / output streams.
#[derive(Debug)]
pub enum Stream {
/// Standard output.
Stdout,
/// Standard error.
Stderr,
/// Standard input.
Stdin,
}
impl Stream {
fn to_fd(&self) -> c_int |
}
impl AbstractStream for Stream {
type Attributes = TerminalAttributes;
fn isatty(&self) -> bool {
let ret = unsafe { libc::isatty(self.to_fd()) };
let error: i32 = errno::errno().into();
match ret {
1 => true,
0 => match error {
libc::EBADF => false,
libc::ENOTTY => false,
_ => {
debug!(
"Unrecognized isatty errno: {}; assuming {:?} is not a TTY",
error, *self
);
false
}
},
_ => {
debug!(
"Unrecognized isatty return code: {}; assuming {:?} is not a TTY",
ret, *self
);
false
}
}
}
fn get_attributes(&self) -> IoResult<Self::Attributes> {
TerminalAttributes::new(self.to_fd())
}
fn set_attributes(&mut self, attributes: &Self::Attributes) -> IoResult<()> {
let ret = attributes.apply(self.to_fd());
debug_assert!(ret.is_err() || *attributes == Self::Attributes::new(self.to_fd()).unwrap());
ret
}
fn as_reader(&self) -> Option<Box<dyn Read>> {
match *self {
Stream::Stdin => Some(Box::new(io::stdin())),
_ => None,
}
}
fn as_writer(&self) -> Option<Box<dyn Write>> {
match *self {
Stream::Std | {
match *self {
Stream::Stdout => libc::STDOUT_FILENO,
Stream::Stderr => libc::STDERR_FILENO,
Stream::Stdin => libc::STDIN_FILENO,
}
} | identifier_body |
cli.rs | SPAR", libc::CMSPAR),
("CRTSCTS", libc::CRTSCTS),
],
)?,
)
.field(
"c_lflag",
&debug_format_flag_field(
self.inner.c_lflag,
&[
("ISIG", libc::ISIG),
("ICANON", libc::ICANON),
("ECHO", libc::ECHO),
("ECHOE", libc::ECHOE),
("ECHOK", libc::ECHOK),
("ECHONL", libc::ECHONL),
("ECHOCTL", libc::ECHOCTL),
("ECHOPRT", libc::ECHOPRT),
("ECHOKE", libc::ECHOKE),
("FLUSHO", libc::FLUSHO),
("NOFLSH", libc::NOFLSH),
("TOSTOP", libc::TOSTOP),
("PENDIN", libc::PENDIN),
("IEXTEN", libc::IEXTEN),
],
)?,
)
.field("c_cc", &debug_format_c_cc_field(&self.inner.c_cc)?)
.field("c_ispeed", unsafe { &libc::cfgetispeed(&self.inner) })
.field("c_ospeed", unsafe { &libc::cfgetospeed(&self.inner) })
.finish()
}
}
impl AbstractTerminalAttributes for TerminalAttributes {
fn enable(&mut self, flag: TerminalFlag) {
self.inner.c_lflag |= flag.to_value();
}
fn disable(&mut self, flag: TerminalFlag) {
self.inner.c_lflag &= !flag.to_value();
}
}
/// This trait describes an abstract input or output stream.
///
/// This trait primarily exists for testing purposes. In almost all cases, users
/// will instead just use the concrete type `Stream` defined below.
pub trait AbstractStream {
/// A type which describes the attributes of this stream / terminal.
type Attributes: AbstractTerminalAttributes + fmt::Debug;
/// Returns whether or not this stream refers to an interactive terminal (a
/// TTY), as opposed to, for example, a pipe.
fn isatty(&self) -> bool;
/// Retrieve the current attributes of this stream / terminal.
fn get_attributes(&self) -> IoResult<Self::Attributes>;
/// Modify this stream's / terminal's attributes to match the given state.
fn set_attributes(&mut self, attributes: &Self::Attributes) -> IoResult<()>;
/// Return a `Read` for this stream, if reading is supported.
fn as_reader(&self) -> Option<Box<dyn Read>>;
/// Return a `Write` for this stream, if writing is supported.
fn as_writer(&self) -> Option<Box<dyn Write>>;
}
/// Standard input / output streams.
#[derive(Debug)]
pub enum Stream {
/// Standard output.
Stdout,
/// Standard error.
Stderr,
/// Standard input.
Stdin,
}
impl Stream {
fn to_fd(&self) -> c_int {
match *self {
Stream::Stdout => libc::STDOUT_FILENO,
Stream::Stderr => libc::STDERR_FILENO,
Stream::Stdin => libc::STDIN_FILENO,
}
}
}
impl AbstractStream for Stream {
type Attributes = TerminalAttributes;
fn isatty(&self) -> bool {
let ret = unsafe { libc::isatty(self.to_fd()) };
let error: i32 = errno::errno().into();
match ret {
1 => true,
0 => match error {
libc::EBADF => false,
libc::ENOTTY => false,
_ => {
debug!(
"Unrecognized isatty errno: {}; assuming {:?} is not a TTY",
error, *self
);
false
}
},
_ => {
debug!(
"Unrecognized isatty return code: {}; assuming {:?} is not a TTY",
ret, *self
);
false
}
}
}
fn get_attributes(&self) -> IoResult<Self::Attributes> {
TerminalAttributes::new(self.to_fd())
}
fn set_attributes(&mut self, attributes: &Self::Attributes) -> IoResult<()> {
let ret = attributes.apply(self.to_fd());
debug_assert!(ret.is_err() || *attributes == Self::Attributes::new(self.to_fd()).unwrap());
ret
}
fn as_reader(&self) -> Option<Box<dyn Read>> {
match *self {
Stream::Stdin => Some(Box::new(io::stdin())),
_ => None,
}
}
fn as_writer(&self) -> Option<Box<dyn Write>> {
match *self {
Stream::Stdout => Some(Box::new(io::stdout())),
Stream::Stderr => Some(Box::new(io::stderr())),
_ => None,
}
}
}
/// This structure handles a) disabling the echoing of characters typed to
/// `Stdin`, and b) remembering to reset the terminal attributes afterwards
/// (via `Drop`).
struct DisableEcho<'s, S: AbstractStream> {
stream: &'s mut S,
initial_attributes: S::Attributes,
}
impl<'s, S: AbstractStream> DisableEcho<'s, S> {
fn new(stream: &'s mut S) -> Result<Self> {
let initial_attributes = stream.get_attributes()?;
debug!("Initial stream attributes: {:#?}", initial_attributes);
let mut attributes = stream.get_attributes()?;
// Don't echo characters typed to stdin.
attributes.disable(TerminalFlag::Echo);
// But, *do* echo the newline when the user hits ENTER.
attributes.enable(TerminalFlag::EchoNewlines);
debug!("Setting attributes to: {:#?}", attributes);
stream.set_attributes(&attributes)?;
Ok(DisableEcho {
stream: stream,
initial_attributes: initial_attributes,
})
}
}
impl<'s, S: AbstractStream> Drop for DisableEcho<'s, S> {
fn drop(&mut self) {
self.stream
.set_attributes(&self.initial_attributes)
.unwrap();
}
}
fn require_isatty<S: AbstractStream>(s: &mut S) -> Result<()> {
if !s.isatty() {
Err(Error::Precondition(format!(
"cannot prompt interactively when the I/O streams are not TTYs"
)))
} else {
Ok(())
}
}
fn build_input_reader<IS: AbstractStream>(
input_stream: &mut IS,
) -> Result<io::BufReader<Box<dyn Read>>> {
require_isatty(input_stream)?;
Ok(io::BufReader::new(match input_stream.as_reader() {
None => {
return Err(Error::Precondition(format!(
"the given input stream must support `Read`"
)))
}
Some(r) => r,
}))
}
fn remove_newline(mut s: String) -> Result<String> {
// Remove the trailing newline (if any - not finding one is an error).
if !s.ends_with('\n') {
return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "unexpected end of input").into());
}
s.pop();
// If this is windows and so there's also a \r, remove that too.
if s.ends_with('\r') {
s.pop();
}
Ok(s)
}
fn prompt_for_string_impl<IS: AbstractStream, OS: AbstractStream>(
input_stream: &mut IS,
// We have to take the reader as a parameter, since it must be "global",
// even if this function is e.g. called in a loop. Otherwise, because it's
// buffered, we might buffer some input and then discard it.
input_reader: &mut io::BufReader<Box<dyn Read>>,
output_stream: &mut OS,
prompt: &str,
is_sensitive: bool,
) -> Result<String> {
use io::BufRead;
require_isatty(output_stream)?;
// It's fine to construct a separate writer, potentially on each loop
// iteration or whatever, because we flush immediately, and don't do any
// buffering.
let mut writer = match output_stream.as_writer() {
None => {
return Err(Error::Precondition(format!(
"the given output stream must support `Write`"
)))
}
Some(w) => w,
};
write!(writer, "{}", prompt)?;
// We have to flush so the user sees the prompt immediately.
writer.flush()?;
Ok({
let _disable_echo = match is_sensitive {
false => None,
true => Some(DisableEcho::new(input_stream)?),
};
let mut ret = String::new();
input_reader.read_line(&mut ret)?;
remove_newline(ret)?
})
}
/// Prompt the user for a string (read from the given input stream) using the
/// given output stream (typically standard output or standard error) to display
/// the given prompt message.
///
/// If `is_sensitive` is true, then the users characters will not be echoed back
/// (e.g. this will behave like a password prompt).
///
/// Note that there are various requirements for the given streams, and this
/// function will return an error if any of them are not met:
///
/// - Both `input_stream` and `output_stream` must be TTYs.
/// - `input_stream` must return a valid `Read` instance.
/// - `output_stream` must return a valid `Write` instance.
pub fn | prompt_for_string | identifier_name |
|
cli.rs | && self.inner.c_oflag == other.inner.c_oflag
&& self.inner.c_cflag == other.inner.c_cflag
&& self.inner.c_lflag == other.inner.c_lflag
&& self.inner.c_line == other.inner.c_line
&& self.inner.c_cc == other.inner.c_cc
&& self.inner.c_ispeed == other.inner.c_ispeed
&& self.inner.c_ospeed == other.inner.c_ospeed
}
}
impl Eq for TerminalAttributes {}
fn debug_format_flag_field(
v: libc::tcflag_t,
fs: &'static [(&'static str, libc::tcflag_t)],
) -> std::result::Result<String, fmt::Error> {
use fmt::Write;
let mut remaining_v: libc::tcflag_t = v;
let mut s = String::new();
for &(fname, fvalue) in fs {
if (v & fvalue) != 0 {
let was_empty = s.is_empty();
write!(
&mut s,
"{}{}",
match was_empty {
true => "",
false => " | ",
},
fname
)?;
remaining_v &= !v;
}
}
if remaining_v != 0 {
let was_empty = s.is_empty();
write!(
&mut s,
"{}(extra: {:x})",
match was_empty {
true => "",
false => " ",
},
remaining_v
)?;
}
Ok(s)
}
fn debug_format_c_cc_field(c_cc: &[libc::cc_t; 32]) -> std::result::Result<String, fmt::Error> {
use fmt::Write;
const INDICES: &'static [(&'static str, usize)] = &[
("VDISCARD", libc::VDISCARD),
("VEOF", libc::VEOF),
("VEOL", libc::VEOL),
("VEOL2", libc::VEOL2),
("VERASE", libc::VERASE),
("VINTR", libc::VINTR),
("VKILL", libc::VKILL),
("VLNEXT", libc::VLNEXT),
("VMIN", libc::VMIN),
("VQUIT", libc::VQUIT),
("VREPRINT", libc::VREPRINT),
("VSTART", libc::VSTART),
("VSTOP", libc::VSTOP),
("VSUSP", libc::VSUSP),
("VSWTC", libc::VSWTC),
("VTIME", libc::VTIME),
("VWERASE", libc::VWERASE),
];
let mut s = String::new();
for &(name, idx) in INDICES {
let was_empty = s.is_empty();
write!(
&mut s,
"{}{}:{}",
match was_empty {
true => "",
false => ", ",
},
name,
c_cc[idx]
)?;
}
Ok(s)
}
impl fmt::Debug for TerminalAttributes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TerminalAttributes")
.field(
"c_iflag",
&debug_format_flag_field(
self.inner.c_iflag,
&[
("IGNBRK", libc::IGNBRK),
("BRKINT", libc::BRKINT),
("IGNPAR", libc::IGNPAR),
("PARMRK", libc::PARMRK),
("INPCK", libc::INPCK),
("ISTRIP", libc::ISTRIP),
("INLCR", libc::INLCR),
("IGNCR", libc::IGNCR),
("ICRNL", libc::ICRNL),
("IXON", libc::IXON),
("IXANY", libc::IXANY),
("IXOFF", libc::IXOFF),
("IMAXBEL", libc::IMAXBEL),
("IUTF8", libc::IUTF8),
],
)?,
)
.field(
"c_oflag",
&debug_format_flag_field(
self.inner.c_oflag,
&[
("OPOST", libc::OPOST),
("OLCUC", libc::OLCUC),
("ONLCR", libc::ONLCR),
("ONOCR", libc::ONOCR),
("ONLRET", libc::ONLRET),
("OFILL", libc::OFILL),
("OFDEL", libc::OFDEL),
("NLDLY", libc::NLDLY),
("CRDLY", libc::CRDLY),
("TABDLY", libc::TABDLY),
("BSDLY", libc::BSDLY),
("VTDLY", libc::VTDLY),
("FFDLY", libc::FFDLY),
],
)?,
)
.field(
"c_cflag",
&debug_format_flag_field(
self.inner.c_cflag,
&[
("CBAUD", libc::CBAUD),
("CBAUDEX", libc::CBAUDEX),
("CSIZE", libc::CSIZE),
("CSTOPB", libc::CSTOPB),
("CREAD", libc::CREAD),
("PARENB", libc::PARENB),
("PARODD", libc::PARODD),
("HUPCL", libc::HUPCL),
("CLOCAL", libc::CLOCAL),
("CIBAUD", libc::CIBAUD),
("CMSPAR", libc::CMSPAR),
("CRTSCTS", libc::CRTSCTS),
],
)?,
)
.field(
"c_lflag",
&debug_format_flag_field(
self.inner.c_lflag,
&[
("ISIG", libc::ISIG),
("ICANON", libc::ICANON),
("ECHO", libc::ECHO),
("ECHOE", libc::ECHOE),
("ECHOK", libc::ECHOK),
("ECHONL", libc::ECHONL),
("ECHOCTL", libc::ECHOCTL),
("ECHOPRT", libc::ECHOPRT),
("ECHOKE", libc::ECHOKE),
("FLUSHO", libc::FLUSHO),
("NOFLSH", libc::NOFLSH),
("TOSTOP", libc::TOSTOP),
("PENDIN", libc::PENDIN),
("IEXTEN", libc::IEXTEN),
],
)?,
)
.field("c_cc", &debug_format_c_cc_field(&self.inner.c_cc)?)
.field("c_ispeed", unsafe { &libc::cfgetispeed(&self.inner) })
.field("c_ospeed", unsafe { &libc::cfgetospeed(&self.inner) })
.finish()
}
}
impl AbstractTerminalAttributes for TerminalAttributes {
fn enable(&mut self, flag: TerminalFlag) {
self.inner.c_lflag |= flag.to_value();
}
fn disable(&mut self, flag: TerminalFlag) {
self.inner.c_lflag &= !flag.to_value();
}
}
/// This trait describes an abstract input or output stream.
///
/// This trait primarily exists for testing purposes. In almost all cases, users
/// will instead just use the concrete type `Stream` defined below.
pub trait AbstractStream {
/// A type which describes the attributes of this stream / terminal.
type Attributes: AbstractTerminalAttributes + fmt::Debug;
/// Returns whether or not this stream refers to an interactive terminal (a
/// TTY), as opposed to, for example, a pipe.
fn isatty(&self) -> bool;
/// Retrieve the current attributes of this stream / terminal.
fn get_attributes(&self) -> IoResult<Self::Attributes>;
/// Modify this stream's / terminal's attributes to match the given state.
fn set_attributes(&mut self, attributes: &Self::Attributes) -> IoResult<()>;
/// Return a `Read` for this stream, if reading is supported.
fn as_reader(&self) -> Option<Box<dyn Read>>;
/// Return a `Write` for this stream, if writing is supported.
fn as_writer(&self) -> Option<Box<dyn Write>>;
}
/// Standard input / output streams.
#[derive(Debug)]
pub enum Stream {
/// Standard output.
Stdout,
/// Standard error.
Stderr,
/// Standard input.
Stdin,
}
impl Stream {
fn to_fd(&self) -> c_int {
match *self {
Stream::Stdout => libc::STDOUT_FILENO,
Stream::Stderr => libc::STDERR_FILENO,
Stream::Stdin => libc::STDIN_FILENO,
}
}
}
impl AbstractStream for Stream {
type Attributes = TerminalAttributes;
fn isatty(&self) -> bool {
let ret = unsafe { libc::isatty(self.to_fd()) };
let error: i32 = errno::errno().into();
match ret {
1 => true,
0 => match error {
libc::EBADF => false,
libc::ENOTTY => false,
_ => {
debug!(
"Unrecognized isatty errno: {}; assuming {:?} is not a TTY",
error, *self
);
false
}
},
_ => {
debug!(
"Unrecognized isatty return code: {}; assuming {:?} is not a TTY",
ret, *self
);
false
| random_line_split |
||
helmrepoutils.go | ("package", "utils", "method", "GetHelmRepoClient")
httpClient := http.DefaultClient
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: false,
},
}
if configMap != nil {
configData := configMap.Data
srLogger.Info("ConfigRef retrieved", "configMap.Data", configData)
if configData["insecureSkipVerify"] != "" {
b, err := strconv.ParseBool(configData["insecureSkipVerify"])
if err != nil {
if errors.IsNotFound(err) {
return nil, nil
}
srLogger.Error(err, "Unable to parse", "insecureSkipVerify", configData["insecureSkipVerify"])
return nil, err
}
srLogger.Info("Set InsecureSkipVerify", "insecureSkipVerify", b)
transport.TLSClientConfig.InsecureSkipVerify = b
} else {
srLogger.Info("insecureSkipVerify is not specified")
}
} else {
srLogger.Info("configMap is nil")
}
httpClient.Transport = transport
srLogger.Info("InsecureSkipVerify equal", "InsecureSkipVerify", transport.TLSClientConfig.InsecureSkipVerify)
return httpClient, nil
}
//GetConfigMap search the config map containing the helm repo client configuration.
func GetConfigMap(client client.Client, parentNamespace string, configMapRef *corev1.ObjectReference) (configMap *corev1.ConfigMap, err error) {
srLogger := log.WithValues("package", "utils", "method", "getConfigMap")
if configMapRef != nil {
srLogger.Info("Retrieve configMap ", "parentNamespace", parentNamespace, "configMapRef.Name", configMapRef.Name)
ns := configMapRef.Namespace
if ns == "" {
ns = parentNamespace
}
configMap = &corev1.ConfigMap{}
err = client.Get(context.TODO(), types.NamespacedName{Namespace: ns, Name: configMapRef.Name}, configMap)
if err != nil {
if errors.IsNotFound(err) {
srLogger.Error(err, "ConfigMap not found ", "Name:", configMapRef.Name, " on namespace: ", ns)
return nil, nil
}
srLogger.Error(err, "Failed to get configMap ", "Name:", configMapRef.Name, " on namespace: ", ns)
return nil, err
}
srLogger.Info("ConfigMap found ", "Name:", configMapRef.Name, " on namespace: ", ns)
} else {
srLogger.Info("no configMapRef defined ", "parentNamespace", parentNamespace)
}
return configMap, err
}
//GetSecret returns the secret to access the helm-repo
func | (client client.Client, parentNamespace string, secretRef *corev1.ObjectReference) (secret *corev1.Secret, err error) {
srLogger := log.WithValues("package", "utils", "method", "getSecret")
if secretRef != nil {
srLogger.Info("Retreive secret", "parentNamespace", parentNamespace, "secretRef", secretRef)
ns := secretRef.Namespace
if ns == "" {
ns = parentNamespace
}
secret = &corev1.Secret{}
err = client.Get(context.TODO(), types.NamespacedName{Namespace: ns, Name: secretRef.Name}, secret)
if err != nil {
srLogger.Error(err, "Failed to get secret ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
return nil, err
}
srLogger.Info("Secret found ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
} else {
srLogger.Info("No secret defined", "parentNamespace", parentNamespace)
}
return secret, err
}
func DownloadChart(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
switch strings.ToLower(string(s.Spec.Source.SourceType)) {
case string(appv1alpha1.HelmRepoSourceType):
return DownloadChartFromHelmRepo(configMap, secret, chartsDir, s)
case string(appv1alpha1.GitHubSourceType):
return DownloadChartFromGitHub(configMap, secret, chartsDir, s)
default:
return "", fmt.Errorf("SourceType '%s' unsupported", s.Spec.Source.SourceType)
}
}
//DownloadChartFromGitHub downloads a chart into the charsDir
func DownloadChartFromGitHub(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.GitHub == nil {
err := fmt.Errorf("GitHub type but Spec.GitHub is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
destRepo := filepath.Join(chartsDir, s.Spec.ReleaseName, s.Namespace, s.Spec.ChartName)
for _, url := range s.Spec.Source.GitHub.Urls {
options := &git.CloneOptions{
URL: url,
Depth: 1,
SingleBranch: true,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
}
if secret != nil && secret.Data != nil {
srLogger.Info("Add credentials")
options.Auth = &githttp.BasicAuth{
Username: string(secret.Data["user"]),
Password: string(secret.Data["password"]),
}
}
if s.Spec.Source.GitHub.Branch == "" {
options.ReferenceName = plumbing.Master
} else {
options.ReferenceName = plumbing.ReferenceName(s.Spec.Source.GitHub.Branch)
}
os.RemoveAll(chartDir)
_, err = git.PlainClone(destRepo, false, options)
if err != nil {
os.RemoveAll(destRepo)
srLogger.Error(err, "Clone failed", "url", url)
continue
}
}
if err != nil {
srLogger.Error(err, "All urls failed")
}
chartDir = filepath.Join(destRepo, s.Spec.Source.GitHub.ChartPath)
return chartDir, err
}
//DownloadChartFromHelmRepo downloads a chart into the charsDir
func DownloadChartFromHelmRepo(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.HelmRepo == nil {
err := fmt.Errorf("HelmRepo type but Spec.HelmRepo is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
httpClient, err := GetHelmRepoClient(s.Namespace, configMap)
if err != nil {
srLogger.Error(err, "Failed to create httpClient ", "sr.Spec.SecretRef.Name", s.Spec.SecretRef.Name)
return "", err
}
var downloadErr error
for _, urlelem := range s.Spec.Source.HelmRepo.Urls {
var URLP *url.URL
URLP, downloadErr = url.Parse(urlelem)
if err != nil {
srLogger.Error(downloadErr, "url", urlelem)
continue
}
fileName := filepath.Base(URLP.Path)
// Create the file
chartZip := filepath.Join(chartsDir, fileName)
if _, err := os.Stat(chartZip); os.IsNotExist(err) {
var req *http.Request
req, downloadErr = http.NewRequest(http.MethodGet, urlelem, nil)
if downloadErr != nil {
srLogger.Error(downloadErr, "Can not build request: ", "urlelem", urlelem)
continue
}
if secret != nil && secret.Data != nil {
req.SetBasicAuth(string(secret.Data["user"]), string(secret.Data["password"]))
}
var resp *http.Response
resp, downloadErr = httpClient.Do(req)
if downloadErr != nil {
srLogger.Error(downloadErr, | GetSecret | identifier_name |
helmrepoutils.go | Values("package", "utils", "method", "GetHelmRepoClient")
httpClient := http.DefaultClient
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: false,
},
}
if configMap != nil {
configData := configMap.Data
srLogger.Info("ConfigRef retrieved", "configMap.Data", configData)
if configData["insecureSkipVerify"] != "" {
b, err := strconv.ParseBool(configData["insecureSkipVerify"])
if err != nil {
if errors.IsNotFound(err) {
return nil, nil
}
srLogger.Error(err, "Unable to parse", "insecureSkipVerify", configData["insecureSkipVerify"])
return nil, err
}
srLogger.Info("Set InsecureSkipVerify", "insecureSkipVerify", b)
transport.TLSClientConfig.InsecureSkipVerify = b
} else {
srLogger.Info("insecureSkipVerify is not specified")
}
} else {
srLogger.Info("configMap is nil")
}
httpClient.Transport = transport
srLogger.Info("InsecureSkipVerify equal", "InsecureSkipVerify", transport.TLSClientConfig.InsecureSkipVerify)
return httpClient, nil
}
//GetConfigMap search the config map containing the helm repo client configuration.
func GetConfigMap(client client.Client, parentNamespace string, configMapRef *corev1.ObjectReference) (configMap *corev1.ConfigMap, err error) {
srLogger := log.WithValues("package", "utils", "method", "getConfigMap")
if configMapRef != nil {
srLogger.Info("Retrieve configMap ", "parentNamespace", parentNamespace, "configMapRef.Name", configMapRef.Name)
ns := configMapRef.Namespace
if ns == "" {
ns = parentNamespace
}
configMap = &corev1.ConfigMap{}
err = client.Get(context.TODO(), types.NamespacedName{Namespace: ns, Name: configMapRef.Name}, configMap)
if err != nil {
if errors.IsNotFound(err) {
srLogger.Error(err, "ConfigMap not found ", "Name:", configMapRef.Name, " on namespace: ", ns)
return nil, nil
}
srLogger.Error(err, "Failed to get configMap ", "Name:", configMapRef.Name, " on namespace: ", ns)
return nil, err
}
srLogger.Info("ConfigMap found ", "Name:", configMapRef.Name, " on namespace: ", ns)
} else {
srLogger.Info("no configMapRef defined ", "parentNamespace", parentNamespace)
}
return configMap, err
}
//GetSecret returns the secret to access the helm-repo
func GetSecret(client client.Client, parentNamespace string, secretRef *corev1.ObjectReference) (secret *corev1.Secret, err error) {
srLogger := log.WithValues("package", "utils", "method", "getSecret")
if secretRef != nil {
srLogger.Info("Retreive secret", "parentNamespace", parentNamespace, "secretRef", secretRef)
ns := secretRef.Namespace
if ns == "" {
ns = parentNamespace
}
secret = &corev1.Secret{}
err = client.Get(context.TODO(), types.NamespacedName{Namespace: ns, Name: secretRef.Name}, secret)
if err != nil {
srLogger.Error(err, "Failed to get secret ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
return nil, err
}
srLogger.Info("Secret found ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
} else {
srLogger.Info("No secret defined", "parentNamespace", parentNamespace)
}
return secret, err
}
func DownloadChart(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
switch strings.ToLower(string(s.Spec.Source.SourceType)) {
case string(appv1alpha1.HelmRepoSourceType):
return DownloadChartFromHelmRepo(configMap, secret, chartsDir, s)
case string(appv1alpha1.GitHubSourceType):
return DownloadChartFromGitHub(configMap, secret, chartsDir, s)
default:
return "", fmt.Errorf("SourceType '%s' unsupported", s.Spec.Source.SourceType)
}
}
//DownloadChartFromGitHub downloads a chart into the charsDir
func DownloadChartFromGitHub(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.GitHub == nil {
err := fmt.Errorf("GitHub type but Spec.GitHub is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
destRepo := filepath.Join(chartsDir, s.Spec.ReleaseName, s.Namespace, s.Spec.ChartName)
for _, url := range s.Spec.Source.GitHub.Urls {
options := &git.CloneOptions{
URL: url,
Depth: 1,
SingleBranch: true,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
}
if secret != nil && secret.Data != nil {
srLogger.Info("Add credentials")
options.Auth = &githttp.BasicAuth{
Username: string(secret.Data["user"]),
Password: string(secret.Data["password"]),
}
}
if s.Spec.Source.GitHub.Branch == "" {
options.ReferenceName = plumbing.Master
} else {
options.ReferenceName = plumbing.ReferenceName(s.Spec.Source.GitHub.Branch)
}
os.RemoveAll(chartDir)
_, err = git.PlainClone(destRepo, false, options)
if err != nil {
os.RemoveAll(destRepo)
srLogger.Error(err, "Clone failed", "url", url)
continue
}
}
if err != nil {
srLogger.Error(err, "All urls failed")
}
chartDir = filepath.Join(destRepo, s.Spec.Source.GitHub.ChartPath)
return chartDir, err
}
//DownloadChartFromHelmRepo downloads a chart into the charsDir | srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.HelmRepo == nil {
err := fmt.Errorf("HelmRepo type but Spec.HelmRepo is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
httpClient, err := GetHelmRepoClient(s.Namespace, configMap)
if err != nil {
srLogger.Error(err, "Failed to create httpClient ", "sr.Spec.SecretRef.Name", s.Spec.SecretRef.Name)
return "", err
}
var downloadErr error
for _, urlelem := range s.Spec.Source.HelmRepo.Urls {
var URLP *url.URL
URLP, downloadErr = url.Parse(urlelem)
if err != nil {
srLogger.Error(downloadErr, "url", urlelem)
continue
}
fileName := filepath.Base(URLP.Path)
// Create the file
chartZip := filepath.Join(chartsDir, fileName)
if _, err := os.Stat(chartZip); os.IsNotExist(err) {
var req *http.Request
req, downloadErr = http.NewRequest(http.MethodGet, urlelem, nil)
if downloadErr != nil {
srLogger.Error(downloadErr, "Can not build request: ", "urlelem", urlelem)
continue
}
if secret != nil && secret.Data != nil {
req.SetBasicAuth(string(secret.Data["user"]), string(secret.Data["password"]))
}
var resp *http.Response
resp, downloadErr = httpClient.Do(req)
if downloadErr != nil {
srLogger.Error(downloadErr, " | func DownloadChartFromHelmRepo(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) { | random_line_split |
helmrepoutils.go | namespace: ", ns)
} else {
srLogger.Info("no configMapRef defined ", "parentNamespace", parentNamespace)
}
return configMap, err
}
//GetSecret returns the secret to access the helm-repo
func GetSecret(client client.Client, parentNamespace string, secretRef *corev1.ObjectReference) (secret *corev1.Secret, err error) {
srLogger := log.WithValues("package", "utils", "method", "getSecret")
if secretRef != nil {
srLogger.Info("Retreive secret", "parentNamespace", parentNamespace, "secretRef", secretRef)
ns := secretRef.Namespace
if ns == "" {
ns = parentNamespace
}
secret = &corev1.Secret{}
err = client.Get(context.TODO(), types.NamespacedName{Namespace: ns, Name: secretRef.Name}, secret)
if err != nil {
srLogger.Error(err, "Failed to get secret ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
return nil, err
}
srLogger.Info("Secret found ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
} else {
srLogger.Info("No secret defined", "parentNamespace", parentNamespace)
}
return secret, err
}
func DownloadChart(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
switch strings.ToLower(string(s.Spec.Source.SourceType)) {
case string(appv1alpha1.HelmRepoSourceType):
return DownloadChartFromHelmRepo(configMap, secret, chartsDir, s)
case string(appv1alpha1.GitHubSourceType):
return DownloadChartFromGitHub(configMap, secret, chartsDir, s)
default:
return "", fmt.Errorf("SourceType '%s' unsupported", s.Spec.Source.SourceType)
}
}
//DownloadChartFromGitHub downloads a chart into the charsDir
func DownloadChartFromGitHub(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.GitHub == nil {
err := fmt.Errorf("GitHub type but Spec.GitHub is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
destRepo := filepath.Join(chartsDir, s.Spec.ReleaseName, s.Namespace, s.Spec.ChartName)
for _, url := range s.Spec.Source.GitHub.Urls {
options := &git.CloneOptions{
URL: url,
Depth: 1,
SingleBranch: true,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,
}
if secret != nil && secret.Data != nil {
srLogger.Info("Add credentials")
options.Auth = &githttp.BasicAuth{
Username: string(secret.Data["user"]),
Password: string(secret.Data["password"]),
}
}
if s.Spec.Source.GitHub.Branch == "" {
options.ReferenceName = plumbing.Master
} else {
options.ReferenceName = plumbing.ReferenceName(s.Spec.Source.GitHub.Branch)
}
os.RemoveAll(chartDir)
_, err = git.PlainClone(destRepo, false, options)
if err != nil {
os.RemoveAll(destRepo)
srLogger.Error(err, "Clone failed", "url", url)
continue
}
}
if err != nil {
srLogger.Error(err, "All urls failed")
}
chartDir = filepath.Join(destRepo, s.Spec.Source.GitHub.ChartPath)
return chartDir, err
}
//DownloadChartFromHelmRepo downloads a chart into the charsDir
func DownloadChartFromHelmRepo(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.HelmRepo == nil {
err := fmt.Errorf("HelmRepo type but Spec.HelmRepo is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
httpClient, err := GetHelmRepoClient(s.Namespace, configMap)
if err != nil {
srLogger.Error(err, "Failed to create httpClient ", "sr.Spec.SecretRef.Name", s.Spec.SecretRef.Name)
return "", err
}
var downloadErr error
for _, urlelem := range s.Spec.Source.HelmRepo.Urls {
var URLP *url.URL
URLP, downloadErr = url.Parse(urlelem)
if err != nil {
srLogger.Error(downloadErr, "url", urlelem)
continue
}
fileName := filepath.Base(URLP.Path)
// Create the file
chartZip := filepath.Join(chartsDir, fileName)
if _, err := os.Stat(chartZip); os.IsNotExist(err) {
var req *http.Request
req, downloadErr = http.NewRequest(http.MethodGet, urlelem, nil)
if downloadErr != nil {
srLogger.Error(downloadErr, "Can not build request: ", "urlelem", urlelem)
continue
}
if secret != nil && secret.Data != nil {
req.SetBasicAuth(string(secret.Data["user"]), string(secret.Data["password"]))
}
var resp *http.Response
resp, downloadErr = httpClient.Do(req)
if downloadErr != nil {
srLogger.Error(downloadErr, "Http request failed: ", "urlelem", urlelem)
continue
}
srLogger.Info("Get suceeded: ", "urlelem", urlelem)
defer resp.Body.Close()
var out *os.File
out, downloadErr = os.Create(chartZip)
if downloadErr != nil {
srLogger.Error(downloadErr, "Failed to create: ", "chartZip", chartZip)
continue
}
defer out.Close()
// Write the body to file
_, downloadErr = io.Copy(out, resp.Body)
if downloadErr != nil {
srLogger.Error(downloadErr, "Failed to copy body: ", "chartZip", chartZip)
continue
}
}
var r *os.File
r, downloadErr = os.Open(chartZip)
if downloadErr != nil {
srLogger.Error(downloadErr, "Failed to open: ", "chartZip", chartZip)
continue
}
chartDirUnzip := filepath.Join(chartsDir, s.Spec.ReleaseName, s.Namespace)
chartDir = filepath.Join(chartDirUnzip, s.Spec.ChartName)
//Clean before untar
os.RemoveAll(chartDirUnzip)
downloadErr = Untar(chartDirUnzip, r)
if downloadErr != nil {
//Remove zip because failed to untar and so probably corrupted
os.RemoveAll(chartZip)
srLogger.Error(downloadErr, "Failed to unzip: ", "chartZip", chartZip)
continue
}
}
return chartDir, downloadErr
}
//Untar untars the reader into the dst directory
func Untar(dst string, r io.Reader) error {
srLogger := log.WithValues("destination", dst)
gzr, err := gzip.NewReader(r)
if err != nil {
srLogger.Error(err, "")
return err
}
defer gzr.Close()
tr := tar.NewReader(gzr)
for {
header, err := tr.Next()
switch {
// if no more files are found return
case err == io.EOF:
return nil
// return any other error
case err != nil:
srLogger.Error(err, "")
return err
// if the header is nil, just skip it (not sure how this happens)
case header == nil:
continue
}
// the target location where the dir/file should be created
target := filepath.Join(dst, header.Name)
// the following switch could also be done using fi.Mode(), not sure if there
// a benefit of using one vs. the other.
// fi := header.FileInfo()
// check the file type
switch header.Typeflag {
// if its a dir and it doesn't exist create it
case tar.TypeDir:
if _, err := os.Stat(target); err != nil {
if err := os.MkdirAll(target, 0755); err != nil | {
srLogger.Error(err, "")
return err
} | conditional_block |
|
helmrepoutils.go | ("package", "utils", "method", "GetHelmRepoClient")
httpClient := http.DefaultClient
transport := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
DualStack: true,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: false,
},
}
if configMap != nil {
configData := configMap.Data
srLogger.Info("ConfigRef retrieved", "configMap.Data", configData)
if configData["insecureSkipVerify"] != "" {
b, err := strconv.ParseBool(configData["insecureSkipVerify"])
if err != nil {
if errors.IsNotFound(err) {
return nil, nil
}
srLogger.Error(err, "Unable to parse", "insecureSkipVerify", configData["insecureSkipVerify"])
return nil, err
}
srLogger.Info("Set InsecureSkipVerify", "insecureSkipVerify", b)
transport.TLSClientConfig.InsecureSkipVerify = b
} else {
srLogger.Info("insecureSkipVerify is not specified")
}
} else {
srLogger.Info("configMap is nil")
}
httpClient.Transport = transport
srLogger.Info("InsecureSkipVerify equal", "InsecureSkipVerify", transport.TLSClientConfig.InsecureSkipVerify)
return httpClient, nil
}
//GetConfigMap search the config map containing the helm repo client configuration.
func GetConfigMap(client client.Client, parentNamespace string, configMapRef *corev1.ObjectReference) (configMap *corev1.ConfigMap, err error) {
srLogger := log.WithValues("package", "utils", "method", "getConfigMap")
if configMapRef != nil {
srLogger.Info("Retrieve configMap ", "parentNamespace", parentNamespace, "configMapRef.Name", configMapRef.Name)
ns := configMapRef.Namespace
if ns == "" {
ns = parentNamespace
}
configMap = &corev1.ConfigMap{}
err = client.Get(context.TODO(), types.NamespacedName{Namespace: ns, Name: configMapRef.Name}, configMap)
if err != nil {
if errors.IsNotFound(err) {
srLogger.Error(err, "ConfigMap not found ", "Name:", configMapRef.Name, " on namespace: ", ns)
return nil, nil
}
srLogger.Error(err, "Failed to get configMap ", "Name:", configMapRef.Name, " on namespace: ", ns)
return nil, err
}
srLogger.Info("ConfigMap found ", "Name:", configMapRef.Name, " on namespace: ", ns)
} else {
srLogger.Info("no configMapRef defined ", "parentNamespace", parentNamespace)
}
return configMap, err
}
//GetSecret returns the secret to access the helm-repo
func GetSecret(client client.Client, parentNamespace string, secretRef *corev1.ObjectReference) (secret *corev1.Secret, err error) {
srLogger := log.WithValues("package", "utils", "method", "getSecret")
if secretRef != nil {
srLogger.Info("Retreive secret", "parentNamespace", parentNamespace, "secretRef", secretRef)
ns := secretRef.Namespace
if ns == "" {
ns = parentNamespace
}
secret = &corev1.Secret{}
err = client.Get(context.TODO(), types.NamespacedName{Namespace: ns, Name: secretRef.Name}, secret)
if err != nil {
srLogger.Error(err, "Failed to get secret ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
return nil, err
}
srLogger.Info("Secret found ", "Name:", secretRef.Name, " on namespace: ", secretRef.Namespace)
} else {
srLogger.Info("No secret defined", "parentNamespace", parentNamespace)
}
return secret, err
}
func DownloadChart(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
switch strings.ToLower(string(s.Spec.Source.SourceType)) {
case string(appv1alpha1.HelmRepoSourceType):
return DownloadChartFromHelmRepo(configMap, secret, chartsDir, s)
case string(appv1alpha1.GitHubSourceType):
return DownloadChartFromGitHub(configMap, secret, chartsDir, s)
default:
return "", fmt.Errorf("SourceType '%s' unsupported", s.Spec.Source.SourceType)
}
}
//DownloadChartFromGitHub downloads a chart into the charsDir
func DownloadChartFromGitHub(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) | }
if secret != nil && secret.Data != nil {
srLogger.Info("Add credentials")
options.Auth = &githttp.BasicAuth{
Username: string(secret.Data["user"]),
Password: string(secret.Data["password"]),
}
}
if s.Spec.Source.GitHub.Branch == "" {
options.ReferenceName = plumbing.Master
} else {
options.ReferenceName = plumbing.ReferenceName(s.Spec.Source.GitHub.Branch)
}
os.RemoveAll(chartDir)
_, err = git.PlainClone(destRepo, false, options)
if err != nil {
os.RemoveAll(destRepo)
srLogger.Error(err, "Clone failed", "url", url)
continue
}
}
if err != nil {
srLogger.Error(err, "All urls failed")
}
chartDir = filepath.Join(destRepo, s.Spec.Source.GitHub.ChartPath)
return chartDir, err
}
//DownloadChartFromHelmRepo downloads a chart into the charsDir
func DownloadChartFromHelmRepo(configMap *corev1.ConfigMap, secret *corev1.Secret, chartsDir string, s *appv1alpha1.HelmRelease) (chartDir string, err error) {
srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.HelmRepo == nil {
err := fmt.Errorf("HelmRepo type but Spec.HelmRepo is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
httpClient, err := GetHelmRepoClient(s.Namespace, configMap)
if err != nil {
srLogger.Error(err, "Failed to create httpClient ", "sr.Spec.SecretRef.Name", s.Spec.SecretRef.Name)
return "", err
}
var downloadErr error
for _, urlelem := range s.Spec.Source.HelmRepo.Urls {
var URLP *url.URL
URLP, downloadErr = url.Parse(urlelem)
if err != nil {
srLogger.Error(downloadErr, "url", urlelem)
continue
}
fileName := filepath.Base(URLP.Path)
// Create the file
chartZip := filepath.Join(chartsDir, fileName)
if _, err := os.Stat(chartZip); os.IsNotExist(err) {
var req *http.Request
req, downloadErr = http.NewRequest(http.MethodGet, urlelem, nil)
if downloadErr != nil {
srLogger.Error(downloadErr, "Can not build request: ", "urlelem", urlelem)
continue
}
if secret != nil && secret.Data != nil {
req.SetBasicAuth(string(secret.Data["user"]), string(secret.Data["password"]))
}
var resp *http.Response
resp, downloadErr = httpClient.Do(req)
if downloadErr != nil {
srLogger.Error(downloadErr, | {
srLogger := log.WithValues("HelmRelease.Namespace", s.Namespace, "SubscrptionRelease.Name", s.Name)
if s.Spec.Source.GitHub == nil {
err := fmt.Errorf("GitHub type but Spec.GitHub is not defined")
return "", err
}
if _, err := os.Stat(chartsDir); os.IsNotExist(err) {
err := os.MkdirAll(chartsDir, 0755)
if err != nil {
srLogger.Error(err, "Unable to create chartDir: ", "chartsDir", chartsDir)
return "", err
}
}
destRepo := filepath.Join(chartsDir, s.Spec.ReleaseName, s.Namespace, s.Spec.ChartName)
for _, url := range s.Spec.Source.GitHub.Urls {
options := &git.CloneOptions{
URL: url,
Depth: 1,
SingleBranch: true,
RecurseSubmodules: git.DefaultSubmoduleRecursionDepth, | identifier_body |
ResNet50_augmentation.py |
def get_dataset(ds_path):
ds_path = pathlib.Path(ds_path)
images = list(ds_path.glob('*/*.jpg'))
images = [str(path) for path in images]
total_images = len(images)
labels = sorted(item.name for item in ds_path.glob('*/') if item.is_dir())
classes = labels
labels = dict((name, index) for index, name in enumerate(labels))
labels = [labels[pathlib.Path(path).parent.name] for path in images]
labels = tf.keras.utils.to_categorical(labels, num_classes=len(classes), dtype='float32')
return images, labels, classes
def aug_fn(image):
data = {"image":image}
aug_data = transforms(**data)
aug_img = aug_data["image"]
aug_img = tf.cast(aug_img, tf.float32) / 255.0
aug_img = tf.image.per_image_standardization(aug_img)
# aug_img = tf.keras.applications.resnet.preprocess_input(aug_img)
return aug_img
def process_data(image, label):
aug_img = tf.numpy_function(func=aug_fn, inp=[image], Tout=tf.float32)
return aug_img, label
def make_tf_data(images, labels, augmentation):
images = tf.data.Dataset.from_tensor_slices(images)
images = images.map(preprocess_image, num_parallel_calls=AUTOTUNE)
labels = tf.data.Dataset.from_tensor_slices(labels)
dataset = tf.data.Dataset.zip((images, labels))
dataset = dataset.repeat()
if augmentation: |
dataset = dataset.batch(BATCH_SIZE)
dataset = dataset.prefetch(AUTOTUNE)
return dataset
def residual_block(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
if conv_shortcut:
shortcut = tf.keras.layers.Conv2D(4 * filters, 1, strides=stride, name=name+'_0_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
shortcut = tf.keras.layers.BatchNormalization(axis=3, name=name+'_0_bn')(shortcut)
else:
shortcut = x
x = tf.keras.layers.Conv2D(filters, 1, strides=stride, name=name + '_1_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_1_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_1_relu')(x)
x = tf.keras.layers.Conv2D(filters, kernel_size, padding='SAME', name=name + '_2_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_2_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_2_relu')(x)
x = tf.keras.layers.Conv2D(4 * filters, 1, name=name + '_3_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_3_bn')(x)
x = tf.keras.layers.Add(name=name + '_add')([shortcut, x])
x = tf.keras.layers.Activation('relu', name=name + '_out')(x)
return x
def residual_stack(x, filters, blocks, stride1=2, name=None):
x = residual_block(x, filters, stride=stride1, name=name + '_block1')
for i in range(2, blocks + 1):
x = residual_block(x, filters, conv_shortcut=False, name=name + '_block' + str(i))
return x
def ResNet50():
inputs = tf.keras.layers.Input(shape=INPUT_SHAPE)
x = tf.keras.layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)
x = tf.keras.layers.Conv2D(64, 7, strides=2, use_bias=True, name='conv1_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name='conv1_bn')(x)
x = tf.keras.layers.Activation('relu', name='conv1_relu')(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = tf.keras.layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = residual_stack(x, 64, 3, stride1=1, name='conv2')
x = residual_stack(x, 128, 4, name='conv3')
x = residual_stack(x, 256, 6, name='conv4')
x = residual_stack(x, 512, 3, name='conv5')
x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)
outputs = tf.keras.layers.Dense(n_classes, activation='softmax', name='predictions')(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
return model
@tf.function
def train(model, images, labels):
with tf.GradientTape() as tape:
y_pred = model(images, training=True)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(grads_and_vars=zip(grads, model.trainable_variables))
train_acc.update_state(labels, y_pred)
train_loss.update_state(labels, y_pred)
@tf.function
def validation(model, images, labels):
y_pred = model(images, training=False)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
val_acc.update_state(labels, y_pred)
val_loss.update_state(labels, y_pred)
def lrfn():
if epoch < LR_RAMPUP_EPOCHS:
lr = (LR_MAX - LR_START) / LR_RAMPUP_EPOCHS * epoch + LR_START
elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:
lr = LR_MAX
else:
lr = (LR_MAX - LR_MIN) * LR_EXP_DECAY**(epoch - LR_RAMPUP_EPOCHS - LR_SUSTAIN_EPOCHS) + LR_MIN
return lr
def tf_data_visualize(augmentation_element, name):
row, col, idx = 5, 4, 0
row = min(row, BATCH_SIZE // col)
for (image, label) in augmentation_element:
print(image.shape, label.shape)
image = image / 255.0
plt.figure(figsize=(15, int(15 * row / col)))
for j in range(row * col):
plt.subplot(row, col, j + 1)
plt.axis('off')
plt.imshow(image[j, ])
# plt.savefig(f'{SAVED_PATH}/{LOG_TIME}/{name}_{idx}.jpg')
plt.show()
idx += 1
if idx == 3:
break
if __name__ == "__main__":
# hyper parameters
AUTOTUNE = tf.data.experimental.AUTOTUNE
IMG_SIZE = 224
INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)
BATCH_SIZE = 32
EPOCHS = 1000
# learning rate scheduler
LR_START = 0.001
LR_MAX = 0.005 * strategy.num_replicas_in_sync
LR_MIN = 0.001
LR_RAMPUP_EPOCHS = 5
LR_SUSTAIN_EPOCHS = 0
LR_EXP_DECAY = .8
# early stopping
PATIENCE = 3
EARLY_STOPPING = True
minimum_loss = float(2147000000)
total_images, total_labels, CLASSES = get_dataset('/home/v100/tf_workspace/datasets/natural_images/natural_images')
n_classes = len(CLASSES)
train_images, valid_images, train_labels, valid_labels = train_test_split(total_images, total_labels, test_size=.3, shuffle=True, random_state=777)
TRAIN_STEPS_PER_EPOCH = int(tf.math.ceil(len(train_images) / BATCH_SIZE).numpy())
VALID_STEP_PER_EPOCH = int(tf.math.ceil(len(valid_images) / BATCH_SIZE).numpy())
cost_fn = tf.keras.losses.CategoricalCrossentropy()
# optimizer = tf.keras.optimizers.Adam(learning_rate=lrfn)
optimizer = tf.keras.optimizers.Adam(learning_rate=0.00001)
inputs = tf.keras.Input(shape=(INPUT_SHAPE))
model = ResNet50()
model(inputs=inputs)
model.summary()
# tf.keras.utils.plot_model(model, show_shapes=True)
train_acc = | dataset = dataset.map(partial(process_data), num_parallel_calls=AUTOTUNE) | random_line_split |
ResNet50_augmentation.py |
def get_dataset(ds_path):
ds_path = pathlib.Path(ds_path)
images = list(ds_path.glob('*/*.jpg'))
images = [str(path) for path in images]
total_images = len(images)
labels = sorted(item.name for item in ds_path.glob('*/') if item.is_dir())
classes = labels
labels = dict((name, index) for index, name in enumerate(labels))
labels = [labels[pathlib.Path(path).parent.name] for path in images]
labels = tf.keras.utils.to_categorical(labels, num_classes=len(classes), dtype='float32')
return images, labels, classes
def aug_fn(image):
data = {"image":image}
aug_data = transforms(**data)
aug_img = aug_data["image"]
aug_img = tf.cast(aug_img, tf.float32) / 255.0
aug_img = tf.image.per_image_standardization(aug_img)
# aug_img = tf.keras.applications.resnet.preprocess_input(aug_img)
return aug_img
def process_data(image, label):
|
def make_tf_data(images, labels, augmentation):
images = tf.data.Dataset.from_tensor_slices(images)
images = images.map(preprocess_image, num_parallel_calls=AUTOTUNE)
labels = tf.data.Dataset.from_tensor_slices(labels)
dataset = tf.data.Dataset.zip((images, labels))
dataset = dataset.repeat()
if augmentation:
dataset = dataset.map(partial(process_data), num_parallel_calls=AUTOTUNE)
dataset = dataset.batch(BATCH_SIZE)
dataset = dataset.prefetch(AUTOTUNE)
return dataset
def residual_block(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
if conv_shortcut:
shortcut = tf.keras.layers.Conv2D(4 * filters, 1, strides=stride, name=name+'_0_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
shortcut = tf.keras.layers.BatchNormalization(axis=3, name=name+'_0_bn')(shortcut)
else:
shortcut = x
x = tf.keras.layers.Conv2D(filters, 1, strides=stride, name=name + '_1_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_1_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_1_relu')(x)
x = tf.keras.layers.Conv2D(filters, kernel_size, padding='SAME', name=name + '_2_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_2_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_2_relu')(x)
x = tf.keras.layers.Conv2D(4 * filters, 1, name=name + '_3_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_3_bn')(x)
x = tf.keras.layers.Add(name=name + '_add')([shortcut, x])
x = tf.keras.layers.Activation('relu', name=name + '_out')(x)
return x
def residual_stack(x, filters, blocks, stride1=2, name=None):
x = residual_block(x, filters, stride=stride1, name=name + '_block1')
for i in range(2, blocks + 1):
x = residual_block(x, filters, conv_shortcut=False, name=name + '_block' + str(i))
return x
def ResNet50():
inputs = tf.keras.layers.Input(shape=INPUT_SHAPE)
x = tf.keras.layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)
x = tf.keras.layers.Conv2D(64, 7, strides=2, use_bias=True, name='conv1_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name='conv1_bn')(x)
x = tf.keras.layers.Activation('relu', name='conv1_relu')(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = tf.keras.layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = residual_stack(x, 64, 3, stride1=1, name='conv2')
x = residual_stack(x, 128, 4, name='conv3')
x = residual_stack(x, 256, 6, name='conv4')
x = residual_stack(x, 512, 3, name='conv5')
x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)
outputs = tf.keras.layers.Dense(n_classes, activation='softmax', name='predictions')(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
return model
@tf.function
def train(model, images, labels):
with tf.GradientTape() as tape:
y_pred = model(images, training=True)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(grads_and_vars=zip(grads, model.trainable_variables))
train_acc.update_state(labels, y_pred)
train_loss.update_state(labels, y_pred)
@tf.function
def validation(model, images, labels):
y_pred = model(images, training=False)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
val_acc.update_state(labels, y_pred)
val_loss.update_state(labels, y_pred)
def lrfn():
if epoch < LR_RAMPUP_EPOCHS:
lr = (LR_MAX - LR_START) / LR_RAMPUP_EPOCHS * epoch + LR_START
elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:
lr = LR_MAX
else:
lr = (LR_MAX - LR_MIN) * LR_EXP_DECAY**(epoch - LR_RAMPUP_EPOCHS - LR_SUSTAIN_EPOCHS) + LR_MIN
return lr
def tf_data_visualize(augmentation_element, name):
row, col, idx = 5, 4, 0
row = min(row, BATCH_SIZE // col)
for (image, label) in augmentation_element:
print(image.shape, label.shape)
image = image / 255.0
plt.figure(figsize=(15, int(15 * row / col)))
for j in range(row * col):
plt.subplot(row, col, j + 1)
plt.axis('off')
plt.imshow(image[j, ])
# plt.savefig(f'{SAVED_PATH}/{LOG_TIME}/{name}_{idx}.jpg')
plt.show()
idx += 1
if idx == 3:
break
if __name__ == "__main__":
# hyper parameters
AUTOTUNE = tf.data.experimental.AUTOTUNE
IMG_SIZE = 224
INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)
BATCH_SIZE = 32
EPOCHS = 1000
# learning rate scheduler
LR_START = 0.001
LR_MAX = 0.005 * strategy.num_replicas_in_sync
LR_MIN = 0.001
LR_RAMPUP_EPOCHS = 5
LR_SUSTAIN_EPOCHS = 0
LR_EXP_DECAY = .8
# early stopping
PATIENCE = 3
EARLY_STOPPING = True
minimum_loss = float(2147000000)
total_images, total_labels, CLASSES = get_dataset('/home/v100/tf_workspace/datasets/natural_images/natural_images')
n_classes = len(CLASSES)
train_images, valid_images, train_labels, valid_labels = train_test_split(total_images, total_labels, test_size=.3, shuffle=True, random_state=777)
TRAIN_STEPS_PER_EPOCH = int(tf.math.ceil(len(train_images) / BATCH_SIZE).numpy())
VALID_STEP_PER_EPOCH = int(tf.math.ceil(len(valid_images) / BATCH_SIZE).numpy())
cost_fn = tf.keras.losses.CategoricalCrossentropy()
# optimizer = tf.keras.optimizers.Adam(learning_rate=lrfn)
optimizer = tf.keras.optimizers.Adam(learning_rate=0.00001)
inputs = tf.keras.Input(shape=(INPUT_SHAPE))
model = ResNet50()
model(inputs=inputs)
model.summary()
# tf.keras.utils.plot_model(model, show_shapes=True)
train_acc = tf | aug_img = tf.numpy_function(func=aug_fn, inp=[image], Tout=tf.float32)
return aug_img, label | identifier_body |
ResNet50_augmentation.py |
def get_dataset(ds_path):
ds_path = pathlib.Path(ds_path)
images = list(ds_path.glob('*/*.jpg'))
images = [str(path) for path in images]
total_images = len(images)
labels = sorted(item.name for item in ds_path.glob('*/') if item.is_dir())
classes = labels
labels = dict((name, index) for index, name in enumerate(labels))
labels = [labels[pathlib.Path(path).parent.name] for path in images]
labels = tf.keras.utils.to_categorical(labels, num_classes=len(classes), dtype='float32')
return images, labels, classes
def aug_fn(image):
data = {"image":image}
aug_data = transforms(**data)
aug_img = aug_data["image"]
aug_img = tf.cast(aug_img, tf.float32) / 255.0
aug_img = tf.image.per_image_standardization(aug_img)
# aug_img = tf.keras.applications.resnet.preprocess_input(aug_img)
return aug_img
def process_data(image, label):
aug_img = tf.numpy_function(func=aug_fn, inp=[image], Tout=tf.float32)
return aug_img, label
def make_tf_data(images, labels, augmentation):
images = tf.data.Dataset.from_tensor_slices(images)
images = images.map(preprocess_image, num_parallel_calls=AUTOTUNE)
labels = tf.data.Dataset.from_tensor_slices(labels)
dataset = tf.data.Dataset.zip((images, labels))
dataset = dataset.repeat()
if augmentation:
dataset = dataset.map(partial(process_data), num_parallel_calls=AUTOTUNE)
dataset = dataset.batch(BATCH_SIZE)
dataset = dataset.prefetch(AUTOTUNE)
return dataset
def residual_block(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
if conv_shortcut:
shortcut = tf.keras.layers.Conv2D(4 * filters, 1, strides=stride, name=name+'_0_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
shortcut = tf.keras.layers.BatchNormalization(axis=3, name=name+'_0_bn')(shortcut)
else:
shortcut = x
x = tf.keras.layers.Conv2D(filters, 1, strides=stride, name=name + '_1_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_1_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_1_relu')(x)
x = tf.keras.layers.Conv2D(filters, kernel_size, padding='SAME', name=name + '_2_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_2_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_2_relu')(x)
x = tf.keras.layers.Conv2D(4 * filters, 1, name=name + '_3_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_3_bn')(x)
x = tf.keras.layers.Add(name=name + '_add')([shortcut, x])
x = tf.keras.layers.Activation('relu', name=name + '_out')(x)
return x
def residual_stack(x, filters, blocks, stride1=2, name=None):
x = residual_block(x, filters, stride=stride1, name=name + '_block1')
for i in range(2, blocks + 1):
x = residual_block(x, filters, conv_shortcut=False, name=name + '_block' + str(i))
return x
def ResNet50():
inputs = tf.keras.layers.Input(shape=INPUT_SHAPE)
x = tf.keras.layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)
x = tf.keras.layers.Conv2D(64, 7, strides=2, use_bias=True, name='conv1_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name='conv1_bn')(x)
x = tf.keras.layers.Activation('relu', name='conv1_relu')(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = tf.keras.layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = residual_stack(x, 64, 3, stride1=1, name='conv2')
x = residual_stack(x, 128, 4, name='conv3')
x = residual_stack(x, 256, 6, name='conv4')
x = residual_stack(x, 512, 3, name='conv5')
x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)
outputs = tf.keras.layers.Dense(n_classes, activation='softmax', name='predictions')(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
return model
@tf.function
def train(model, images, labels):
with tf.GradientTape() as tape:
y_pred = model(images, training=True)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(grads_and_vars=zip(grads, model.trainable_variables))
train_acc.update_state(labels, y_pred)
train_loss.update_state(labels, y_pred)
@tf.function
def validation(model, images, labels):
y_pred = model(images, training=False)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
val_acc.update_state(labels, y_pred)
val_loss.update_state(labels, y_pred)
def | ():
if epoch < LR_RAMPUP_EPOCHS:
lr = (LR_MAX - LR_START) / LR_RAMPUP_EPOCHS * epoch + LR_START
elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:
lr = LR_MAX
else:
lr = (LR_MAX - LR_MIN) * LR_EXP_DECAY**(epoch - LR_RAMPUP_EPOCHS - LR_SUSTAIN_EPOCHS) + LR_MIN
return lr
def tf_data_visualize(augmentation_element, name):
row, col, idx = 5, 4, 0
row = min(row, BATCH_SIZE // col)
for (image, label) in augmentation_element:
print(image.shape, label.shape)
image = image / 255.0
plt.figure(figsize=(15, int(15 * row / col)))
for j in range(row * col):
plt.subplot(row, col, j + 1)
plt.axis('off')
plt.imshow(image[j, ])
# plt.savefig(f'{SAVED_PATH}/{LOG_TIME}/{name}_{idx}.jpg')
plt.show()
idx += 1
if idx == 3:
break
if __name__ == "__main__":
# hyper parameters
AUTOTUNE = tf.data.experimental.AUTOTUNE
IMG_SIZE = 224
INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)
BATCH_SIZE = 32
EPOCHS = 1000
# learning rate scheduler
LR_START = 0.001
LR_MAX = 0.005 * strategy.num_replicas_in_sync
LR_MIN = 0.001
LR_RAMPUP_EPOCHS = 5
LR_SUSTAIN_EPOCHS = 0
LR_EXP_DECAY = .8
# early stopping
PATIENCE = 3
EARLY_STOPPING = True
minimum_loss = float(2147000000)
total_images, total_labels, CLASSES = get_dataset('/home/v100/tf_workspace/datasets/natural_images/natural_images')
n_classes = len(CLASSES)
train_images, valid_images, train_labels, valid_labels = train_test_split(total_images, total_labels, test_size=.3, shuffle=True, random_state=777)
TRAIN_STEPS_PER_EPOCH = int(tf.math.ceil(len(train_images) / BATCH_SIZE).numpy())
VALID_STEP_PER_EPOCH = int(tf.math.ceil(len(valid_images) / BATCH_SIZE).numpy())
cost_fn = tf.keras.losses.CategoricalCrossentropy()
# optimizer = tf.keras.optimizers.Adam(learning_rate=lrfn)
optimizer = tf.keras.optimizers.Adam(learning_rate=0.00001)
inputs = tf.keras.Input(shape=(INPUT_SHAPE))
model = ResNet50()
model(inputs=inputs)
model.summary()
# tf.keras.utils.plot_model(model, show_shapes=True)
train_acc = | lrfn | identifier_name |
ResNet50_augmentation.py | =3, name=name + '_2_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_2_relu')(x)
x = tf.keras.layers.Conv2D(4 * filters, 1, name=name + '_3_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name=name + '_3_bn')(x)
x = tf.keras.layers.Add(name=name + '_add')([shortcut, x])
x = tf.keras.layers.Activation('relu', name=name + '_out')(x)
return x
def residual_stack(x, filters, blocks, stride1=2, name=None):
x = residual_block(x, filters, stride=stride1, name=name + '_block1')
for i in range(2, blocks + 1):
x = residual_block(x, filters, conv_shortcut=False, name=name + '_block' + str(i))
return x
def ResNet50():
inputs = tf.keras.layers.Input(shape=INPUT_SHAPE)
x = tf.keras.layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)
x = tf.keras.layers.Conv2D(64, 7, strides=2, use_bias=True, name='conv1_conv', kernel_initializer='he_uniform', bias_initializer='he_uniform', kernel_regularizer=tf.keras.regularizers.l2(0.0001))(x)
x = tf.keras.layers.BatchNormalization(axis=3, name='conv1_bn')(x)
x = tf.keras.layers.Activation('relu', name='conv1_relu')(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = tf.keras.layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = residual_stack(x, 64, 3, stride1=1, name='conv2')
x = residual_stack(x, 128, 4, name='conv3')
x = residual_stack(x, 256, 6, name='conv4')
x = residual_stack(x, 512, 3, name='conv5')
x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)
outputs = tf.keras.layers.Dense(n_classes, activation='softmax', name='predictions')(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
return model
@tf.function
def train(model, images, labels):
with tf.GradientTape() as tape:
y_pred = model(images, training=True)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(grads_and_vars=zip(grads, model.trainable_variables))
train_acc.update_state(labels, y_pred)
train_loss.update_state(labels, y_pred)
@tf.function
def validation(model, images, labels):
y_pred = model(images, training=False)
loss = tf.reduce_mean(cost_fn(labels, y_pred))
val_acc.update_state(labels, y_pred)
val_loss.update_state(labels, y_pred)
def lrfn():
if epoch < LR_RAMPUP_EPOCHS:
lr = (LR_MAX - LR_START) / LR_RAMPUP_EPOCHS * epoch + LR_START
elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:
lr = LR_MAX
else:
lr = (LR_MAX - LR_MIN) * LR_EXP_DECAY**(epoch - LR_RAMPUP_EPOCHS - LR_SUSTAIN_EPOCHS) + LR_MIN
return lr
def tf_data_visualize(augmentation_element, name):
row, col, idx = 5, 4, 0
row = min(row, BATCH_SIZE // col)
for (image, label) in augmentation_element:
print(image.shape, label.shape)
image = image / 255.0
plt.figure(figsize=(15, int(15 * row / col)))
for j in range(row * col):
plt.subplot(row, col, j + 1)
plt.axis('off')
plt.imshow(image[j, ])
# plt.savefig(f'{SAVED_PATH}/{LOG_TIME}/{name}_{idx}.jpg')
plt.show()
idx += 1
if idx == 3:
break
if __name__ == "__main__":
# hyper parameters
AUTOTUNE = tf.data.experimental.AUTOTUNE
IMG_SIZE = 224
INPUT_SHAPE = (IMG_SIZE, IMG_SIZE, 3)
BATCH_SIZE = 32
EPOCHS = 1000
# learning rate scheduler
LR_START = 0.001
LR_MAX = 0.005 * strategy.num_replicas_in_sync
LR_MIN = 0.001
LR_RAMPUP_EPOCHS = 5
LR_SUSTAIN_EPOCHS = 0
LR_EXP_DECAY = .8
# early stopping
PATIENCE = 3
EARLY_STOPPING = True
minimum_loss = float(2147000000)
total_images, total_labels, CLASSES = get_dataset('/home/v100/tf_workspace/datasets/natural_images/natural_images')
n_classes = len(CLASSES)
train_images, valid_images, train_labels, valid_labels = train_test_split(total_images, total_labels, test_size=.3, shuffle=True, random_state=777)
TRAIN_STEPS_PER_EPOCH = int(tf.math.ceil(len(train_images) / BATCH_SIZE).numpy())
VALID_STEP_PER_EPOCH = int(tf.math.ceil(len(valid_images) / BATCH_SIZE).numpy())
cost_fn = tf.keras.losses.CategoricalCrossentropy()
# optimizer = tf.keras.optimizers.Adam(learning_rate=lrfn)
optimizer = tf.keras.optimizers.Adam(learning_rate=0.00001)
inputs = tf.keras.Input(shape=(INPUT_SHAPE))
model = ResNet50()
model(inputs=inputs)
model.summary()
# tf.keras.utils.plot_model(model, show_shapes=True)
train_acc = tf.metrics.CategoricalAccuracy()
train_loss = tf.metrics.CategoricalCrossentropy()
val_acc = tf.metrics.CategoricalAccuracy()
val_loss = tf.metrics.CategoricalCrossentropy()
transforms = A.Compose([
# A.Resize(IMG_SIZE, IMG_SIZE, 3, p=1),
A.OneOf([
A.HorizontalFlip(p=0.6),
A.VerticalFlip(p=0.6),
], p=0.7),
# A.Cutout(num_holes=15, max_h_size=4, max_w_size=4, fill_value=[0, 0, 0], p=0.7),
A.OneOf([
A.RandomRotate90(p=0.6),
A.ShiftScaleRotate(p=0.6, border_mode=1)
], p=0.7),
# A.RandomBrightness(limit=0.1, p=0.5),
# A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.5),
# A.RandomContrast(limit=0.2, p=0.5),
])
# tf_data_visualize(make_tf_data(train_images, train_labels, True), 'train')
stateful_matrices = ['train_acc', 'train_loss', 'valid_acc', 'valid_loss']
print()
print('Learning started. It takes sometime.')
for epoch in range(EPOCHS):
print("Current Learning Rate : ", optimizer._decayed_lr('float32').numpy())
tf.print("Epoch {}/{}".format(epoch + 1, EPOCHS))
prog_bar = tf.keras.utils.Progbar(target=TRAIN_STEPS_PER_EPOCH, stateful_metrics=stateful_matrices)
train_acc.reset_states()
train_loss.reset_states()
val_acc.reset_states()
val_loss.reset_states()
for idx, (images, labels) in enumerate(make_tf_data(train_images, train_labels, True)):
train(model, images, labels)
values=[('train_loss', train_loss.result().numpy()), ('train_acc', train_acc.result().numpy())]
prog_bar.update(idx, values=values)
if idx+1 >= TRAIN_STEPS_PER_EPOCH:
break
for idx, (images, labels) in enumerate(make_tf_data(valid_images, valid_labels, True)):
validation(model, images, labels)
if idx+1 >= VALID_STEP_PER_EPOCH:
break
values = [('train_loss', train_loss.result().numpy()), ('train_acc', train_acc.result().numpy()), ('valid_loss', val_loss.result().numpy()), ('valid_acc', val_acc.result().numpy())]
prog_bar.update(TRAIN_STEPS_PER_EPOCH, values=values, finalize=True)
if EARLY_STOPPING:
tmp_loss = (val_loss.result().numpy())
if tmp_loss < minimum_loss:
minimum_loss = tmp_loss
PATIENCE = 3
else:
| PATIENCE -= 1
if PATIENCE == 0:
break | conditional_block |
|
sriov.go | {
return nil, "", fmt.Errorf("failed to load netconf: %v", err)
}
if n.VlanId < 0 || n.VlanId > 4094 {
return nil, "", fmt.Errorf(`invalid VLAN ID %d (must be between 0 and 4095 inclusive)`, n.VlanId)
}
return n, n.CNIVersion, nil
}
func | (conf *NetConf, ifName string, netns ns.NetNS) (*current.Interface, error) {
vf := ¤t.Interface{}
// 申请一个可用的Virtual Function
m, vfIdx, vfDevName, err := allocFreeVF()
if err != nil {
return nil, err
}
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV 成功申请%v网卡的第%v个VF, 名称为: %v\n", m.Attrs().Name, vfIdx, vfDevName)
vfDev, err := netlink.LinkByName(vfDevName)
if err != nil {
return nil, fmt.Errorf("failed to lookup vf device %q: %v", vfDevName, err)
}
if conf.MTU <= 0 {
conf.MTU = m.Attrs().MTU
}
if err = netlink.LinkSetVfHardwareAddr(m, vfIdx, vfDev.Attrs().HardwareAddr); err != nil {
return nil, fmt.Errorf("failed to set vf %d macaddress: %v", vfIdx, err)
}
if err = netlink.LinkSetVfVlan(m, vfIdx, conf.VlanId); err != nil {
return nil, fmt.Errorf("failed to set vf %d vlan: %v", vfIdx, err)
}
if err = netlink.LinkSetUp(vfDev); err != nil {
return nil, fmt.Errorf("failed to setup vf %d device: %v", vfIdx, err)
}
// move VF device to ns
if err = netlink.LinkSetNsFd(vfDev, int(netns.Fd())); err != nil {
return nil, fmt.Errorf("failed to move vf %d to netns: %v", vfIdx, err)
}
err = netns.Do(func(_ ns.NetNS) error {
err := ip.RenameLink(vfDevName, ifName)
if err != nil {
return fmt.Errorf("failed to rename vlan to %q: %v", ifName, err)
}
vf.Name = ifName
// Re-fetch interface to get all properties/attributes
contVF, err := netlink.LinkByName(vf.Name)
if err != nil {
return fmt.Errorf("failed to refetch vlan %q: %v", vf.Name, err)
}
vf.Mac = contVF.Attrs().HardwareAddr.String()
vf.Sandbox = netns.Path()
return nil
})
if err != nil {
return nil, err
}
return vf, nil
}
func allocFreeVF() (netlink.Link, int, string, error) {
vfIdx := -1
devName := ""
// 获取机器可用物理网卡(PF)列表
links, err := netlink.LinkList()
if err != nil {
return nil, -1, "", fmt.Errorf("获取可用物理网卡失败: %v", err)
}
for _, link := range links {
if link.Type() == "device" && link.Attrs().OperState == netlink.OperUp {
master := link.Attrs().Name
sriovFile := fmt.Sprintf("/sys/class/net/%s/device/sriov_numvfs", master)
if _, err := os.Lstat(sriovFile); err != nil {
return nil, -1, "", fmt.Errorf("failed to open the sriov_numfs of device %q: %v", master, err)
}
data, err := ioutil.ReadFile(sriovFile)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to read the sriov_numfs of device %q: %v", master, err)
}
if len(data) == 0 {
return nil, -1, "", fmt.Errorf("no data in the file %q", sriovFile)
}
sriovNumfs := strings.TrimSpace(string(data))
vfTotal, err := strconv.Atoi(sriovNumfs)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to convert sriov_numfs(byte value) to int of device %q: %v", master, err)
}
if vfTotal <= 0 {
return nil, -1, "", fmt.Errorf("no virtual function in the device %q: %v", master)
}
for vf := 0; vf < vfTotal; vf++ {
devName, err = getVFDeviceName(master, vf)
// got a free vf
if err == nil {
vfIdx = vf
break
}
}
if vfIdx == -1 {
return nil, -1, "", fmt.Errorf("can not get a free virtual function in directory %s", master)
}
return link, vfIdx, devName, nil
}
}
return nil, vfIdx, devName, fmt.Errorf("该主机无可用物理网卡")
}
func getVFDeviceName(master string, vf int) (string, error) {
vfDir := fmt.Sprintf("/sys/class/net/%s/device/virtfn%d/net", master, vf)
if _, err := os.Lstat(vfDir); err != nil {
return "", fmt.Errorf("failed to open the virtfn%d dir of the device %q: %v", vf, master, err)
}
infos, err := ioutil.ReadDir(vfDir)
if err != nil {
return "", fmt.Errorf("failed to read the virtfn%d dir of the device %q: %v", vf, master, err)
}
if len(infos) != 1 {
return "", fmt.Errorf("no network device in directory %s", vfDir)
}
return infos[0].Name(), nil
}
func releaseVF(conf *NetConf, ifName string, netns ns.NetNS) error {
initns, err := ns.GetCurrentNS()
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF initns = %v\n", initns)
if err != nil {
return fmt.Errorf("failed to get init netns: %v", err)
}
// for IPAM in cmdDel
return netns.Do(func(_ ns.NetNS) error {
// get VF device
vfDev, err := netlink.LinkByName(ifName)
if err != nil {
return fmt.Errorf("failed to lookup device %s: %v", ifName, err)
}
// device name in init netns
index := vfDev.Attrs().Index
devName := fmt.Sprintf("dev%d", index)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF index = %v devName = %v vfDev = %v\n", index, devName, vfDev)
// shutdown VF device
if err = netlink.LinkSetDown(vfDev); err != nil {
return fmt.Errorf("failed to down device: %v", err)
}
// rename VF device
err = ip.RenameLink(ifName, devName)
if err != nil {
return fmt.Errorf("failed to rename device %s to %s: %v", ifName, devName, err)
}
// move VF device to init netns
if err = netlink.LinkSetNsFd(vfDev, int(initns.Fd())); err != nil {
return fmt.Errorf("failed to move device %s to init netns: %v", ifName, err)
}
return nil
})
}
func cmdAdd(args *skel.CmdArgs) error {
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.ContainerID = %v\n", args.ContainerID)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Netns = %v\n", args.Netns)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.IfName = %v\n", args.IfName)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Args = %v\n", args.Args)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Path = %v\n", args.Path)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.StdinData = %v\n", string(args.StdinData))
n, cniVersion, err := loadConf(args.StdinData)
if err != nil {
return err
}
netns, err := ns.GetNS(args.Netns)
if err != nil {
return fmt.Errorf("failed to open netns %q: %v", args.Netns, err)
}
defer netns.Close()
vfInterface, err := setupVF(n, args.IfName, netns)
if err != nil {
return err
}
// run the IPAM plugin and get back the config to apply
r, err := ipam.ExecAdd(n.IPAM.Type, args.Stdin | setupVF | identifier_name |
sriov.go | ().Name, vfIdx, vfDevName)
vfDev, err := netlink.LinkByName(vfDevName)
if err != nil {
return nil, fmt.Errorf("failed to lookup vf device %q: %v", vfDevName, err)
}
if conf.MTU <= 0 {
conf.MTU = m.Attrs().MTU
}
if err = netlink.LinkSetVfHardwareAddr(m, vfIdx, vfDev.Attrs().HardwareAddr); err != nil {
return nil, fmt.Errorf("failed to set vf %d macaddress: %v", vfIdx, err)
}
if err = netlink.LinkSetVfVlan(m, vfIdx, conf.VlanId); err != nil {
return nil, fmt.Errorf("failed to set vf %d vlan: %v", vfIdx, err)
}
if err = netlink.LinkSetUp(vfDev); err != nil {
return nil, fmt.Errorf("failed to setup vf %d device: %v", vfIdx, err)
}
// move VF device to ns
if err = netlink.LinkSetNsFd(vfDev, int(netns.Fd())); err != nil {
return nil, fmt.Errorf("failed to move vf %d to netns: %v", vfIdx, err)
}
err = netns.Do(func(_ ns.NetNS) error {
err := ip.RenameLink(vfDevName, ifName)
if err != nil {
return fmt.Errorf("failed to rename vlan to %q: %v", ifName, err)
}
vf.Name = ifName
// Re-fetch interface to get all properties/attributes
contVF, err := netlink.LinkByName(vf.Name)
if err != nil {
return fmt.Errorf("failed to refetch vlan %q: %v", vf.Name, err)
}
vf.Mac = contVF.Attrs().HardwareAddr.String()
vf.Sandbox = netns.Path()
return nil
})
if err != nil {
return nil, err
}
return vf, nil
}
func allocFreeVF() (netlink.Link, int, string, error) {
vfIdx := -1
devName := ""
// 获取机器可用物理网卡(PF)列表
links, err := netlink.LinkList()
if err != nil {
return nil, -1, "", fmt.Errorf("获取可用物理网卡失败: %v", err)
}
for _, link := range links {
if link.Type() == "device" && link.Attrs().OperState == netlink.OperUp {
master := link.Attrs().Name
sriovFile := fmt.Sprintf("/sys/class/net/%s/device/sriov_numvfs", master)
if _, err := os.Lstat(sriovFile); err != nil {
return nil, -1, "", fmt.Errorf("failed to open the sriov_numfs of device %q: %v", master, err)
}
data, err := ioutil.ReadFile(sriovFile)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to read the sriov_numfs of device %q: %v", master, err)
}
if len(data) == 0 {
return nil, -1, "", fmt.Errorf("no data in the file %q", sriovFile)
}
sriovNumfs := strings.TrimSpace(string(data))
vfTotal, err := strconv.Atoi(sriovNumfs)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to convert sriov_numfs(byte value) to int of device %q: %v", master, err)
}
if vfTotal <= 0 {
return nil, -1, "", fmt.Errorf("no virtual function in the device %q: %v", master)
}
for vf := 0; vf < vfTotal; vf++ {
devName, err = getVFDeviceName(master, vf)
// got a free vf
if err == nil {
vfIdx = vf
break
}
}
if vfIdx == -1 {
return nil, -1, "", fmt.Errorf("can not get a free virtual function in directory %s", master)
}
return link, vfIdx, devName, nil
}
}
return nil, vfIdx, devName, fmt.Errorf("该主机无可用物理网卡")
}
func getVFDeviceName(master string, vf int) (string, error) {
vfDir := fmt.Sprintf("/sys/class/net/%s/device/virtfn%d/net", master, vf)
if _, err := os.Lstat(vfDir); err != nil {
return "", fmt.Errorf("failed to open the virtfn%d dir of the device %q: %v", vf, master, err)
}
infos, err := ioutil.ReadDir(vfDir)
if err != nil {
return "", fmt.Errorf("failed to read the virtfn%d dir of the device %q: %v", vf, master, err)
}
if len(infos) != 1 {
return "", fmt.Errorf("no network device in directory %s", vfDir)
}
return infos[0].Name(), nil
}
func releaseVF(conf *NetConf, ifName string, netns ns.NetNS) error {
initns, err := ns.GetCurrentNS()
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF initns = %v\n", initns)
if err != nil {
return fmt.Errorf("failed to get init netns: %v", err)
}
// for IPAM in cmdDel
return netns.Do(func(_ ns.NetNS) error {
// get VF device
vfDev, err := netlink.LinkByName(ifName)
if err != nil {
return fmt.Errorf("failed to lookup device %s: %v", ifName, err)
}
// device name in init netns
index := vfDev.Attrs().Index
devName := fmt.Sprintf("dev%d", index)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF index = %v devName = %v vfDev = %v\n", index, devName, vfDev)
// shutdown VF device
if err = netlink.LinkSetDown(vfDev); err != nil {
return fmt.Errorf("failed to down device: %v", err)
}
// rename VF device
err = ip.RenameLink(ifName, devName)
if err != nil {
return fmt.Errorf("failed to rename device %s to %s: %v", ifName, devName, err)
}
// move VF device to init netns
if err = netlink.LinkSetNsFd(vfDev, int(initns.Fd())); err != nil {
return fmt.Errorf("failed to move device %s to init netns: %v", ifName, err)
}
return nil
})
}
func cmdAdd(args *skel.CmdArgs) error {
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.ContainerID = %v\n", args.ContainerID)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Netns = %v\n", args.Netns)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.IfName = %v\n", args.IfName)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Args = %v\n", args.Args)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Path = %v\n", args.Path)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.StdinData = %v\n", string(args.StdinData))
n, cniVersion, err := loadConf(args.StdinData)
if err != nil {
return err
}
netns, err := ns.GetNS(args.Netns)
if err != nil {
return fmt.Errorf("failed to open netns %q: %v", args.Netns, err)
}
defer netns.Close()
vfInterface, err := setupVF(n, args.IfName, netns)
if err != nil {
return err
}
// run the IPAM plugin and get back the config to apply
r, err := ipam.ExecAdd(n.IPAM.Type, args.StdinData)
if err != nil {
return err
}
// Convert whatever the IPAM result was into the current Result type
result, err := current.NewResultFromResult(r)
if err != nil {
return err
}
if len(result.IPs) == 0 {
return errors.New("IPAM plugin returned missing IP config")
}
for _, ipc := range result.IPs {
// All addresses belong to the vlan interface
ipc.Interface = current.Int(0)
}
result.Interfaces = []*current.Interface{vfInterface}
err = netns.Do(func(_ ns.NetNS) error {
return ipam.ConfigureIface(args.IfName, result)
})
if err != nil {
return err
}
| result.DNS = n.DNS
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd result = %v\n", result)
return types.PrintResult(result, cniVersion) | random_line_split |
|
sriov.go | return nil, "", fmt.Errorf("failed to load netconf: %v", err)
}
if n.VlanId < 0 || n.VlanId > 4094 {
return nil, "", fmt.Errorf(`invalid VLAN ID %d (must be between 0 and 4095 inclusive)`, n.VlanId)
}
return n, n.CNIVersion, nil
}
func setupVF(conf *NetConf, ifName string, netns ns.NetNS) (*current.Interface, error) {
vf := ¤t.Interface{}
// 申请一个可用的Virtual Function
m, vfIdx, vfDevName, err := allocFreeVF()
if err != nil {
return nil, err
}
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV 成功申请%v网卡的第%v个VF, 名称为: %v\n", m.Attrs().Name, vfIdx, vfDevName)
vfDev, err := netlink.LinkByName(vfDevName)
if err != nil {
return nil, fmt.Errorf("failed to lookup vf device %q: %v", vfDevName, err)
}
if conf.MTU <= 0 {
conf.MTU = m.Attrs().MTU
}
if err = netlink.LinkSetVfHardwareAddr(m, vfIdx, vfDev.Attrs().HardwareAddr); err != nil {
return nil, fmt.Errorf("failed to set vf %d macaddress: %v", vfIdx, err)
}
if err = netlink.LinkSetVfVlan(m, vfIdx, conf.VlanId); err != nil {
return nil, fmt.Errorf("failed to set vf %d vlan: %v", vfIdx, err)
}
if err = netlink.LinkSetUp(vfDev); err != nil {
return nil, fmt.Errorf("failed to setup vf %d device: %v", vfIdx, err)
}
// move VF device to ns
if err = netlink.LinkSetNsFd(vfDev, int(netns.Fd())); err != nil {
return nil, fmt.Errorf("failed to move vf %d to netns: %v", vfIdx, err)
}
err = netns.Do(func(_ ns.NetNS) error {
err := ip.RenameLink(vfDevName, ifName)
if err != nil {
return fmt.Errorf("failed to rename vlan to %q: %v", ifName, err)
}
vf.Name = ifName
// Re-fetch interface to get all properties/attributes
contVF, err := netlink.LinkByName(vf.Name)
if err != nil {
return fmt.Errorf("failed to refetch vlan %q: %v", vf.Name, err)
}
vf.Mac = contVF.Attrs().HardwareAddr.String()
vf.Sandbox = netns.Path()
return nil
})
if err != nil {
return nil, err
}
return vf, nil
}
func allocFreeVF() (netlink.Link, int, string, error) {
vfIdx := -1
devName := ""
// 获取机器可用物理网卡(PF)列表
links, err := netlink.LinkList()
if err != nil {
return nil, -1, "", fmt.Errorf("获取可用物理网卡失败: %v", err)
}
for _, link := range links {
if link.Type() == "device" && link.Attrs().OperState == netlink.OperUp {
master := link.Attrs().Name
sriovFile := fmt.Sprintf("/sys/class/net/%s/device/sriov_numvfs", master)
if _, err := os.Lstat(sriovFile); err != nil {
return nil, -1, "", fmt.Errorf("failed to open the sriov_numfs of device %q: %v", master, err)
}
data, err := ioutil.ReadFile(sriovFile)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to read the sriov_numfs of device %q: %v", master, err)
}
if len(data) == 0 {
return nil, -1, "", fmt.Errorf("no data in the file %q", sriovFile)
}
sriovNumfs := strings.TrimSpace(string(data))
vfTotal, err := strconv.Atoi(sriovNumfs)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to convert sriov_numfs(byte value) to int of device %q: %v", master, err)
}
if vfTotal <= 0 {
return nil, -1, "", fmt.Errorf("no virtual function in the device %q: %v", master)
}
for vf := 0; vf < vfTotal; vf++ {
devName, err = getVFDeviceName(master, vf)
// got a free vf
if err == nil {
vfIdx = vf
break
}
}
if vfIdx == -1 {
return nil, -1, "", fmt.Errorf("can not get a free virtual function in directory %s", master)
}
return link, vfIdx, devName, nil
}
}
return nil, vfIdx, devName, fmt.Errorf("该主机无可用物理网卡")
}
func getVFDeviceName(master string, vf int) (string, error) {
vfDir := fmt.Sprintf("/sys/class/net/%s/device/virtfn%d/net", master, vf)
if _, err := os.Lstat(vfDir); err != nil {
return "", fmt.Errorf("failed to open the virtfn%d dir of the device %q: %v", vf, master, err)
}
infos, err := ioutil.ReadDir(vfDir)
if err != nil {
return "", fmt.Errorf("failed to read the virtfn%d dir of the device %q: %v", vf, master, err)
}
if len(infos) != 1 {
return "", fmt.Errorf("no network device in directory %s", vfDir)
}
return infos[0].Name(), nil
}
func releaseVF(conf *NetConf, ifName string, netns ns.NetNS) error {
initns, err := ns.GetCurrentNS()
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF initns = %v\n", initns)
if err != nil {
return fmt.Errorf("failed to get init netns: %v", err)
}
// for IPAM in cmdDel
return netns.Do(func(_ ns.NetNS) error {
// get VF device
vfDev, err := netlink.LinkByName(ifName)
if err != nil {
return fmt.Errorf("failed to lookup device %s: %v", ifName, err)
}
// device name in init netns
index := vfDev.Attrs().Index
devName := fmt.Sprintf("dev%d", index)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF index = %v devName = %v vfDev = %v\n", index, devName, vfDev)
// shutdown VF device
if err = netlink.LinkSetDown(vfDev); err != nil {
return fmt.Errorf("failed to down device: %v", err)
}
// rename VF device
err = ip.RenameLink(ifName, devName)
if err != nil {
return fmt.Errorf("failed to rename device %s to %s: %v", ifName, devName, err)
}
// move VF device to init netns
if err = netlink.LinkSetNsFd(vfDev, int(initns.Fd())); err != nil {
return fmt.Errorf("failed to move device %s to init netns: %v", ifName, err)
}
return nil
})
}
func cmdAdd(args *skel.CmdArgs) error {
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.ContainerID = %v\n", args.ContainerID)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Netns = %v\n", args.Netns)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.IfName = %v\n", args.IfName)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Args = %v\n", args.Args)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Path = %v\n", args.Path)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.StdinData = %v\n", string(args.StdinData))
n, cniVersion, err := loadConf(args.StdinData)
if err != nil {
return err
}
netns, err := ns.GetNS(args.Netns)
if err != nil {
return fmt.Errorf("failed to open netns %q: %v", args.Netns, err)
}
defer netns.Close()
vfInterface, err := setupVF(n, args.IfName, netns)
if err != nil {
return err
}
// run the IPAM plugin and get back the config to apply
r, err := ipam.ExecAdd(n. | tdin | IPAM.Type, args.S | conditional_block |
sriov.go | {
return nil, "", fmt.Errorf("failed to load netconf: %v", err)
}
if n.VlanId < 0 || n.VlanId > 4094 {
return nil, "", fmt.Errorf(`invalid VLAN ID %d (must be between 0 and 4095 inclusive)`, n.VlanId)
}
return n, n.CNIVersion, nil
}
func setupVF(conf *NetConf, ifName string, netns ns.NetNS) (*current.Interface, error) {
vf := ¤t.Interface{}
// 申请一个可用的Virtual Function
m, vfIdx, vfDevName, err := allocFreeVF()
if err != nil {
return nil, err
}
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV 成功申请%v网卡的第%v个VF, 名称为: %v\n", m.Attrs().Name, vfIdx, vfDevName)
vfDev, err := netlink.LinkByName(vfDevName)
if err != nil {
return nil, fmt.Errorf("failed to lookup vf device %q: %v", vfDevName, err)
}
if conf.MTU <= 0 {
conf.MTU = m.Attrs().MTU
}
if err = netlink.LinkSetVfHardwareAddr(m, vfIdx, vfDev.Attrs().HardwareAddr); err != nil {
return nil, fmt.Errorf("failed to set vf %d macaddress: %v", vfIdx, err)
}
if err = netlink.LinkSetVfVlan(m, vfIdx, conf.VlanId); err != nil {
return nil, fmt.Errorf("failed to set vf %d vlan: %v", vfIdx, err)
}
if err = netlink.LinkSetUp(vfDev); err != nil {
return nil, fmt.Errorf("failed to setup vf %d device: %v", vfIdx, err)
}
// move VF device to ns
if err = netlink.LinkSetNsFd(vfDev, int(netns.Fd())); err != nil {
return nil, fmt.Errorf("failed to move vf %d to netns: %v", vfIdx, err)
}
err = netns.Do(func(_ ns.NetNS) error {
err := ip.RenameLink(vfDevName, ifName)
if err != nil {
return fmt.Errorf("failed to rename vlan to %q: %v", ifName, err)
}
vf.Name = ifName
// Re-fetch interface to get all properties/attributes
contVF, err := netlink.LinkByName(vf.Name)
if err != nil {
return fmt.Errorf("failed to refetch vlan %q: %v", vf.Name, err)
}
vf.Mac = contVF.Attrs().HardwareAddr.String()
vf.Sandbox = netns.Path()
return nil
})
if err != nil {
return nil, err
}
return vf, nil
}
func allocFreeVF() (netlink.Link, int, string, error) {
vfIdx := -1
devName := ""
// 获取机器可用物理网卡(PF)列表
links, err := netlink.LinkList()
if err != nil {
return nil, -1, "", fmt.Errorf("获取可用物理网卡失败: %v", err)
}
for _, link := range links {
if link.Type() == "device" && link.Attrs().OperState == netlink.OperUp {
master := link.Attrs().Name
sriovFile := fmt.Sprintf("/sys/class/net/%s/device/sriov_numvfs", master)
if _, err := os.Lstat(sriovFile); err != nil {
return nil, -1, "", fmt.Errorf("failed to open the sriov_numfs of device %q: %v", master, err)
}
data, err := ioutil.ReadFile(sriovFile)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to read the sriov_numfs of device %q: %v", master, err)
}
if len(data) == 0 {
return nil, -1, "", fmt.Errorf("no data in the file %q", sriovFile)
}
sriovNumfs := strings.TrimSpace(string(data))
vfTotal, err := strconv.Atoi(sriovNumfs)
if err != nil {
return nil, -1, "", fmt.Errorf("failed to convert sriov_numfs(byte value) to int of device %q: %v", master, err)
}
if vfTotal <= 0 {
return nil, -1, "", fmt.Errorf("no virtual function in the device %q: %v", master)
}
for vf := 0; vf < vfTotal; vf++ {
devName, err = getVFDeviceName(master, vf)
// got a free vf
if err == nil {
vfIdx = vf
break
}
}
if vfIdx == -1 {
return nil, -1, "", fmt.Errorf("can not get a free virtual function in directory %s", master)
}
return link, vfIdx, devName, nil
}
}
return nil, vfIdx, devName, fmt.Errorf("该主机无可用物理网卡")
}
func getVFDeviceName(master string, vf int) (string, error) {
vfDir := fmt.Sprintf("/sys/class/net/%s/device/virtfn%d/net", master, vf)
if _, err := os.Lstat(vf | ()
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF initns = %v\n", initns)
if err != nil {
return fmt.Errorf("failed to get init netns: %v", err)
}
// for IPAM in cmdDel
return netns.Do(func(_ ns.NetNS) error {
// get VF device
vfDev, err := netlink.LinkByName(ifName)
if err != nil {
return fmt.Errorf("failed to lookup device %s: %v", ifName, err)
}
// device name in init netns
index := vfDev.Attrs().Index
devName := fmt.Sprintf("dev%d", index)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV releaseVF index = %v devName = %v vfDev = %v\n", index, devName, vfDev)
// shutdown VF device
if err = netlink.LinkSetDown(vfDev); err != nil {
return fmt.Errorf("failed to down device: %v", err)
}
// rename VF device
err = ip.RenameLink(ifName, devName)
if err != nil {
return fmt.Errorf("failed to rename device %s to %s: %v", ifName, devName, err)
}
// move VF device to init netns
if err = netlink.LinkSetNsFd(vfDev, int(initns.Fd())); err != nil {
return fmt.Errorf("failed to move device %s to init netns: %v", ifName, err)
}
return nil
})
}
func cmdAdd(args *skel.CmdArgs) error {
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.ContainerID = %v\n", args.ContainerID)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Netns = %v\n", args.Netns)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.IfName = %v\n", args.IfName)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Args = %v\n", args.Args)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.Path = %v\n", args.Path)
fmt.Fprintf(os.Stderr, "***********CNI SR-IOV cmdAdd args.StdinData = %v\n", string(args.StdinData))
n, cniVersion, err := loadConf(args.StdinData)
if err != nil {
return err
}
netns, err := ns.GetNS(args.Netns)
if err != nil {
return fmt.Errorf("failed to open netns %q: %v", args.Netns, err)
}
defer netns.Close()
vfInterface, err := setupVF(n, args.IfName, netns)
if err != nil {
return err
}
// run the IPAM plugin and get back the config to apply
r, err := ipam.ExecAdd(n.IPAM.Type, args.StdinData | Dir); err != nil {
return "", fmt.Errorf("failed to open the virtfn%d dir of the device %q: %v", vf, master, err)
}
infos, err := ioutil.ReadDir(vfDir)
if err != nil {
return "", fmt.Errorf("failed to read the virtfn%d dir of the device %q: %v", vf, master, err)
}
if len(infos) != 1 {
return "", fmt.Errorf("no network device in directory %s", vfDir)
}
return infos[0].Name(), nil
}
func releaseVF(conf *NetConf, ifName string, netns ns.NetNS) error {
initns, err := ns.GetCurrentNS | identifier_body |
ngx-grid-table.component.ts | End();
this.api.showLoadingOverlay();
this.setDataLoading(true);
this.dataSource(rowQuery)
.pipe(
takeUntil(this.destroy$),
catchError((err) => {
Console.collapse('grid-table.component RefreshRowsData', 'redBg', 'ERROR', 'redOutline');
console.log(err);
console.groupEnd();
return of({
total: 0,
records: [],
size: rowQuery.pageSize,
current: rowQuery.pageNum,
statistics: [],
} as IPage<any>);
}),
)
.subscribe((resultPage) => {
this.cur_page = resultPage;
this.api.setRowData(resultPage.records);
this.statistics = resultPage.statistics || [];
if (!resultPage.records.length) {
this.api.showNoRowsOverlay();
} else {
this.api.hideOverlay();
}
this.setDataLoading(false);
});
}
onPageSizeChange(size: number): void {
this.setPageSize(size, true);
this.query(1, size);
}
onPageIndexChange(idx: number): void {
this.setPageIndex(idx, true);
this.query(idx, this.pageSize);
}
/**
*
* @param maxRequestCount 最大并发查询数
* @param pageSize 每次查询条数，默认采用当前分页大小
*/
exportAllPageData(maxRequestCount: number = 3, pageSize?: number): void {
const initPageNum = 1;
pageSize = pageSize || this.pageSize;
if (this.dataLoadModel !== 'pageable') {
// 暂时只支持客户端模式导出全部数据，因为服务端模式下由于缓存大小问题setRowData方法无效
console.warn('pageable 模式才能前端导出！');
// 导出当前缓存的数据
this.api.exportDataAsExcel({ customFooter: this.exportStatisticsFooter() });
return;
}
const rowQuery: IRowQuery = clientSideAsRowQuery(this.api, this.columnApi, initPageNum, pageSize, this.filters());
const params = { percent: 0, status: 'active' };
const confirm = this.modal.confirm({
nzContent: this.progressTmpl,
nzTitle: this.translateService.instant('grid.export.confirm'),
nzComponentParams: params,
nzOkText: this.translateService.instant('grid.export.start'),
nzOnOk: () => {
params.percent = 0.01;
params.status = 'active';
confirm.updateConfig({
nzTitle: undefined,
nzContent: this.progressTmpl,
nzComponentParams: params,
nzOkText: null,
nzClosable: false,
nzCloseIcon: undefined,
nzIconType: undefined,
nzMaskClosable: false,
nzCancelText: null,
});
let statisticsFooter: Array<GridStatistics> = [];
return this.dataSource(rowQuery)
.pipe(
mergeMap((page: IPage<any>) => {
const { total, size, current, records, statistics } = page;
statisticsFooter = statistics || [];
const totalPage = Math.ceil(total / size);
if (totalPage > current) {
const step = parseFloat((100 / totalPage).toFixed(2));
params.percent = step;
return range(current + 1, totalPage).pipe(
mergeMap((index: number) => {
return this.dataSource(Object.assign({}, rowQuery, { pageNum: index }));
}, maxRequestCount),
pluck('records'),
tap((next) => {
params.percent = parseFloat((params.percent + step).toFixed(2));
}),
reduce((acc, val) => acc.concat(val || []), records),
);
} else {
return of([]);
}
}),
)
.toPromise()
.then((next) => {
params.status = '';
params.percent = 100;
this.api.setRowData(next);
this.api.exportDataAsExcel({ customFooter: this.exportStatisticsFooter(statisticsFooter) });
this.refresh();
return true;
})
.catch((err) => {
Console.collapse('grid-table.component ExportAllPageData', 'redBg', 'ERROR', 'redOutline');
console.error(err);
console.groupEnd();
params.status = 'exception';
confirm.updateConfig({
nzCancelText: undefined,
nzOkText: this.translateService.instant('grid.export.retry'),
});
return false;
});
},
});
}
private exportStatisticsFooter(statistics?: Array<GridStatistics>): ExcelCell[][] {
const footers: Array<Array<ExcelCell>> = [[]];
statistics = statistics || this.statistics;
if (this.showStatistics && statistics && statistics.length) {
const footer = statistics
.filter((items) => items.skipExport !== true)
.map((items) => {
const rows: Array<ExcelCell> = [];
rows.push({
styleId: 'bigHeader',
data: {
type: 'String',
value: items.label || '',
},
});
items.fields.forEach((item) => {
rows.push({
styleId: 'bigHeader',
data: {
type: 'String',
value: `${item.label}:${item.value}`,
},
} as ExcelCell);
});
return rows;
});
footers.push(...footer);
}
return footers;
}
ngOnDestroy(): void {
this.destroy$.next();
this.destroy$.complete();
}
public setData(data: IPage<any>): void {
if (this.dataLoadModel === 'pageable') {
this.cur_page = data;
this.setPageIndex(this.cur_page.current, false);
this.setPageSize(this.cur_page.size, false);
this.api.setRowData(this.cur_page.records);
} else {
console.warn('只有 tableModel === ‘pageable’ 才允许直接存值');
}
}
// 添加菜单
public addMenu(item: MenuItem): void {
this.additionMenu.push(item);
}
/**
* 刷新表格
*/
public refresh(): Observable<void> {
if (this.dataLoadModel === 'pageable') {
this.query(this.pageIndex, this.pageSize);
} else {
this.api.purgeServerSideCache();
}
// 当loading状态变更为false的时候，可以视为本次数据加载已经完成，返回这个Observable，供其他业务订阅
return this.dataLoadingChange.asObservable().pipe(
filter((status) => !status),
take(1),
map(() => {}),
);
}
/**
* 获取所有范围选中（range）的行数据
*/
public getSelectionData<U>(): U[] {
return this.getSelection((s) => s.data);
}
/**
* 获取所有范围选中（range）的行，并对其进行转换
*/
public getSelection<U>(hand: (value: RowNode) => U): U[] {
const range: CellRange = this.api.getCellRanges()[0];
const nodes: RowNode[] = this.api.getRenderedNodes();
if (range && range.startRow && range.endRow) {
const r = [];
for (let i = range.startRow.rowIndex; i <= range.endRow.rowIndex; i++) {
r.push(hand(nodes[i]));
}
return r;
} else {
return [];
}
}
/**
* 获取所有checkbox选择的行数据
*/
public getCheckedData<U>(): U[] {
return this.getChecked((s) => s.data);
}
/**
* 获取所有checkbox选择的行，并对其进行转换
*/
public getChecked<U>(hand: (value: RowNode) => U): U[] {
const nodes: RowNode[] = this.api.getSelectedNodes();
return nodes.map(hand);
}
/**
* 重置表单
*/
resetForm(): void {
this.form.reset();
}
get pageViewTmpl(): TemplateRef<any> {
return this.customPageView ? this.customPageView : this.defaultPageTmpl;
}
// ================================== 数据绑定 ====================================
toggleFullscreen(): void {
this.setFullscreen(!this.fullscreen);
}
setFullscreen(fullscreen: boolean): void {
this.fullscreen = fullscreen;
this.fullscreenChange.emit(this.fullscreen);
}
setPageIndex(pageIndex: number, emit: boolean): void {
this.pageIndex = pageIndex;
if (emit) {
this.pageIndexChange.emit(pageIndex);
}
}
setPageSize(pageSize: number, emit: boolean): void {
this.pageSize = pageSize;
if (emit) {
this.pageSizeChange.emit(pageSize);
}
}
private setDataLoading(loading: boolean): void {
this.dataLoading = loading;
this.dataLoadingChange.emit(this.dataLoading);
}
toggleDataModel(): void {
if ('pageable' === this.dataLoadModel) {
this.setDataMode('infinite');
} else {
this.setDataMode('pageable');
}
}
setDataMode(model: 'pageable' | 'infinite'): void {
this.dataLoadModel = model;
repairRowModeType(this.gridOptions, this.dataLoadModel);
// TODO 刷新表格
this.repaint();
this.dataLoadModelChange.emit(this.dataLoadModel);
}
repaint(): void {
this.__show__ = false;
setTimeout(() => (this.__show__ = true), 200);
}
}
| conditional_block |
||
ngx-grid-table.component.ts | (this.showPagination !== false) {
this.showPagination = {
...NgxGridTableConstants.DEFAULT_PAGINATION,
...this.showPagination,
};
}
this.gridOptions = initGridOptions(this.gridOptions, this.rowSelection!, (event) => this.onGridReady(event));
}
private onGridReady(event: GridReadyEvent): void {
this.api = event.api;
this.columnApi = event.columnApi;
if (this.dataLoadModel === 'infinite') {
this.api.setServerSideDatasource(this.infiniteDataSource());
}
if (this.haveInit) {
this.gridReLoadReady.emit({ event, gridTable: this });
} else {
this.gridReady.emit({ event, gridTable: this });
this.haveInit = true;
}
// 当网格数据就绪时
// this.api.addEventListener('firstDataRendered', () => {
// this.firstDataRenderedTime = new Date().getTime();
// if (cellActionColumnDefs.length) {
// this.columnApi.autoSizeColumn('_action');
// }
// });
if (this.initLoadData) {
this.refresh();
}
}
private filters(): IFilter[] {
let filters = [] as IFilter[];
if (this.form) {
filters = [...this.form.filter];
}
if (this.filterHand) {
filters = [...this.filterHand(filters, this.form)];
}
return filters;
}
private infiniteDataSource(): IServerSideDatasource {
const getRows = (params: IServerSideGetRowsParams) => {
const rowQuery = serverSideAsRowQuery(params, this.treeData, this.filters());
Console.collapse('grid-table.component getData', 'indigoBg', 'queryParams', 'indigoOutline');
console.log(rowQuery);
console.groupEnd();
this.setDataLoading(true);
this.api.showLoadingOverlay();
this.dataSource(rowQuery)
.pipe(
takeUntil(this.destroy$),
catchError((err) => {
Console.collapse('grid-table.component RefreshRowsData', 'redBg', 'ERROR', 'redOutline');
console.error(err);
console.groupEnd();
return of({} as IPage<any>);
}),
)
.subscribe((resultPage) => {
if (resultPage.records) {
params.successCallback(resultPage.records, resultPage.total);
this.statistics = resultPage.statistics || [];
this.api.hideOverlay();
} else {
this.api.showNoRowsOverlay();
params.failCallback();
}
this.setDataLoading(false);
});
};
return { getRows };
}
// private doDelete(): void {
// const data: any[] = this.getCheckedData();
// if (!data.length) {
// return;
// }
// let mapper: (v: any) => string;
// if (typeof this.gridOptions.getRowNodeId === 'undefined') {
// if (typeof data[0].id !== 'undefined') {
// mapper = (v) => v.id;
// } else {
// console.warn(
// '删除操作无法获取键，默认情况下将获取id作为键，如果没有id字段或不希望使用id作为删除键，请配置 gridOptions.getRowNodeId',
// );
// return;
// }
// } else {
// mapper = this.gridOptions.getRowNodeId;
// }
//
// const ids: string[] = data.map(mapper);
//
// this.http.delete(`/api/${this.currentUrl}/deleteByKeys`, { keys: ids }).subscribe((value) => {
// this.deleted.emit(value);
// });
// }
/**
* 查询
*/
query(pageNum: number, pageSize: number): void {
this.api.clearRangeSelection();
this.api.deselectAll();
if (this.dataLoadModel !== 'pageable') {
console.warn('pageable 模式才能进行分页查询');
return;
}
const rowQuery: IRowQuery = clientSideAsRowQuery(this.api, this.columnApi, pageNum, pageSize, this.filters());
Console.collapse('grid-table.component getData', 'indigoBg', 'queryParams', 'indigoOutline');
console.log(rowQuery);
console.groupEnd();
this.api.showLoadingOverlay();
this.setDataLoading(true);
this.dataSource(rowQuery)
.pipe(
takeUntil(this.destroy$),
catchError((err) => {
Console.collapse('grid-table.component RefreshRowsData', 'redBg', 'ERROR', 'redOutline');
console.log(err);
console.groupEnd();
return of({
total: 0,
records: [],
size: rowQuery.pageSize,
current: rowQuery.pageNum,
statistics: [],
} as IPage<any>);
}),
)
.subscribe((resultPage) => {
this.cur_page = resultPage;
this.api.setRowData(resultPage.records);
this.statistics = resultPage.statistics || [];
if (!resultPage.records.length) {
this.api.showNoRowsOverlay();
} else {
this.api.hideOverlay();
}
this.setDataLoading(false);
});
}
onPageSizeChange(size: number): void {
this.setPageSize(size, true);
this.query(1, size);
}
onPageIndexChange(idx: number): void {
this.setPageIndex(idx, true);
this.query(idx, this.pageSize);
}
/**
*
* @param maxRequestCount 最大并发查询数
* @param pageSize 每次查询条数，默认采用当前分页大小
*/
exportAllPageData(maxRequestCount: number = 3, pageSize?: number): void {
const initPageNum = 1;
pageSize = pageSize || this.pageSize;
if (this.dataLoadModel !== 'pageable') {
// 暂时只支持客户端模式导出全部数据，因为服务端模式下由于缓存大小问题setRowData方法无效
console.warn('pageable 模式才能前端导出！');
// 导出当前缓存的数据
this.api.exportDataAsExcel({ customFooter: this.exportStatisticsFooter() });
return;
}
const rowQuery: IRowQuery = clientSideAsRowQuery(this.api, this.columnApi, initPageNum, pageSize, this.filters());
const params = { percent: 0, status: 'active' };
const confirm = this.modal.confirm({
nzContent: this.progressTmpl,
nzTitle: this.translateService.instant('grid.export.confirm'),
nzComponentParams: params,
nzOkText: this.translateService.instant('grid.export.start'),
nzOnOk: () => {
params.percent = 0.01;
params.status = 'active';
confirm.updateConfig({
nzTitle: undefined,
nzContent: this.progressTmpl,
nzComponentParams: params,
nzOkText: null,
nzClosable: false,
nzCloseIcon: undefined,
nzIconType: undefined,
nzMaskClosable: false,
nzCancelText: null,
});
let statisticsFooter: Array<GridStatistics> = [];
return this.dataSource(rowQuery)
.pipe(
mergeMap((page: IPage<any>) => {
const { total, size, current, records, statistics } = page;
statisticsFooter = statistics || [];
const totalPage = Math.ceil(total / size);
if (totalPage > current) {
const step = parseFloat((100 / totalPage).toFixed(2));
params.percent = step;
return range(current + 1, totalPage).pipe(
mergeMap((index: number) => {
return this.dataSource(Object.assign({}, rowQuery, { pageNum: index }));
}, maxRequestCount),
pluck('records'),
tap((next) => {
params.percent = parseFloat((params.percent + step).toFixed(2));
}),
reduce((acc, val) => acc.concat(val || []), records),
);
} else {
return of([]);
}
}),
)
.toPromise()
.then((next) => {
params.status = '';
params.percent = 100;
this.api.setRowData(next);
this.api.exportDataAsExcel({ customFooter: this.exportStatisticsFooter(statisticsFooter) });
this.refresh();
return true;
})
.catch((err) => {
Console.collapse('grid-table.component ExportAllPageData', 'redBg', 'ERROR', 'redOutline');
console.error(err);
console.groupEnd();
params.status = 'exception';
confirm.updateConfig({
nzCancelText: undefined,
nzOkText: this.translateService.instant('grid.export.retry'),
});
return false;
});
},
});
}
private exportStatisticsFooter(statistics?: Array<GridStatistics>): ExcelCell[][] {
const footers: Array<Array<ExcelCell>> = [[]];
statistics = statistics || this.statistics;
if (this.showStatistics && statistics && statistics.length) {
const footer = statistics
.filter((items) => items.skipExport !== true)
.map((items) => {
const rows: Array<ExcelCell> = [];
rows.push({
styleId: 'bigHeader',
data: {
type: 'String',
value: items.label || '',
},
});
items.fields.forEach((item) => {
rows.push({
styleId: 'bigHeader', | data: { | random_line_split |
|
ngx-grid-table.component.ts | `, { keys: ids }).subscribe((value) => {
// this.deleted.emit(value);
// });
// }
/**
* 查询
*/
query(pageNum: number, pageSize: number): void {
this.api.clearRangeSelection();
this.api.deselectAll();
if (this.dataLoadModel !== 'pageable') {
console.warn('pageable 模式才能进行分页查询');
return;
}
const rowQuery: IRowQuery = clientSideAsRowQuery(this.api, this.columnApi, pageNum, pageSize, this.filters());
Console.collapse('grid-table.component getData', 'indigoBg', 'queryParams', 'indigoOutline');
console.log(rowQuery);
console.groupEnd();
this.api.showLoadingOverlay();
this.setDataLoading(true);
this.dataSource(rowQuery)
.pipe(
takeUntil(this.destroy$),
catchError((err) => {
Console.collapse('grid-table.component RefreshRowsData', 'redBg', 'ERROR', 'redOutline');
console.log(err);
console.groupEnd();
return of({
total: 0,
records: [],
size: rowQuery.pageSize,
current: rowQuery.pageNum,
statistics: [],
} as IPage<any>);
}),
)
.subscribe((resultPage) => {
this.cur_page = resultPage;
this.api.setRowData(resultPage.records);
this.statistics = resultPage.statistics || [];
if (!resultPage.records.length) {
this.api.showNoRowsOverlay();
} else {
this.api.hideOverlay();
}
this.setDataLoading(false);
});
}
onPageSizeChange(size: number): void {
this.setPageSize(size, true);
this.query(1, size);
}
onPageIndexChange(idx: number): void {
this.setPageIndex(idx, true);
this.query(idx, this.pageSize);
}
/**
*
* @param maxRequestCount 最大并发查询数
* @param pageSize 每次查询条数，默认采用当前分页大小
*/
exportAllPageData(maxRequestCount: number = 3, pageSize?: number): void {
const initPageNum = 1;
pageSize = pageSize || this.pageSize;
if (this.dataLoadModel !== 'pageable') {
// 暂时只支持客户端模式导出全部数据，因为服务端模式下由于缓存大小问题setRowData方法无效
console.warn('pageable 模式才能前端导出！');
// 导出当前缓存的数据
this.api.exportDataAsExcel({ customFooter: this.exportStatisticsFooter() });
return;
}
const rowQuery: IRowQuery = clientSideAsRowQuery(this.api, this.columnApi, initPageNum, pageSize, this.filters());
const params = { percent: 0, status: 'active' };
const confirm = this.modal.confirm({
nzContent: this.progressTmpl,
nzTitle: this.translateService.instant('grid.export.confirm'),
nzComponentParams: params,
nzOkText: this.translateService.instant('grid.export.start'),
nzOnOk: () => {
params.percent = 0.01;
params.status = 'active';
confirm.updateConfig({
nzTitle: undefined,
nzContent: this.progressTmpl,
nzComponentParams: params,
nzOkText: null,
nzClosable: false,
nzCloseIcon: undefined,
nzIconType: undefined,
nzMaskClosable: false,
nzCancelText: null,
});
let statisticsFooter: Array<GridStatistics> = [];
return this.dataSource(rowQuery)
.pipe(
mergeMap((page: IPage<any>) => {
const { total, size, current, records, statistics } = page;
statisticsFooter = statistics || [];
const totalPage = Math.ceil(total / size);
if (totalPage > current) {
const step = parseFloat((100 / totalPage).toFixed(2));
params.percent = step;
return range(current + 1, totalPage).pipe(
mergeMap((index: number) => {
return this.dataSource(Object.assign({}, rowQuery, { pageNum: index }));
}, maxRequestCount),
pluck('records'),
tap((next) => {
params.percent = parseFloat((params.percent + step).toFixed(2));
}),
reduce((acc, val) => acc.concat(val || []), records),
);
} else {
return of([]);
}
}),
)
.toPromise()
.then((next) => {
params.status = '';
params.percent = 100;
this.api.setRowData(next);
this.api.exportDataAsExcel({ customFooter: this.exportStatisticsFooter(statisticsFooter) });
this.refresh();
return true;
})
.catch((err) => {
Console.collapse('grid-table.component ExportAllPageData', 'redBg', 'ERROR', 'redOutline');
console.error(err);
console.groupEnd();
params.status = 'exception';
confirm.updateConfig({
nzCancelText: undefined,
nzOkText: this.translateService.instant('grid.export.retry'),
});
return false;
});
},
});
}
private exportStatisticsFooter(statistics?: Array<GridStatistics>): ExcelCell[][] {
const footers: Array<Array<ExcelCell>> = [[]];
statistics = statistics || this.statistics;
if (this.showStatistics && statistics && statistics.length) {
const footer = statistics
.filter((items) => items.skipExport !== true)
.map((items) => {
const rows: Array<ExcelCell> = [];
rows.push({
styleId: 'bigHeader',
data: {
type: 'String',
value: items.label || '',
},
});
items.fields.forEach((item) => {
rows.push({
styleId: 'bigHeader',
data: {
type: 'String',
value: `${item.label}:${item.value}`,
},
} as ExcelCell);
});
return rows;
});
footers.push(...footer);
}
return footers;
}
ngOnDestroy(): void {
this.destroy$.next();
this.destroy$.complete();
}
public setData(data: IPage<any>): void {
if (this.dataLoadModel === 'pageable') {
this.cur_page = data;
this.setPageIndex(this.cur_page.current, false);
this.setPageSize(this.cur_page.size, false);
this.api.setRowData(this.cur_page.records);
} else {
console.warn('只有 tableModel === ‘pageable’ 才允许直接存值');
}
}
// 添加菜单
public addMenu(item: MenuItem): void {
this.additionMenu.push(item);
}
/**
* 刷新表格
*/
public refresh(): Observable<void> {
if (this.dataLoadModel === 'pageable') {
this.query(this.pageIndex, this.pageSize);
} else {
this.api.purgeServerSideCache();
}
// 当loading状态变更为false的时候，可以视为本次数据加载已经完成，返回这个Observable，供其他业务订阅
return this.dataLoadingChange.asObservable().pipe(
filter((status) => !status),
take(1),
map(() => {}),
);
}
/**
* 获取所有范围选中（range）的行数据
*/
public getSelectionData<U>(): U[] {
return this.getSelection((s) => s.data);
}
/**
* 获取所有范围选中（range）的行，并对其进行转换
*/
public getSelection<U>(hand: (value: RowNode) => U): U[] {
const range: CellRange = this.api.getCellRanges()[0];
const nodes: RowNode[] = this.api.getRenderedNodes();
if (range && range.startRow && range.endRow) {
const r = [];
for (let i = range.startRow.rowIndex; i <= range.endRow.rowIndex; i++) {
r.push(hand(nodes[i]));
}
return r;
} else {
return [];
}
}
/**
* 获取所有checkbox选择的行数据
*/
public getCheckedData<U>(): U[] {
return this.getChecked((s) => s.data);
}
/**
* 获取所有checkbox选择的行，并对其进行转换
*/
public getChecked<U>(hand: (value: RowNode) => U): U[] {
const nodes: RowNode[] = this.api.getSelectedNodes();
return nodes.map(hand);
}
/**
* 重置表单
*/
resetForm(): void {
this.form.reset();
}
get pageViewTmpl(): TemplateRef<any> {
return this.customPageView ? this.customPageView : this.defaultPageTmpl;
}
// ================================== 数据绑定 ====================================
toggleFullscreen(): void {
this.setFullscreen(!this.fullscreen);
}
setFullscreen(fullscreen: boolean): void {
this.fullscreen = fullscreen;
this.fullscreenChange.emit(this.fullscreen);
}
setPageIndex(pageIndex: number, emit: boolean): void {
this.pageIndex = pageIndex;
if (emit) {
this.pageIndexChange.emit(pageIndex);
}
}
setPageSize(pageSize: number, emit: boolean): void {
this.pageSize = pageSize;
if (emit) {
this.pageSizeChange.emit(pageSize);
}
}
private setDataLoading(loading: boolean): void {
| this.dataL | identifier_name |
|
ngx-grid-table.component.ts | = 1;
/** 页大小 */
@Input() pageSize = 20;
/** 表格基础配置 */
@Input() gridOptions!: GridOptions;
/** 表格基础配置 */
@Input() colACLTmpl!: string;
/** 表格主题 */
@Input() gridTheme = 'ag-theme-balham';
/** 表格CSS */
@Input() gridTableClass = [];
/** 数据表格样式 */
@Input() gridTableStyle: { [key: string]: any } = { width: '100%', height: '70%' };
/** 是否在表格初始化后立即执行一次查询 */
@Input() initLoadData = true;
/** 分页还是无限 */
@Input() dataLoadModel: 'pageable' | 'infinite' = 'pageable';
/** 是否显示分页控件 */
@Input() showPagination: false | PaginationCfg = {};
/** 是否显示默认状态栏, 展示用户选中项状态数据 */
@Input() defaultStatusBar = false;
/** 单行还是多行 */
@Input() rowSelection: undefined | 'single' | 'multiple' = undefined;
/** 是否显示统计 */
@Input() showStatistics = false;
// /** 是否展示删除菜单 */
// @Input() deleteMenu = false;
/** 默认是否可以改变列宽 */
@Input() resizable = false;
/** 分组时checkbox是否影响自己的子项 */
@Input() groupSelectsChildren = true;
/** 操作列模板 */
@Input() optionCell!: TemplateRef<any>;
/** 数据源 */
@Input() dataSource!: IGridDataSource<any>;
/** 表单schema */
@Input() searchSchema!: SFSchema;
/** 初始表单数据 */
@Input() initFormData!: any;
@Input() customPageView!: TemplateRef<any>;
@Input() filterHand!: (filters: IFilter[], form: SfQueryFormComponent) => IFilter[];
@Input() topToolPanel!: TemplateRef<any>;
@Input() bottomToolPanel!: TemplateRef<any>;
// ============================== 事件 ============================
@Output() fullscreenChange = new EventEmitter<boolean>();
@Output() pageIndexChange = new EventEmitter<number>();
@Output() pageSizeChange = new EventEmitter<number>();
/** 表格就绪事件 */
@Output() gridReady = new EventEmitter<{ event: GridReadyEvent; gridTable: NgxGridTableComponent }>();
@Output() gridReLoadReady = new EventEmitter<{ event: GridReadyEvent; gridTable: NgxGridTableComponent }>();
/** 删除事件 */
@Output() deleted = new EventEmitter<any>();
@Output() dataLoadingChange = new EventEmitter<boolean>();
@Output() dataLoadModelChange = new EventEmitter<'pageable' | 'infinite'>();
// ============================= 组件 =======================
@ViewChild(SfQueryFormComponent) form!: SfQueryFormComponent;
@ViewChild('defaultPageTmpl') defaultPageTmpl!: TemplateRef<any>;
@ViewChild('progressTmpl') progressTmpl!: TemplateRef<any>;
constructor(
private translateService: TranslateService,
private msg: NzMessageService,
private modal: NzModalService,
private reuseTabService: ReuseTabService,
private activatedRoute: ActivatedRoute,
private router: Router,
private http: _HttpClient,
private aclService: ACLService,
) {
this.currentUrl = this.router.url;
}
ngOnInit(): void {
if (!this.haveInit) {
this.initGridOptions();
}
}
private initGridOptions() {
// api 获取方法，用于给functions传递api对象
const apiGetter: ApiGetter = { get: () => ({ api: this.api, columnApi: this.columnApi }) };
buildFrameworkComponents(this.gridOptions);
// 构建菜单
buildMenus(
this.gridOptions,
this.translateService,
this.aclService,
this.additionMenu,
// this.deleteMenu,
this.destroy$,
apiGetter,
() => this.getSelectionData(),
// () => this.doDelete(),
);
buildTreeDataCfg(this.gridOptions, this.treeData);
buildStatusBar(this.gridOptions, this.defaultStatusBar);
buildSideBar(this.gridOptions) |
if (this.dataLoadModel === 'infinite') {
this.api.setServerSideDatasource(this.infiniteDataSource());
}
if (this.haveInit) {
this.gridReLoadReady.emit({ event, gridTable: this });
} else {
this.gridReady.emit({ event, gridTable: this });
this.haveInit = true;
}
// 当网格数据就绪时
// this.api.addEventListener('firstDataRendered', () => {
// this.firstDataRenderedTime = new Date().getTime();
// if (cellActionColumnDefs.length) {
// this.columnAp
i.autoSizeColumn('_action');
// }
// });
if (this.initLoadData) {
this.refresh();
}
}
private filters(): IFilter[] {
let filters = [] as IFilter[];
if (this.form) {
filters = [...this.form.filter];
}
if (this.filterHand) {
filters = [...this.filterHand(filters, this.form)];
}
return filters;
}
private infiniteDataSource(): IServerSideDatasource {
const getRows = (params: IServerSideGetRowsParams) => {
const rowQuery = serverSideAsRowQuery(params, this.treeData, this.filters());
Console.collapse('grid-table.component getData', 'indigoBg', 'queryParams', 'indigoOutline');
console.log(rowQuery);
console.groupEnd();
this.setDataLoading(true);
this.api.showLoadingOverlay();
this.dataSource(rowQuery)
.pipe(
takeUntil(this.destroy$),
catchError((err) => {
Console.collapse('grid-table.component RefreshRowsData', 'redBg', 'ERROR', 'redOutline');
console.error(err);
console.groupEnd();
return of({} as IPage<any>);
}),
)
.subscribe((resultPage) => {
if (resultPage.records) {
params.successCallback(resultPage.records, resultPage.total);
this.statistics = resultPage.statistics || [];
this.api.hideOverlay();
} else {
this.api.showNoRowsOverlay();
params.failCallback();
}
this.setDataLoading(false);
});
};
return { getRows };
}
// private doDelete(): void {
// const data: any[] = this.getCheckedData();
// if (!data.length) {
// return;
// }
// let mapper: (v: any) => string;
// if (typeof this.gridOptions.getRowNodeId === 'undefined') {
// if (typeof data[0].id !== 'undefined') {
// mapper = (v) => v.id;
// } else {
// console.warn(
// '删除操作无法获取键，默认情况下将获取id作为键，如果没有id字段或不希望使用id作为删除键，请配置 gridOptions.getRowNodeId',
// );
// return;
// }
// } else {
// mapper = this.gridOptions.getRowNodeId;
// }
//
// const ids: string[] = data.map(mapper);
//
// this.http.delete(`/api/${this.currentUrl}/deleteByKeys`, { keys: ids }).subscribe((value) => {
// this.deleted.emit(value);
// });
// }
/**
* 查询
*/
query(pageNum: number, pageSize: number): void {
this.api.clearRangeSelection();
this.api.deselectAll();
if (this.dataLoadModel !== 'pageable') {
console.warn('pageable 模式才能进行分页查询');
return;
}
const rowQuery: IRowQuery = clientSideAsRowQuery(this.api, this.columnApi, pageNum, pageSize, this.filters());
Console.collapse('grid-table.component getData', 'indigoBg', 'queryParams', 'indigoOutline');
console.log(rowQuery);
console.groupEnd();
this.api.showLoadingOverlay();
this.setDataLoading(true);
this.dataSource(rowQuery)
.pipe(
takeUntil(this.destroy$),
catchError((err) => {
Console.collapse('grid-table.component RefreshRowsData', 'redBg', 'ERROR', 'redOutline');
console.log(err);
console.groupEnd();
return of({
total: 0,
records: [],
size: rowQuery.pageSize,
current: rowQuery.pageNum,
statistics: [],
} as I | ;
buildResizable(this.gridOptions, this.resizable);
buildOptionField(this.gridOptions, this.optionCell);
reuseTabFix(this.router, this.currentUrl, this.destroy$, apiGetter);
repairRowModeType(this.gridOptions, this.dataLoadModel);
buildColACL(this.gridOptions, this.aclService, this.colACLTmpl);
if (this.showPagination !== false) {
this.showPagination = {
...NgxGridTableConstants.DEFAULT_PAGINATION,
...this.showPagination,
};
}
this.gridOptions = initGridOptions(this.gridOptions, this.rowSelection!, (event) => this.onGridReady(event));
}
private onGridReady(event: GridReadyEvent): void {
this.api = event.api;
this.columnApi = event.columnApi; | identifier_body |
normalizations.py | """Normalization layers."""
from typing import List, Optional, Tuple
import jax
from jax import numpy as jnp
from lingvo.jax import base_layer
from lingvo.jax import py_utils
from lingvo.jax import pytypes
NestedMap = py_utils.NestedMap
WeightInit = py_utils.WeightInit
weight_params = py_utils.weight_params
InstantiableParams = py_utils.InstantiableParams
JTensor = pytypes.JTensor
def compute_moments(
inputs: JTensor,
padding: JTensor,
reduce_over_dims: List[int],
enable_cross_replica_sum_on_tpu: bool = False,
keepdims: bool = False,
) -> Tuple[JTensor, JTensor]:
"""Computes mean and variance over the valid data points in inputs."""
assert inputs.ndim == padding.ndim
rank = inputs.ndim
assert all([0 <= dim < rank for dim in reduce_over_dims])
mask = 1.0 - padding
sum_v = jnp.sum(inputs * mask, axis=reduce_over_dims, keepdims=keepdims)
count_v = jnp.sum(
jnp.ones_like(inputs) * mask, axis=reduce_over_dims, keepdims=keepdims)
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_v = jax.lax.psum(sum_v, axis_name='batch')
count_v = jax.lax.psum(count_v, axis_name='batch')
count_v = jnp.maximum(count_v, 1.0)
mean = sum_v / count_v
sum_vv = jnp.sum(
(inputs - mean) * (inputs - mean) * mask,
axis=reduce_over_dims,
keepdims=keepdims)
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_vv = jax.lax.psum(sum_vv, axis_name='batch')
variance = sum_vv / count_v
return mean, variance
class BatchNorm(base_layer.BaseLayer):
"""Batch normalization layer."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('dim', 0, 'Depth of the input/output.')
p.Define(
'decay', 0.999,
'Decay in updating the mean and variance moving average used in'
' batch normalization.')
p.Define(
'enable_cross_replica_sum_on_tpu', False,
'If true, computes global mean and variance across all replicas.'
'Only effective for tpu.')
p.Define(
'use_moving_avg_in_training', False,
'If True, use global moving avg (mean, variance) during training'
' to avoid mismatch between train and eval, which then'
' essentially acts as an adaptive normalization step. When this is'
' set to True, it also disables the use of beta and gamma variables.')
p.Define('set_padded_output_to_zero', True,
'If True, sets the padded outputs to zero.')
return p
def __init__(self, params: InstantiableParams) -> None:
super().__init__(params)
p = self.params
self._epsilon = 0.001
self._decay = p.decay
def _get_weight_shape(self) -> JTensor:
return [self.params.dim]
def create_layer_variables(self) -> None:
p = self.params
beta_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('beta', beta_pc)
# gamma = theta.gamma + 1.0
gamma_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('gamma', gamma_pc)
mva = weight_params(
shape=[p.dim],
init=WeightInit.Constant(0.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_mean', mva, trainable=False)
mvv = weight_params(
shape=[p.dim],
init=WeightInit.Constant(1.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_variance', mvv, trainable=False)
def _get_default_paddings(self, inputs: JTensor) -> JTensor:
"""Gets the default paddings for an input."""
in_shape = list(inputs.shape)
assert len(in_shape) > 1
in_shape[-1] = 1
return jnp.zeros(in_shape, dtype=inputs.dtype)
def _get_beta_gamma(self, theta: NestedMap) -> Tuple[JTensor, JTensor]:
p = self.params
if p.use_moving_avg_in_training:
beta = 0.0
gamma = 1.0
else:
beta = theta.beta
gamma = theta.gamma + 1.0
return beta, gamma
def compute_and_update_moments(
self, theta: NestedMap, inputs: JTensor,
paddings: JTensor) -> Tuple[JTensor, JTensor, JTensor, JTensor]:
"""Computes moments and updates state.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim].
paddings: The paddings JTensor. Shaped [..., 1], with the same rank as
the input JTensor.
Returns:
Tuple of (mean, variance, beta, gamma).
"""
p = self.params
if self.do_eval:
# The mean and variance used for normalization.
norm_mean, norm_variance = theta.moving_mean, theta.moving_variance
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
else:
rank = inputs.ndim
reduce_over_dims = list(range(0, rank - 1))
mean, variance = compute_moments(
inputs,
paddings,
reduce_over_dims,
enable_cross_replica_sum_on_tpu=p.enable_cross_replica_sum_on_tpu,
keepdims=True)
new_moving_mean = theta.moving_mean * p.decay + mean * (1.0 - p.decay)
self.forward_update_var('moving_mean', new_moving_mean)
new_moving_variance = (
theta.moving_variance * p.decay + variance * (1.0 - p.decay))
self.forward_update_var('moving_variance', new_moving_variance)
# Add some summaries for visualization.
base_layer.add_summary('mean', mean)
base_layer.add_summary('variance', variance)
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
if p.use_moving_avg_in_training:
# Use the global statistics for normalization.
|
else:
# Use the batch statistics for normalization.
norm_mean = mean
norm_variance = variance
beta, gamma = self._get_beta_gamma(theta)
return norm_mean, norm_variance, beta, gamma
def fprop(self,
theta: NestedMap,
inputs: JTensor,
paddings: Optional[JTensor] = None) -> JTensor:
"""Apply batch normalization.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim].
paddings: The paddings JTensor. Shaped [..., 1].
Returns:
Output after applying batch normalization, with the same shape as
'inputs'.
"""
p = self.params
inputs, paddings = self._cast_to_fprop_dtype((inputs, paddings))
if paddings is None:
paddings = self._get_default_paddings(inputs)
assert inputs.ndim == paddings.ndim
assert paddings.shape[-1] == 1
norm_mean, norm_variance, beta, gamma = self.compute_and_update_moments(
theta, inputs, paddings)
inv = gamma / jnp.sqrt(norm_variance + self._epsilon)
bn_output = (inputs - norm_mean) * inv + beta
if p.set_padded_output_to_zero:
bn_output *= 1.0 - paddings
return bn_output
class LayerNorm(base_layer.BaseLayer):
"""Layer normalization."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('input_dims', 0, 'Depth of the input to the network.')
p.Define('epsilon', 1e-6, 'Tiny value to guard rsqrt.')
p.Define('scale', True, 'Whether to use a learned scaling.')
p.Define('bias', True, 'Whether to use bias.')
return p
def create_layer_variables(self) -> None:
super().create_layer_variables()
p = self.params
wp = p.weight_split_dims_mapping
wp_scale = wp.wt
| norm_mean = theta.moving_mean
norm_variance = theta.moving_variance | conditional_block |
normalizations.py | """Normalization layers."""
from typing import List, Optional, Tuple
import jax
from jax import numpy as jnp
from lingvo.jax import base_layer
from lingvo.jax import py_utils
from lingvo.jax import pytypes
NestedMap = py_utils.NestedMap
WeightInit = py_utils.WeightInit
weight_params = py_utils.weight_params
InstantiableParams = py_utils.InstantiableParams
JTensor = pytypes.JTensor
def compute_moments(
inputs: JTensor,
padding: JTensor,
reduce_over_dims: List[int],
enable_cross_replica_sum_on_tpu: bool = False,
keepdims: bool = False,
) -> Tuple[JTensor, JTensor]:
|
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_vv = jax.lax.psum(sum_vv, axis_name='batch')
variance = sum_vv / count_v
return mean, variance
class BatchNorm(base_layer.BaseLayer):
"""Batch normalization layer."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('dim', 0, 'Depth of the input/output.')
p.Define(
'decay', 0.999,
'Decay in updating the mean and variance moving average used in'
' batch normalization.')
p.Define(
'enable_cross_replica_sum_on_tpu', False,
'If true, computes global mean and variance across all replicas.'
'Only effective for tpu.')
p.Define(
'use_moving_avg_in_training', False,
'If True, use global moving avg (mean, variance) during training'
' to avoid mismatch between train and eval, which then'
' essentially acts as an adaptive normalization step. When this is'
' set to True, it also disables the use of beta and gamma variables.')
p.Define('set_padded_output_to_zero', True,
'If True, sets the padded outputs to zero.')
return p
def __init__(self, params: InstantiableParams) -> None:
super().__init__(params)
p = self.params
self._epsilon = 0.001
self._decay = p.decay
def _get_weight_shape(self) -> JTensor:
return [self.params.dim]
def create_layer_variables(self) -> None:
p = self.params
beta_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('beta', beta_pc)
# gamma = theta.gamma + 1.0
gamma_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('gamma', gamma_pc)
mva = weight_params(
shape=[p.dim],
init=WeightInit.Constant(0.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_mean', mva, trainable=False)
mvv = weight_params(
shape=[p.dim],
init=WeightInit.Constant(1.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_variance', mvv, trainable=False)
def _get_default_paddings(self, inputs: JTensor) -> JTensor:
"""Gets the default paddings for an input."""
in_shape = list(inputs.shape)
assert len(in_shape) > 1
in_shape[-1] = 1
return jnp.zeros(in_shape, dtype=inputs.dtype)
def _get_beta_gamma(self, theta: NestedMap) -> Tuple[JTensor, JTensor]:
p = self.params
if p.use_moving_avg_in_training:
beta = 0.0
gamma = 1.0
else:
beta = theta.beta
gamma = theta.gamma + 1.0
return beta, gamma
def compute_and_update_moments(
self, theta: NestedMap, inputs: JTensor,
paddings: JTensor) -> Tuple[JTensor, JTensor, JTensor, JTensor]:
"""Computes moments and updates state.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim].
paddings: The paddings JTensor. Shaped [..., 1], with the same rank as
the input JTensor.
Returns:
Tuple of (mean, variance, beta, gamma).
"""
p = self.params
if self.do_eval:
# The mean and variance used for normalization.
norm_mean, norm_variance = theta.moving_mean, theta.moving_variance
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
else:
rank = inputs.ndim
reduce_over_dims = list(range(0, rank - 1))
mean, variance = compute_moments(
inputs,
paddings,
reduce_over_dims,
enable_cross_replica_sum_on_tpu=p.enable_cross_replica_sum_on_tpu,
keepdims=True)
new_moving_mean = theta.moving_mean * p.decay + mean * (1.0 - p.decay)
self.forward_update_var('moving_mean', new_moving_mean)
new_moving_variance = (
theta.moving_variance * p.decay + variance * (1.0 - p.decay))
self.forward_update_var('moving_variance', new_moving_variance)
# Add some summaries for visualization.
base_layer.add_summary('mean', mean)
base_layer.add_summary('variance', variance)
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
if p.use_moving_avg_in_training:
# Use the global statistics for normalization.
norm_mean = theta.moving_mean
norm_variance = theta.moving_variance
else:
# Use the batch statistics for normalization.
norm_mean = mean
norm_variance = variance
beta, gamma = self._get_beta_gamma(theta)
return norm_mean, norm_variance, beta, gamma
def fprop(self,
theta: NestedMap,
inputs: JTensor,
paddings: Optional[JTensor] = None) -> JTensor:
"""Apply batch normalization.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim].
paddings: The paddings JTensor. Shaped [..., 1].
Returns:
Output after applying batch normalization, with the same shape as
'inputs'.
"""
p = self.params
inputs, paddings = self._cast_to_fprop_dtype((inputs, paddings))
if paddings is None:
paddings = self._get_default_paddings(inputs)
assert inputs.ndim == paddings.ndim
assert paddings.shape[-1] == 1
norm_mean, norm_variance, beta, gamma = self.compute_and_update_moments(
theta, inputs, paddings)
inv = gamma / jnp.sqrt(norm_variance + self._epsilon)
bn_output = (inputs - norm_mean) * inv + beta
if p.set_padded_output_to_zero:
bn_output *= 1.0 - paddings
return bn_output
class LayerNorm(base_layer.BaseLayer):
"""Layer normalization."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('input_dims', 0, 'Depth of the input to the network.')
p.Define('epsilon', 1e-6, 'Tiny value to guard rsqrt.')
p.Define('scale', True, 'Whether to use a learned scaling.')
p.Define('bias', True, 'Whether to use bias.')
return p
def create_layer_variables(self) -> None:
super().create_layer_variables()
p = self.params
wp = p.weight_split_dims_mapping
wp_scale = wp.wt | """Computes mean and variance over the valid data points in inputs."""
assert inputs.ndim == padding.ndim
rank = inputs.ndim
assert all([0 <= dim < rank for dim in reduce_over_dims])
mask = 1.0 - padding
sum_v = jnp.sum(inputs * mask, axis=reduce_over_dims, keepdims=keepdims)
count_v = jnp.sum(
jnp.ones_like(inputs) * mask, axis=reduce_over_dims, keepdims=keepdims)
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_v = jax.lax.psum(sum_v, axis_name='batch')
count_v = jax.lax.psum(count_v, axis_name='batch')
count_v = jnp.maximum(count_v, 1.0)
mean = sum_v / count_v
sum_vv = jnp.sum(
(inputs - mean) * (inputs - mean) * mask,
axis=reduce_over_dims,
keepdims=keepdims) | identifier_body |
normalizations.py | """Normalization layers."""
from typing import List, Optional, Tuple
import jax
from jax import numpy as jnp
from lingvo.jax import base_layer
from lingvo.jax import py_utils
from lingvo.jax import pytypes
NestedMap = py_utils.NestedMap
WeightInit = py_utils.WeightInit
weight_params = py_utils.weight_params
InstantiableParams = py_utils.InstantiableParams
JTensor = pytypes.JTensor
def compute_moments(
inputs: JTensor,
padding: JTensor,
reduce_over_dims: List[int],
enable_cross_replica_sum_on_tpu: bool = False,
keepdims: bool = False,
) -> Tuple[JTensor, JTensor]:
"""Computes mean and variance over the valid data points in inputs."""
assert inputs.ndim == padding.ndim
rank = inputs.ndim
assert all([0 <= dim < rank for dim in reduce_over_dims])
mask = 1.0 - padding
sum_v = jnp.sum(inputs * mask, axis=reduce_over_dims, keepdims=keepdims)
count_v = jnp.sum(
jnp.ones_like(inputs) * mask, axis=reduce_over_dims, keepdims=keepdims)
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_v = jax.lax.psum(sum_v, axis_name='batch')
count_v = jax.lax.psum(count_v, axis_name='batch')
count_v = jnp.maximum(count_v, 1.0)
mean = sum_v / count_v
sum_vv = jnp.sum(
(inputs - mean) * (inputs - mean) * mask,
axis=reduce_over_dims,
keepdims=keepdims)
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_vv = jax.lax.psum(sum_vv, axis_name='batch')
variance = sum_vv / count_v
return mean, variance
class BatchNorm(base_layer.BaseLayer):
"""Batch normalization layer."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('dim', 0, 'Depth of the input/output.')
p.Define(
'decay', 0.999,
'Decay in updating the mean and variance moving average used in'
' batch normalization.')
p.Define(
'enable_cross_replica_sum_on_tpu', False,
'If true, computes global mean and variance across all replicas.'
'Only effective for tpu.')
p.Define(
'use_moving_avg_in_training', False,
'If True, use global moving avg (mean, variance) during training'
' to avoid mismatch between train and eval, which then'
' essentially acts as an adaptive normalization step. When this is'
' set to True, it also disables the use of beta and gamma variables.')
p.Define('set_padded_output_to_zero', True,
'If True, sets the padded outputs to zero.')
return p
def __init__(self, params: InstantiableParams) -> None:
super().__init__(params)
p = self.params
self._epsilon = 0.001
self._decay = p.decay
def _get_weight_shape(self) -> JTensor:
return [self.params.dim]
def create_layer_variables(self) -> None:
p = self.params
beta_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('beta', beta_pc)
# gamma = theta.gamma + 1.0
gamma_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('gamma', gamma_pc)
mva = weight_params(
shape=[p.dim],
init=WeightInit.Constant(0.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_mean', mva, trainable=False)
mvv = weight_params(
shape=[p.dim],
init=WeightInit.Constant(1.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_variance', mvv, trainable=False)
def _get_default_paddings(self, inputs: JTensor) -> JTensor:
"""Gets the default paddings for an input."""
in_shape = list(inputs.shape)
assert len(in_shape) > 1
in_shape[-1] = 1
return jnp.zeros(in_shape, dtype=inputs.dtype)
def _get_beta_gamma(self, theta: NestedMap) -> Tuple[JTensor, JTensor]:
p = self.params
if p.use_moving_avg_in_training:
beta = 0.0
gamma = 1.0
else:
beta = theta.beta
gamma = theta.gamma + 1.0
return beta, gamma
def compute_and_update_moments(
self, theta: NestedMap, inputs: JTensor,
paddings: JTensor) -> Tuple[JTensor, JTensor, JTensor, JTensor]:
"""Computes moments and updates state.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim].
paddings: The paddings JTensor. Shaped [..., 1], with the same rank as
the input JTensor.
Returns:
Tuple of (mean, variance, beta, gamma).
"""
p = self.params
if self.do_eval:
# The mean and variance used for normalization.
norm_mean, norm_variance = theta.moving_mean, theta.moving_variance
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
else:
rank = inputs.ndim
reduce_over_dims = list(range(0, rank - 1))
mean, variance = compute_moments(
inputs,
paddings,
reduce_over_dims,
enable_cross_replica_sum_on_tpu=p.enable_cross_replica_sum_on_tpu,
keepdims=True)
new_moving_mean = theta.moving_mean * p.decay + mean * (1.0 - p.decay)
self.forward_update_var('moving_mean', new_moving_mean)
new_moving_variance = (
theta.moving_variance * p.decay + variance * (1.0 - p.decay))
self.forward_update_var('moving_variance', new_moving_variance)
# Add some summaries for visualization.
base_layer.add_summary('mean', mean)
base_layer.add_summary('variance', variance)
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
if p.use_moving_avg_in_training:
# Use the global statistics for normalization.
norm_mean = theta.moving_mean
norm_variance = theta.moving_variance
else:
# Use the batch statistics for normalization.
norm_mean = mean
norm_variance = variance
beta, gamma = self._get_beta_gamma(theta)
return norm_mean, norm_variance, beta, gamma
def fprop(self,
theta: NestedMap,
inputs: JTensor,
paddings: Optional[JTensor] = None) -> JTensor:
"""Apply batch normalization.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim]. | """
p = self.params
inputs, paddings = self._cast_to_fprop_dtype((inputs, paddings))
if paddings is None:
paddings = self._get_default_paddings(inputs)
assert inputs.ndim == paddings.ndim
assert paddings.shape[-1] == 1
norm_mean, norm_variance, beta, gamma = self.compute_and_update_moments(
theta, inputs, paddings)
inv = gamma / jnp.sqrt(norm_variance + self._epsilon)
bn_output = (inputs - norm_mean) * inv + beta
if p.set_padded_output_to_zero:
bn_output *= 1.0 - paddings
return bn_output
class LayerNorm(base_layer.BaseLayer):
"""Layer normalization."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('input_dims', 0, 'Depth of the input to the network.')
p.Define('epsilon', 1e-6, 'Tiny value to guard rsqrt.')
p.Define('scale', True, 'Whether to use a learned scaling.')
p.Define('bias', True, 'Whether to use bias.')
return p
def create_layer_variables(self) -> None:
super().create_layer_variables()
p = self.params
wp = p.weight_split_dims_mapping
wp_scale = wp.wt
| paddings: The paddings JTensor. Shaped [..., 1].
Returns:
Output after applying batch normalization, with the same shape as
'inputs'. | random_line_split |
normalizations.py | """Normalization layers."""
from typing import List, Optional, Tuple
import jax
from jax import numpy as jnp
from lingvo.jax import base_layer
from lingvo.jax import py_utils
from lingvo.jax import pytypes
NestedMap = py_utils.NestedMap
WeightInit = py_utils.WeightInit
weight_params = py_utils.weight_params
InstantiableParams = py_utils.InstantiableParams
JTensor = pytypes.JTensor
def compute_moments(
inputs: JTensor,
padding: JTensor,
reduce_over_dims: List[int],
enable_cross_replica_sum_on_tpu: bool = False,
keepdims: bool = False,
) -> Tuple[JTensor, JTensor]:
"""Computes mean and variance over the valid data points in inputs."""
assert inputs.ndim == padding.ndim
rank = inputs.ndim
assert all([0 <= dim < rank for dim in reduce_over_dims])
mask = 1.0 - padding
sum_v = jnp.sum(inputs * mask, axis=reduce_over_dims, keepdims=keepdims)
count_v = jnp.sum(
jnp.ones_like(inputs) * mask, axis=reduce_over_dims, keepdims=keepdims)
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_v = jax.lax.psum(sum_v, axis_name='batch')
count_v = jax.lax.psum(count_v, axis_name='batch')
count_v = jnp.maximum(count_v, 1.0)
mean = sum_v / count_v
sum_vv = jnp.sum(
(inputs - mean) * (inputs - mean) * mask,
axis=reduce_over_dims,
keepdims=keepdims)
if enable_cross_replica_sum_on_tpu:
# TODO(shafey, yonghui): Fetch axis_name from globals.
sum_vv = jax.lax.psum(sum_vv, axis_name='batch')
variance = sum_vv / count_v
return mean, variance
class BatchNorm(base_layer.BaseLayer):
"""Batch normalization layer."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('dim', 0, 'Depth of the input/output.')
p.Define(
'decay', 0.999,
'Decay in updating the mean and variance moving average used in'
' batch normalization.')
p.Define(
'enable_cross_replica_sum_on_tpu', False,
'If true, computes global mean and variance across all replicas.'
'Only effective for tpu.')
p.Define(
'use_moving_avg_in_training', False,
'If True, use global moving avg (mean, variance) during training'
' to avoid mismatch between train and eval, which then'
' essentially acts as an adaptive normalization step. When this is'
' set to True, it also disables the use of beta and gamma variables.')
p.Define('set_padded_output_to_zero', True,
'If True, sets the padded outputs to zero.')
return p
def __init__(self, params: InstantiableParams) -> None:
super().__init__(params)
p = self.params
self._epsilon = 0.001
self._decay = p.decay
def _get_weight_shape(self) -> JTensor:
return [self.params.dim]
def create_layer_variables(self) -> None:
p = self.params
beta_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('beta', beta_pc)
# gamma = theta.gamma + 1.0
gamma_pc = weight_params(
shape=self._get_weight_shape(),
init=WeightInit.Constant(0.0),
dtype=p.dtype)
self.create_variable('gamma', gamma_pc)
mva = weight_params(
shape=[p.dim],
init=WeightInit.Constant(0.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_mean', mva, trainable=False)
mvv = weight_params(
shape=[p.dim],
init=WeightInit.Constant(1.0),
dtype=p.dtype,
collections=[base_layer.REQUIRES_MEAN_SYNC])
self.create_variable('moving_variance', mvv, trainable=False)
def _get_default_paddings(self, inputs: JTensor) -> JTensor:
"""Gets the default paddings for an input."""
in_shape = list(inputs.shape)
assert len(in_shape) > 1
in_shape[-1] = 1
return jnp.zeros(in_shape, dtype=inputs.dtype)
def | (self, theta: NestedMap) -> Tuple[JTensor, JTensor]:
p = self.params
if p.use_moving_avg_in_training:
beta = 0.0
gamma = 1.0
else:
beta = theta.beta
gamma = theta.gamma + 1.0
return beta, gamma
def compute_and_update_moments(
self, theta: NestedMap, inputs: JTensor,
paddings: JTensor) -> Tuple[JTensor, JTensor, JTensor, JTensor]:
"""Computes moments and updates state.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim].
paddings: The paddings JTensor. Shaped [..., 1], with the same rank as
the input JTensor.
Returns:
Tuple of (mean, variance, beta, gamma).
"""
p = self.params
if self.do_eval:
# The mean and variance used for normalization.
norm_mean, norm_variance = theta.moving_mean, theta.moving_variance
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
else:
rank = inputs.ndim
reduce_over_dims = list(range(0, rank - 1))
mean, variance = compute_moments(
inputs,
paddings,
reduce_over_dims,
enable_cross_replica_sum_on_tpu=p.enable_cross_replica_sum_on_tpu,
keepdims=True)
new_moving_mean = theta.moving_mean * p.decay + mean * (1.0 - p.decay)
self.forward_update_var('moving_mean', new_moving_mean)
new_moving_variance = (
theta.moving_variance * p.decay + variance * (1.0 - p.decay))
self.forward_update_var('moving_variance', new_moving_variance)
# Add some summaries for visualization.
base_layer.add_summary('mean', mean)
base_layer.add_summary('variance', variance)
base_layer.add_summary('moving_mean', theta.moving_mean)
base_layer.add_summary('moving_variance', theta.moving_variance)
if p.use_moving_avg_in_training:
# Use the global statistics for normalization.
norm_mean = theta.moving_mean
norm_variance = theta.moving_variance
else:
# Use the batch statistics for normalization.
norm_mean = mean
norm_variance = variance
beta, gamma = self._get_beta_gamma(theta)
return norm_mean, norm_variance, beta, gamma
def fprop(self,
theta: NestedMap,
inputs: JTensor,
paddings: Optional[JTensor] = None) -> JTensor:
"""Apply batch normalization.
Args:
theta: A `.NestedMap` object containing weights' values of this layer and
its children layers.
inputs: The inputs JTensor. Shaped [..., dim].
paddings: The paddings JTensor. Shaped [..., 1].
Returns:
Output after applying batch normalization, with the same shape as
'inputs'.
"""
p = self.params
inputs, paddings = self._cast_to_fprop_dtype((inputs, paddings))
if paddings is None:
paddings = self._get_default_paddings(inputs)
assert inputs.ndim == paddings.ndim
assert paddings.shape[-1] == 1
norm_mean, norm_variance, beta, gamma = self.compute_and_update_moments(
theta, inputs, paddings)
inv = gamma / jnp.sqrt(norm_variance + self._epsilon)
bn_output = (inputs - norm_mean) * inv + beta
if p.set_padded_output_to_zero:
bn_output *= 1.0 - paddings
return bn_output
class LayerNorm(base_layer.BaseLayer):
"""Layer normalization."""
@classmethod
def Params(cls) -> InstantiableParams:
p = super().Params()
p.Define('input_dims', 0, 'Depth of the input to the network.')
p.Define('epsilon', 1e-6, 'Tiny value to guard rsqrt.')
p.Define('scale', True, 'Whether to use a learned scaling.')
p.Define('bias', True, 'Whether to use bias.')
return p
def create_layer_variables(self) -> None:
super().create_layer_variables()
p = self.params
wp = p.weight_split_dims_mapping
wp_scale = wp.wt
| _get_beta_gamma | identifier_name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.