Identify branches to maintain in each kiegroup repository

Repos:
https://github.com/kiegroup/drools
https://github.com/kiegroup/kogito-runtimes
https://github.com/kiegroup/kogito-apps
https://github.com/kiegroup/kogito-examples
https://github.com/kiegroup/kogito-docs
https://github.com/kiegroup/kogito-images
https://github.com/kiegroup/kogito-operator
https://github.com/kiegroup/kogito-website
https://github.com/kiegroup/kogito-pipelines
https://github.com/kiegroup/kie-tools
https://github.com/kiegroup/kie-benchmarks
https://github.com/kiegroup/optaplanner
https://github.com/kiegroup/kogito-serverless-operator
https://github.com/kiegroup/optaplanner-quickstarts
https://github.com/kiegroup/kie-docs
https://github.com/kiegroup/kogito-benchmarks
https://github.com/kiegroup/kie-sandbox-quarkus-accelerator
https://github.com/kiegroup/kogito-online-staging
https://github.com/kiegroup/kogito-online

@eduardocerqueira @porcelli @baldimir
here are my questions from the repositories we currently use:

kogito-serverless-operator stays is not moved ?
kie-jpmml-integration should be moved ? cc @danielezonca
if optaplanner is moved, shouldn't we move optaplanner-quickstarts and optaplanner-website as well ?
what about drools-website ?
what would become of kie-docs ?

For reference, here are the configuration we use on pipelines to generate Jenkins jobs for Kogito/Drools8/OP8, and it helps to know which repositories are currently in use:

drools config
optaplanner config
kogito config

There is one more repository, which I highlighted in the initial Apache document:
https://github.com/kiegroup/kogito-benchmarks

For these production community environments to work, we also depend on two other repos, that are used for the GitHub Pages deployments:

https://github.com/kiegroup/kogito-online-staging
https://github.com/kiegroup/kogito-online

The name is kogito for historical reasons, but they're both part of the KIE Tools production community infrastructure.

I think so, but let's confirm with @caponetto

@ederign @tiagobento Yes. The deployment of the webapp is on gh-pages branch (dev and staging included) and the Quarkus accelerator is on quarkus-accelerator branch.

Repos to move:
kogito-serverless-operator
optaplanner-quickstarts
kie-docs
kogito-benchmarks
kie-sandbox-quarkus-accelerator
kogito-online-staging
kogito-online
2nd Phase Move:
*-website (will need updates, will use jbake)
Left behind:
jpmml left behind (probably can't anyway due to license)
serverless-logic-sandbox-deployment

Repos to move: kogito-serverless-operator optaplanner-quickstarts kie-docs kogito-benchmarks kie-sandbox-quarkus-accelerator kogito-online-staging kogito-online
2nd Phase Move: *-website (will need updates, will use jbake)
Left behind: jpmml left behind (probably can't anyway due to license) serverless-logic-sandbox-deployment

@porcelli Where are kogito-runtimes, kogito-apps, kogito-examples and others from the first comment?

@MarianMacik if you check I also updated the description of the issue to incorporate my last comment.
my last comment was just for record the decision that were made during the sync call we had early today between Red Hat and IBM

At this point all repos were identified. The repos migration is tracked on this issue https://github.com/kiegroup/kie-issues/issues/428
and the copyrights and headers on this https://github.com/kiegroup/kie-issues/issues/413

not so fast @eduardocerqueira
Just found out https://github.com/kiegroup/drools-lsp
And we also have kie-issues

thank you @tarilabs to spot one more repo that has been left behind.
https://github.com/kiegroup/dmn-feel-handbook#readme

there's also this repository https://github.com/kiegroup/kie-issues

Thank you everyone for the comments with the missed repos, they were added to the EPIC https://github.com/orgs/apache/projects/295/views/3?pane=issue&itemId=40508194 where we will continue tracking the work for transferring the repos to Apache.
Closing this task, pls use the EPIC listed above for further comments.


fix: Support limit flag for Box Search

Closes: SDK-2171
Fixes:  #322

Not the best approach. CLI uses limit and offset by itself to sum all results to one array.


filter/2 function grouping on documentation index

When reading through the docs one might see that DataFrame.filter/2 is not properly grouped in the HexDocs modules section/index. Similar functions are grouped in the Explorer.DataFrame > Functions: Single Table section, but not filter/2. Is there a reason to do so?
I believe the function should be inside the "Functions: Single Table" subsection.

Good find, it has been fixed in main!


Use recommended documentation IP ranges

Use proper RFC3849 and RFC5737 IP ranges in the documentation, and clear up how the actual prefix should be selected.

/check-cla

/assign @vineethreddy02

Thanks for your feedback. I think this part of the documentation needs more than just this particular change and to be honest it’s not my area of expertise, so I’m leaving this as-is for now.


更新0.43.08版本无法安装，并无法重新安装

koolshare 2.37版本
Collected errors:

pkg_hash_fetch_best_installation_candidate: Packages for luci-app-openclash found, but incompatible with the architectures configured
opkg_install_cmd: Cannot install package luci-app-openclash.

0.43.9依然无法安装


Silence unhandled resources warning

This PR silences the Xcode warning as below caused by Info.plist file

@gabriellanata pls check this PR. Thanks for the awesome library.

Thanks!

@gabriellanata hey, do you have any plan for a new release soon?

Yes! Was waiting for a couple more PRs to merge. Version 0.13.0 should be available with this change included


Fixed & Added Hamburger to Navigation Bar

Description
This PR fixes & adds Hamburger to the Navbar & successfully closes #102 .
Screenshots :
Large Screen :

Mobile Version :

Would be glad if you'd merge this PR @SSHSRN 👍

Thanks for the contribution!


Remove Teacher Comments

Remove Teacher Comments

@saravanan-udayakumar , these tests look good and will greatly help cleanup the chats. But I also think that because CLUE tests run in parallel in github, there's a high chance when one thread might be running the chat tests and adding comments to be verified later in that test when a different thread might run this cleanup test and remove the comments leading the former test to fail.
I say we move this specific into a new folder outside functional, that we can call cleanup. We can then run cleanup as a separate job in github after every cypress run. I'll add a story for myself for setting up the separate job. Can you please do the folder setup I mentioned above in this PR?

@saravanan-udayakumar , I've moved this test to the cleanup folder and made the changes to regression-daily.yml so that this cleanup runs once a day along with regression-daily in github to cleanup all comments added in the day that weren't already deleted by the tests. I'll merge this PR now.


Add 'channels' options; save cache on action failure; extend docs

Rel https://github.com/mamba-org/provision-with-micromamba/issues/42
Closes https://github.com/mamba-org/provision-with-micromamba/issues/44

Hah

Thanks @jonashaag for this! Would be nice to get merged soon

@wolfv

ping @wolfv

One argument against it is that it's slightly more cumbersome to have conditional extra-specs/channels:
extra-specs: |
  ${{ some-condition && 'python=3.7' || '' }}

vs (does that even work?)
extra-specs:
  ${{ some-condition && '- python=3.7' || '' }}

or even
extra-specs:
  ${{ some-condition && format('- python={}', some-version) || '' }}

I guess we could just ignore empty lists items (is -  even a valid YAML line?).
The | style is what GitHub does eg. in the cache action, but it's unclear why https://github.com/actions/cache/issues/510.
I guess it's safe to support both syntaxes as well...

LGTM!

@wolfv if you're OK with the extra-specs syntax I think we should merge this.


feat: Performance improvement

Performance improvement refactoring suggested in https://github.com/jsr-core/asyncutil/issues/30 are applied.
Check file:///Users/alisue/ogh/jsr-core/asyncutil/mutex_bench.ts
Check file:///Users/alisue/ogh/jsr-core/asyncutil/semaphore_bench.ts
cpu: Apple M1 Max
runtime: deno 1.45.4 (aarch64-apple-darwin)

file:///Users/alisue/ogh/jsr-core/asyncutil/mutex_bench.ts
benchmark              time (avg)        iter/s             (min … max)       p75       p99      p995
----------------------------------------------------------------------- -----------------------------
Mutex                 452.41 ns/iter   2,210,370.0 (439.27 ns … 545.97 ns) 446.38 ns 537.83 ns 545.97 ns
Mutex (1.0.2)         666.79 ns/iter   1,499,722.7 (636.54 ns … 947.56 ns) 653.95 ns 947.56 ns 947.56 ns
Mutex (Issue #30)     435.85 ns/iter   2,294,381.9  (428.7 ns … 458.39 ns) 435.39 ns 457.76 ns 458.39 ns

file:///Users/alisue/ogh/jsr-core/asyncutil/semaphore_bench.ts
benchmark              time (avg)        iter/s             (min … max)       p75       p99      p995
----------------------------------------------------------------------- -----------------------------
Semaphore              78.77 µs/iter      12,695.7    (61.62 µs … 1.81 ms) 68.04 µs 607.38 µs 665.96 µs
Semaphore (1.0.2)     296.69 µs/iter       3,370.6    (260.5 µs … 2.24 ms) 279.54 µs 635.88 µs 687.54 µs

Thanks to @PandaWorker 🎉

It's not entirely clear what Object.assign is used for.
When I measured performance, the version with Object.assign was slower because additional instructions were executed, which in principle are not needed at all
Explain to me why to bind the disposing methods to the promise itself?
return Object.assign(Promise.resolve(disposable), disposable);
return Object.assign(waiter.promise.then(() => disposable), disposable);

Also, I would recommend using under the hood of the module only: lock[Symbol.dispose]()
And give customers the opportunity to manually release
const sem = new Semaphore(1);

{
  const lock = await sem.acquire();
  try {
     // do ...
  } finally {
    lock[Symbol.dispose](); // ot sem.release();
  }
}

{
  const lock = await sem.acquire();
  return asyncTask().finally(() => lock[Symbol.dispose]); // or sem.release();
}

You also need to write all possible tests and benchmarks

Also Denon.bench does not run tasks competitively, which means that the semaphore will always be unlocked and will not put the expectant in the Set
You also need to make benchmarks for competitive access to acquire, so that the expectations are exactly put in the Set

The semaphore implementation on Set will work in much the same way as on Deque, as long as there are few elements. As soon as there are a lot of expectations, there is a significant performance drawdown, since Set hashes the element itself when adding and searching for an element, and Deque immediately gives the first element
cpu: Apple M1 Max
runtime: deno 1.45.5 (aarch64-apple-darwin)

file:///Users/panda/Documents/deno/sync/semaphore.bench.ts
benchmark                                                      time (avg)        iter/s             (min … max)       p75       p99      p995
--------------------------------------------------------------------------------------------------------------- -----------------------------

group semaphore acquire
relesae with using                                            631.12 ns/iter   1,584,480.8 (456.72 ns … 881.66 ns) 657.79 ns 881.66 ns 881.66 ns
relesae with using [acquireWithSignal]                        584.76 ns/iter   1,710,112.1 (474.36 ns … 929.88 ns) 627.16 ns 929.88 ns 929.88 ns
relesae with [Symbol.dispose]                                  373.9 ns/iter   2,674,518.7 (292.75 ns … 459.38 ns) 421.79 ns 457.5 ns 459.38 ns
relesae with [Symbol.dispose] (Deque)                         417.88 ns/iter   2,393,042.3  (320.25 ns … 512.5 ns) 466.82 ns 508.17 ns 512.5 ns
relesae with [Symbol.dispose] [acquireWithSignal]                422 ns/iter   2,369,692.6   (294.93 ns … 2.37 µs) 424.22 ns 1.82 µs 2.37 µs
relesae with [Symbol.dispose] [acquireWithSignal] (Deque)     409.78 ns/iter   2,440,341.3   (302.27 ns … 2.41 µs) 419.23 ns 1.51 µs 2.41 µs

summary
  relesae with [Symbol.dispose]
   1.1x faster than relesae with [Symbol.dispose] [acquireWithSignal] (Deque)
   1.12x faster than relesae with [Symbol.dispose] (Deque)
   1.13x faster than relesae with [Symbol.dispose] [acquireWithSignal]
   1.56x faster than relesae with using [acquireWithSignal]
   1.69x faster than relesae with using

group semaphore concurents tasks (5)
relesae with using                                              3.84 µs/iter     260,238.5     (3.23 µs … 4.71 µs) 4.07 µs 4.71 µs 4.71 µs
relesae with using [acquireWithSignal]                          3.91 µs/iter     255,575.8     (3.01 µs … 5.06 µs) 4.18 µs 5.06 µs 5.06 µs
relesae with [Symbol.dispose]                                   2.82 µs/iter     354,830.3     (2.31 µs … 3.17 µs) 2.92 µs 3.17 µs 3.17 µs
relesae with [Symbol.dispose] (Deque)                           2.49 µs/iter     402,009.5      (1.9 µs … 2.71 µs) 2.66 µs 2.71 µs 2.71 µs
relesae with [Symbol.dispose] [acquireWithSignal]               2.72 µs/iter     368,041.4     (2.22 µs … 3.41 µs) 3.01 µs 3.41 µs 3.41 µs
relesae with [Symbol.dispose] [acquireWithSignal] (Deque)       2.53 µs/iter     395,288.0     (2.01 µs … 2.91 µs) 2.71 µs 2.91 µs 2.91 µs

summary
  relesae with [Symbol.dispose] (Deque)
   1.02x faster than relesae with [Symbol.dispose] [acquireWithSignal] (Deque)
   1.09x faster than relesae with [Symbol.dispose] [acquireWithSignal]
   1.13x faster than relesae with [Symbol.dispose]
   1.54x faster than relesae with using
   1.57x faster than relesae with using [acquireWithSignal]

group semaphore concurents tasks (10_000)
relesae with using                                             34.14 ms/iter          29.3  (25.57 ms … 112.56 ms) 32.61 ms 112.56 ms 112.56 ms
relesae with using [acquireWithSignal]                         44.94 ms/iter          22.3    (26.4 ms … 119.2 ms) 56.11 ms 119.2 ms 119.2 ms
relesae with [Symbol.dispose]                                  27.16 ms/iter          36.8   (21.55 ms … 58.43 ms) 28.34 ms 58.43 ms 58.43 ms
relesae with [Symbol.dispose] (Deque)                            6.2 ms/iter         161.3    (4.62 ms … 15.66 ms) 6.61 ms 15.66 ms 15.66 ms
relesae with [Symbol.dispose] [acquireWithSignal]              25.95 ms/iter          38.5   (21.04 ms … 34.29 ms) 28.16 ms 34.29 ms 34.29 ms
relesae with [Symbol.dispose] [acquireWithSignal] (Deque)        5.8 ms/iter         172.4    (3.65 ms … 18.56 ms) 6.66 ms 18.56 ms 18.56 ms

summary
  relesae with [Symbol.dispose] [acquireWithSignal] (Deque)
   1.07x faster than relesae with [Symbol.dispose] (Deque)
   4.47x faster than relesae with [Symbol.dispose] [acquireWithSignal]
   4.68x faster than relesae with [Symbol.dispose]
   5.88x faster than relesae with using
   7.75x faster than relesae with using [acquireWithSignal]

group semaphore concurents tasks (50_000)
relesae with using                                            687.02 ms/iter           1.5  (650.5 ms … 739.51 ms) 695.77 ms 739.51 ms 739.51 ms
relesae with using [acquireWithSignal]                        702.04 ms/iter           1.4 (591.96 ms … 835.46 ms) 787.13 ms 835.46 ms 835.46 ms
relesae with [Symbol.dispose]                                 610.42 ms/iter           1.6  (574.81 ms … 643.3 ms) 629.11 ms 643.3 ms 643.3 ms
relesae with [Symbol.dispose] (Deque)                          66.74 ms/iter          15.0    (57.17 ms … 81.5 ms) 68.79 ms 81.5 ms 81.5 ms
relesae with [Symbol.dispose] [acquireWithSignal]             628.18 ms/iter           1.6 (549.56 ms … 676.17 ms) 671.43 ms 676.17 ms 676.17 ms
relesae with [Symbol.dispose] [acquireWithSignal] (Deque)      85.02 ms/iter          11.8  (65.58 ms … 105.92 ms) 92.25 ms 105.92 ms 105.92 ms

summary
  relesae with [Symbol.dispose] (Deque)
   1.27x faster than relesae with [Symbol.dispose] [acquireWithSignal] (Deque)
   9.15x faster than relesae with [Symbol.dispose]
   9.41x faster than relesae with [Symbol.dispose] [acquireWithSignal]
   10.29x faster than relesae with using
   10.52x faster than relesae with using [acquireWithSignal]

It's not entirely clear what Object.assign is used for. When I measured performance, the version with Object.assign was slower because additional instructions were executed, which in principle are not needed at all
Explain to me why to bind the disposing methods to the promise itself?
return Object.assign(Promise.resolve(disposable), disposable);
return Object.assign(waiter.promise.then(() => disposable), disposable);

The current RwLock implementation relies on that.

While there is no native using feature in v8, you should not use it in places where it can harm performance and in libraries

I see. I haven't considered that. Now, I think we need to add release() for convenience

No runtime has native support for using, check state tc39 yet https://github.com/tc39/proposal-explicit-resource-management
At the moment, the conversion of using to a js implementation is being used, which is not very optimized.
For more than a year, runtimes have been preparing for the appearance of using in native form in v8.
I took measurements on all runtimes of Bun, Deno and Node(tsx), everywhere using led to a significant deterioration in performance

Look at what it turns into when you build
From here you will get the answer to the question why there is no native support and performance drawdown due to unnecessary abstractions
source:
const disposable = {
	data: '123',
	[Symbol.dispose](){
		console.log('disposed')
	}
}

{
	using a = disposable;
	console.log(a);
}

bundle:
function _using_ctx() {
    var _disposeSuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed) {
        var err = new Error();
        err.name = "SuppressedError";
        err.suppressed = suppressed;
        err.error = error;
        return err;
    }, empty = {}, stack = [];
    function using(isAwait, value) {
        if (value != null) {
            if (Object(value) !== value) {
                throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
            }
            if (isAwait) {
                var dispose = value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
            }
            if (dispose == null) {
                dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
            }
            if (typeof dispose !== "function") {
                throw new TypeError(`Property [Symbol.dispose] is not a function.`);
            }
            stack.push({
                v: value,
                d: dispose,
                a: isAwait
            });
        } else if (isAwait) {
            stack.push({
                d: value,
                a: isAwait
            });
        }
        return value;
    }
    return {
        e: empty,
        u: using.bind(null, false),
        a: using.bind(null, true),
        d: function() {
            var error = this.e;
            function next() {
                while(resource = stack.pop()){
                    try {
                        var resource, disposalResult = resource.d && resource.d.call(resource.v);
                        if (resource.a) {
                            return Promise.resolve(disposalResult).then(next, err);
                        }
                    } catch (e) {
                        return err(e);
                    }
                }
                if (error !== empty) throw error;
            }
            function err(e) {
                error = error !== empty ? new _disposeSuppressedError(error, e) : e;
                return next();
            }
            return next();
        }
    };
}
const disposable = {
    data: '123',
    [Symbol.dispose] () {
        console.log('disposed');
    }
};
{
    try {
        var _usingCtx = _using_ctx();
        const a = _usingCtx.u(disposable);
        console.log(a);
    } catch (_) {
        _usingCtx.e = _;
    } finally{
        _usingCtx.d();
    }
}

There's no point arguing, make benchmarks for both versions and you'll see for yourself.

I’ve already decided to remove using from internal implementations due to performance concerns. Now, I’m considering whether or not to add a release() method.
I’m aware that using is still at stage 3, but if most platforms already support it, I think it would be better NOT to expose release(). If users are concerned about performance, they can use lock[System.dispose]() instead.

I'll remove using anyway due to performance concern in Node but it seems using doesn't affect the performance in Deno. Just fyi.
benchmark      time (avg)        iter/s             (min … max)       p75       p99      p995
--------------------------------------------------------------- -----------------------------

group Lock#lock
v1.0.0         52.84 ms/iter          18.9   (45.86 ms … 57.58 ms) 55.68 ms 57.58 ms 57.58 ms
main           53.55 ms/iter          18.7   (47.32 ms … 73.59 ms) 55.52 ms 73.59 ms 73.59 ms

summary
  v1.0.0
   1.01x faster than main

diff --git a/lock.ts b/lock.ts
index bf49c90..2b5d955 100644
--- a/lock.ts
+++ b/lock.ts
@@ -43,7 +43,11 @@ export class Lock<T> {
    * @returns A Promise that resolves with the result of the function.
    */
   async lock<R>(fn: (value: T) => R | PromiseLike<R>): Promise<R> {
-    using _lock = await this.#mu.acquire();
-    return await fn(this.#value);
+    const lock = await this.#mu.acquire();
+    try {
+      return await fn(this.#value);
+    } finally {
+      lock[Symbol.dispose]();
+    }
   }
 }

I do not know what you have done there, but using cannot work faster than explicitly calling
function getDisposable(): Promise<Disposable> {
	const disposable = {
		[Symbol.dispose]() {},
	};

	return Promise.resolve(disposable);
}

Deno.bench({name: "using", fn: async () => {
	using _lock = await getDisposable();
}});

Deno.bench({name: "Symbol.dispose", fn: async () => {
	const _lock = await getDisposable();
	_lock[Symbol.dispose]();
}})

Deno.bench({name: "try/finally Symbol.dispose", fn: async () => {
	const _lock = await getDisposable();

	try {
	//
	} finally {
		_lock[Symbol.dispose]();
	}
}})

cpu: Apple M1 Max
runtime: deno 1.45.5 (aarch64-apple-darwin)

file:///Users/panda/Documents/deno/sync/using2.ts
benchmark                       time (avg)        iter/s             (min … max)       p75       p99      p995
-------------------------------------------------------------------------------- -----------------------------
using                          659.36 ns/iter   1,516,632.6 (545.24 ns … 839.54 ns) 669.6 ns 839.54 ns 839.54 ns
Symbol.dispose                 412.58 ns/iter   2,423,753.7 (291.03 ns … 539.02 ns) 428.44 ns 531.37 ns 539.02 ns
try/finally Symbol.dispose      415.1 ns/iter   2,409,041.8 (296.53 ns … 528.19 ns) 426.43 ns 446.6 ns 528.19 ns

I'll remove using anyway due to performance concern in Node but it seems using doesn't affect the performance in Deno. Just fyi.
benchmark      time (avg)        iter/s             (min … max)       p75       p99      p995
--------------------------------------------------------------- -----------------------------

group Lock#lock
v1.0.0         52.84 ms/iter          18.9   (45.86 ms … 57.58 ms) 55.68 ms 57.58 ms 57.58 ms
main           53.55 ms/iter          18.7   (47.32 ms … 73.59 ms) 55.52 ms 73.59 ms 73.59 ms

summary
  v1.0.0
   1.01x faster than main

diff --git a/lock.ts b/lock.ts
index bf49c90..2b5d955 100644
--- a/lock.ts
+++ b/lock.ts
@@ -43,7 +43,11 @@ export class Lock<T> {
    * @returns A Promise that resolves with the result of the function.
    */
   async lock<R>(fn: (value: T) => R | PromiseLike<R>): Promise<R> {
-    using _lock = await this.#mu.acquire();
-    return await fn(this.#value);
+    const lock = await this.#mu.acquire();
+    try {
+      return await fn(this.#value);
+    } finally {
+      lock[Symbol.dispose]();
+    }
   }
 }

I measured lock on my implementation and my version wins by 10-15% than the implementation using using or try/finally
	async lock<R>(fn: () => R | PromiseLike<R>): Promise<R> {
		const lock = await this.acquire();
		return await Promise.resolve(fn()).finally(() => lock[Symbol.dispose]());
	}

	async lockTry<R>(fn: () => R | PromiseLike<R>): Promise<R> {
		const lock = await this.acquire();
		try {
			return await fn();
		} finally {
			lock.release();
		}
	}

	async usingLock<R>(fn: () => R | PromiseLike<R>): Promise<R> {
		using _lock = await this.acquire();
		return await fn()
	}

cpu: Apple M1 Max
runtime: deno 1.45.5 (aarch64-apple-darwin)

file:///Users/panda/Documents/deno/sync/using2.ts
benchmark                                time (avg)        iter/s             (min … max)       p75       p99      p995
----------------------------------------------------------------------------------------- -----------------------------
lock release with Symbol.dispose        536.57 ns/iter   1,863,705.3  (446.88 ns … 694.3 ns) 570.59 ns 692.39 ns 694.3 ns
lockTry release with Symbol.dispose      697.2 ns/iter   1,434,314.2    (506.6 ns … 2.21 µs) 706.4 ns 2.21 µs 2.21 µs
usingLock release with using            704.44 ns/iter   1,419,560.7    (526.5 ns … 1.27 µs) 730.83 ns 1.27 µs 1.27 µs

I'll continue on #34


Size of arguments calling poly

I am a little bit confused with the size of attribute using a vector of polygons:
using GLMakie
P = [Polygon([Point2(rand(), rand()) for _ = 1:3]) for k = 1:2]
poly!(P, color = [:red, :green], strokecolor = :blue, strokewidth = 1)

works fine. Surprisingly, choosing one different color by triangle
poly!(P, color = [:red, :green], strokecolor = [:blue, :red], strokewidth = 1)

produces an error. Is it the expected behavior?
Thanks!

Hm, guess strokecolor isn't handled correctly by the multi poly recipe...

Not sure it is a related issue.
Since update 0.16.1, the following instructions produce a strange error
using Makie, GLMakie

y, z, sizes = rand(10), rand(10), 30 * rand(10)
f = Figure()
Axis(f[1, 1])
scatter!(y, z,  markersize = sizes, marker = :circle)

ERROR: UndefVarError: x not defined
Stacktrace:
  [1] (::GLMakie.GLVisualize.var"#51#52"{Vec{2, Float32}})(xs::Vec{2, Float32})
    @ GLMakie.GLVisualize $HOME/.julia/packages/GLMakie/oDJ8D/src/GLVisualize/visualize/particles.jl:292
  [2] iterate
    @ ./generator.jl:47 [inlined]
  [3] _collect(c::Vector{Vec{2, Float32}}, itr::Base.Generator{Vector{Vec{2, Float32}}, GLMakie.GLVisualize.var"#51#52"{Vec{2, Float32}}}, #unused#::Base.EltypeUnknown, isz::Base.HasShape{1})
    @ Base ./array.jl:744
  [4] collect_similar
...

Sorry not to be able to investigate further, thanks.

It seems that this line
particles.jl
should be replaced by
map(x -> f * x, xs)

Btw, the original problem does not seem to be resolved in Makie 0.16.1
using GeometryBasics, GLMakie
f = Figure(); Axis(f[1, 1])
P = [Polygon([Point2(rand(), rand()) for _ = 1:3]) for k = 1:2]
poly!(P, color = [:red, :green], strokecolor = [:blue, :red], strokewidth = 1)

ERROR: Buffer vertex does not have the same length as the other buffers.
	color has length 2
	vertex has length 9
	valid_vertex has length 9
...

It seems that this line
particles.jl
should be replaced by
map(x -> f * x, xs)

Oh good catch. Do you want to make a pr for this?


Enable more thorough tests

As part of issue #258, noticed that the tests currently running are not covering all options. at that case it was python3 with both pymongo and pyexecjs
In order to enable it, I would suggest the following changes only to tox.ini:
envlist = pep8,{py27,py33,py34,py35,pypy}-{, pymongo}-{, pyexecjs}
For example on py27, the following environments will be checked:

pep8,py27
pep8,py27-pymongo
pep8,py27-pymongo-pyexecjs
pep8, py27-pyexecjs

Option 1 and option 3 are currently not covered.
since option 3 is the more important one and we do not want option 1 we can do:
envlist = pep8,{py27,py33,py34,py35,pypy}-{pymongo, pyexecjs}-{pymongo ,pyexecjs}
@srinivasreddy  what do you say?

In light of pull request #265 I am closing this issue


[DO NOT MERGE] Adding JobAgents API with Identity support to version 2023-05-01-preview

ARM API Information (Control Plane)
Changelog
Add a changelog entry for this PR by answering the following questions:

What's the purpose of the update?

[ ] new service onboarding
[x] new API version
[ ] update existing version for new feature
[ ] update existing version to fix swagger quality issue in s360
[ ] Other, please clarify

When are you targeting to deploy the new service/feature to public regions? Please provide the date or, if the date is not yet available, the month. We plan to deploy to Canary ASAP to support Portal testing.  Full deployment/release is planned for August 2023.
When do you expect to publish the swagger? Please provide date or, the the date is not yet available, the month. August 2023.
By default, Azure SDKs of all languages (.NET/Python/Java/JavaScript for both management-plane SDK and data-plane SDK, Go for management-plane SDK only ) MUST be refreshed with/after swagger of new version is published. If you prefer NOT to refresh any specific SDK language upon swagger updates in the current PR, please leave details with justification here. N/A

Contribution checklist (MS Employees Only):

[x] I commit to follow the Breaking Change Policy of "no breaking changes"
[x] I have reviewed the documentation for the workflow.
[ ] Validation tools were run on swagger spec(s) and errors have all been fixed in this PR. How to fix?

If any further question about AME onboarding or validation tools, please view the FAQ.
ARM API Review Checklist

Applicability: :warning:
If your changes encompass only the following scenarios, you should SKIP this section, as these scenarios do not require ARM review.

Change to data plane APIs
Adding new properties
All removals

Otherwise your PR may be subject to ARM review requirements. Complete the following:

[x] Check this box if any of the following apply to the PR so that the label "ARMReview" and "WaitForARMFeedback" will be added by bot to kick off ARM API Review.  Missing to check this box in the following scenario may result in delays to the ARM manifest review and deployment.

Adding a new service
Adding new API(s)
Adding a new API version
-[x] To review changes efficiently, ensure you copy the existing version into the new directory structure for first commit and then push new changes, including version updates, in separate commits. You can use OpenAPIHub to initialize the PR for adding a new version. For more details refer to the wiki. Note that this doesn't apply if you are trying to merge a PR that was previously in the private repository.

[x] Ensure you've reviewed following guidelines including ARM resource provider contract and REST guidelines. Estimated time (4 hours). This is required before you can request review from ARM API Review board.

[x] If you are blocked on ARM review and want to get the PR merged with urgency, please get the ARM oncall for reviews (RP Manifest Approvers team under Azure Resource Manager service) from IcM and reach out to them.

Breaking Change Review Checklist
If you have any breaking changes as defined in the Breaking Change Policy, request approval from the Breaking Change Review Board.
Action: to initiate an evaluation of the breaking change, create a new intake using the template for breaking changes. Additional details on the process and office hours are on the Breaking Change Wiki.
NOTE: To update API(s) in public preview for over 1 year (refer to Retirement of Previews)
Please follow the link to find more details on PR review process.
DsMainDev PR: https://msdata.visualstudio.com/Database Systems/_git/DsMainDev/pullrequest/1069639?path=%2FSql%2Fxdb%2Fmanifest%2Fsvc%2Fmgmt%2FWebApiHosting%2FARM%2FV20230501%2FJobAgent%2FExamples%2FCreateOrUpdateJobAgent.json

Hi, @rayboyd30, For review efficiency consideration, when creating a new api version, it is required to place API specs of the base version in the first commit, and push new version updates into successive commits. You can use OpenAPIHub to initialize the PR for adding a new version. For more details refer to the wiki. Or you could onboard API spec pipeline

@rayboyd30, kindly follow this guidance to recreate the PR with an existing latest API as the first commit. Then set WaitForARMFeedback(or remove ARMChangesRequested) label for review.

/azp run

@rayboyd30 Please fix CI checks errors (LintDiff, Avocado), you can refer to this comments or  https://aka.ms/ci-fix on how to fix it.

PutRequestResponseSchemeArm reporting error is a false alarm. We will investigate this further. The PR assignee can ignore this specific failure.

PutRequestResponseSchemeArm reporting error is a false alarm. We will investigate this further. The PR assignee can ignore this specific failure.

@rkmanda If you think LindDiff error is a false alarm, please add label Approved-LintDiff in this PR.

Hi, @rayboyd30, For review efficiency consideration, when creating a new api version, it is required to place API specs of the base version in the first commit, and push new version updates into successive commits. You can use OpenAPIHub to initialize the PR for adding a new version. For more details refer to the wiki. Or you could onboard API spec pipeline

@rayboyd30, kindly follow this guidance to recreate the PR with an existing latest API as the first commit. Then set WaitForARMFeedback(or remove ARMChangesRequested) label for review.

@rayboyd30 Please resolve the comments. After solving, please add label WaitForARMFeedback (or remove ARMChangesRequested).

@jeremyfrosti @rayboyd30 @rkmanda why is this PR marked donotmerge again?


ByteBuffer and Protobuf

This is a novice question but I wanted to know if I download the latest source of protobuf.js is it safe to use the ByteBufferAB.js from the externs directory of protobuf.js-master.zip or do i have to download that separately ?
Thanks,
H

Thank you so much!


Unclear error message when auto-detecting a module that does not support SLSC Switch in its NVMEM

Describe the bug
While configuring an SLSC Switch Module, we would like to be able to click on the Autodetect button in order to query the SLSC Switch module for its properties (Model, Resource, and Topology), and list of endpoints.  However, not all modules define the /switches area (or information in the legacy /capabilities format) in their NVMEM. For these modules, it is unclear how to proceed.
To Reproduce
Steps to reproduce the behavior:

Open a System Explorer session in Veristand, add an SLSC Chassis with a valid IP address.
In the Modules section, select the SLSC Switch for one slot that you know is populated with an SLSC Switch module that does not contain the /switches area, e.g. the first revision of the 1225x modules.
Select the newly-configured Slot # (SLSC Switch) in the left tree within the System Explorer.
Click on the Autodect button at the top and note the resulting error.

Expected behavior
On step 4, we expect the fields to be populated (Model Number, Resource Name, and Topology) to match the module in that slot. If it cannot be automatically populated, we expect a more helpful error message indicating how to proceed.
Screenshots

Desktop (please complete the following information):

OS: Windows 10
Veristand 2017+, with the Routing and Faulting as well as the SLSC Switch custom devices installed.

Additional context
Add any other context about the problem here.

If we detect the module is present, we could potentially provide some enhanced workflows to help the user. For example, if we detect a 1225x module that is incompatible with SLSC Switch, we could offer to (or automatically) load the offline definition from disk.


Consistent units for total gas mass

Initial sigma plots seemed to be orders of magnitude higher than expected, possible conversion missing.
In the model script in "src/model.jl", in ParametersStandard, I ended up putting in (r_c * AU)^2 instead of r_c^2.
In DJ_plot_walkers.py, changed Standard registered keyword "logSigma_c" to "log_M_gas"
[report contributed by J. Pegues.]

Seems to be fixed by #39


Add workflow with actionlint

This will keep a sharp eye on all actions. Including itself!
source

@johnbillion Please enable actions.
I am planning to enable Dependabot to keep actions up-to-date.

Yes please to actionlint. No thanks to Dependabot, I find it too noisy.


IE11 issues that seem to be unsolvable

@tejacques, sorry to bother you again, but we just found the most weird/bizarre issue in IE...
With a piece of code as simple as this, running in the body/head (not on document ready):
http://jsfiddle.net/Ls3fbefj/1/
IE11 doesn't execute the unload function, only the beforeunload when refreshing while still loading (again hitting that sweet spot, since this doesn't happen all the time).

See the highlighted part.
I'm not sure how this can be solved, since beforeunload is a cancelable event (like I explained in https://github.com/tejacques/crosstab/pull/31#issuecomment-113064771) we wouldn't be able to resume the keepaliveLoop.
Two things came to mind:
Solution 1:
The crosstab beforeunload function does what we are doing (canceling any setTimeout loop that might be executed at the end of the program stack) and at the bottom of the function we try to resume it in the next TAB_TIMEOUT like:
// code that is in beforeunload

// try to resume after `TAB_KEEPALIVE` time if the tab is still alive...
window.setTimeout(function() {
    crosstab.stopKeepalive = false;
    keepaliveLoop();
}, TAB_KEEPALIVE);

I believe this solution will be problematic if the user takes TAB_KEEPALIVE time to say yes or no in the confirmation box of the example I posted in https://github.com/tejacques/crosstab/pull/31#issuecomment-113064771 and I'm not sure here if the code will execute or not (at least consistently against all modern browsers).
Solution 2:
We only start crosstab on document ready, wrapping the code near https://github.com/alias-mac/crosstab/blob/18ef65b8c471eb1bc5f634f73d700c3583f3af15/src/crosstab.js#L687:
document.addEventListener("DOMContentLoaded", function(event) {
  // ---- Setup Storage Listener
  // the rest of the code
});

We need to check if this would work normally on all browsers and if IE really executes the unload if the DOM is reported to be loaded (need to run some tests if you decide to go this way).
Most the browsers also support this on document ready:
http://caniuse.com/#search=DOMContentLoaded
There is still one problem with the frozen tabs even with any of the solutions posted above, when the browser crashes.
If the browser crashes, the localStorage is maintained in it's last state (unless you have IE11 again and some weird settings - see http://stackoverflow.com/questions/24489542/localstorage-resets-in-ie11-after-closing-browser).
In this event, how will we recover from frozen tab? Because we will try to ping the master tab that is gone (it was the window/tab that crashed).
Let me know which solution you think it is better or if we should drop frozen tab and find a different solution (like fallback to take over as the master tab and just resume everything - this will basically mean that if crosstab isn't supported, it will assume it is master all the time and broadcast to itself, right?).

Thanks for the continued thorough testing. The DOMContentLoaded approach can potentially add a significant latency, which I'd rather avoid if possible. This is especially apparent in requests that use tricks like flushing the head to load and execute scripts while generating the page.
This will require a lot of specific testing, but a dual strategy might work, wherein once the DOMContent is loaded, the cleanup of the keepalive loop is added as a listener to the unload event, and removed from the beforeunload event, as well as also ensuring the keepalive loop is running.
This seems to work on IE11 in a simple test case:
<!doctype html>
<html>
    <head>
        <title>Testing</title>
        <script>
            window.addEventListener('DOMContentLoaded', function () {
                console.log('DOMContentLoaded');
            });
            window.addEventListener('beforeunload', function () {
                console.log('beforeunload - cancel refresh loop');
                window.addEventListener('DOMContentLoaded', function () {
                    console.log('restart refresh loop');
                });
                return "Are you sure?";
            });
            window.addEventListener('unload', function () {
                console.log('unload - cancel refresh loop');
            });
        </script>
    </head>
    <body>
        <script src="//path/to/a/script/that/loads/really/slow.js"></script>
    </body>
</html>

Here's the chain I am seeing:
If the page is left before the DOM content is loaded, only the beforeunload event fires. If the page fully loads before it is left, beforeunload, and unload fire. If the page is left before the content is loaded, but is cancelled, the DOMContentLoaded event will fire once the page finishes loading.
I believe setting it up as described above should work, but requires more testing on various browsers.

As for your second question about frozen tabs -- I've been thinking about the proper solution for quite some time, but I think I've finally settles on the following:
When a tab starts up, assume (but do not announce) that it is master, and trigger the become master event locally, at the same time broadcast a ping to all other tabs listening asking for the current state. All tabs respond with a pong with their id as well as the id they believe is master. The newly started tab demotes itself from master as necessary.
The upside is that there is no longer any frozen tab state. If a tab is isolated, it simply believes it is master, and continues along happily. The downside is that it will attempt to do any connection or master tab setup every time a new tab is opened, and downgrading from master becomes a necessary component to handle. Another downside is that because it doesn't know who the master should be and initial requests the tab may have of the master will have some additional latency added. That said, it seems like the best overall approach as it would allow removing any mobile specific restrictions as well as the entire concept of a frozen tab.

@tejacques, thanks for the fast reply.
I'll do some testing this weekend.
For your second comment about the frozen tab, I think the problem is that if the tab promotes itself to be the master, then it might slow things down.
E.g.: if we are doing a socket connection every time a tab is promoted to be the master, that means that each tab (every time it opens) will have to do that connection and the other tab that was demoted will have to disconnect.
Other logic might apply (when the tab becomes the master) that can have some performance degradation.
May I suggest to apply that logic that you said about believing that the tab is the master and notify everyone else, only when a timeout occurs?
This would allow the reuse of the master tab if it replies on time, and promote itself if the master is too busy and doesn't reply (either on time or never).
The master will have 2 messages in the queue, the PING and the tab (now) promoted.
We already handle the fact that a PONG doesn't make sense to be sent (it is too late to reply): https://github.com/tejacques/crosstab/blob/master/src/crosstab.js#L705
This means that during the setup (until setupComplete event), which is the most likely to trigger a frozen tab detected event, we would take over any master tab that is no longer active and wasn't able to communicate that properly (due to crash or any other problem, like the IE11 not notifying the other tabs on unload).
It also handles the problem of only one of the tabs crashed and not the entire browser (in this particular case, the master tab crashed), then one of the tabs that is trying to broadcast to master and master isn't replying (after timeout), will automatically notify that master is dead (like we currently do in var deadTabs = util.filter(util.tabs, notAlive);).
Potencial problems:
If the 2 tabs ping the master at the same time and the timeout occurs at exactly same time, can potentially try to notify that master is dead twice. At this point, I think we can rely on the fact that it is single threaded, so 2 messages are going to be saved in localStorage and both with be read consecutively.
I think this is no different from the current implementation of deadTabs, since we are triggering duplicated tabClosed events with the same tab id, if 2 tabs executed that keepalive part of var deadTabs = util.filter(util.tabs, notAlive);) at the same time (each tab is single threaded, but they run that same code concurrently and send messages about those tabs).
I'm not sure if this is by design or if if the deadTabs code was meant to be executed by the master tab only (since it is the one that will - at the end - write those tabs).
I'll make a PR soon with what I have in mind so we can further discuss.

The tradeoff there is also latency. The current design reads the master tab info from localStorage, and PINGs, however it skips this step if it believes it does not have a frozen tab environment (I.E. Some tab successfully had a handshake with the master tab on this domain). This means the price of that handshake is paid only once. If the frozen tab state is removed and each tab tries to handshake every time it starts up, this adds an appreciable amount of latency, especially in the case where the handshake fails because this is the first tab. The main problems with the current frozen tab state design is that mobile does not work at all (even though it could benefit from iframes), and there is no recovery attempt. Removing the state would allow all platforms to behave similarly. There may also be a middle ground here where we can limit the scenarios it needs to handshake, such as repurposing the frozen tab state to mean that it should PING but assume it will fail and behave as I described, but if it is not set it PINGs and assumes it will succeed.
Typed this on my phone so hopefully it's clear enough. This particular part is probably the most complicated of the entire library, so getting it right will be tricky.

@alias-mac Are you still interested in adding this? (proper unload handling). I've verified that the outlined solution should work on all supported browsers -- I can add it in this week but wanted to make sure you're not working on it already.

@tejacques we are working on it, and our QA is testing across all browsers. It seems that this solution (with the beforeunload that you proposed) is still causing some issues on iPad. We are trying to see what the problem might be.

@tejacques it seems that crosstab.supported says that it is true on iPad but it isn't?
Can you confirm which browsers you support on this lib?

@tejacques, sorry for the spam. One more update.
We were trying to solve this with pagehide event that exists on iOS devices, but that (like IE11) doesn't trigger unless the dom was fully loaded, meaning that we can't dispose crosstab correctly unless we only start it on DOMContentLoaded.
Do you plan on adding iOS safari devices to the isMobile, so that crosstab.supported is false in this case?
Based on our previous comments (above) I really don't see how we can avoid this frozen tab env problem without taking over the master tab when it is unresponsive.

Posting here the code that I'm using to test this:
<!DOCTYPE html>
<html>

<head>
<script type="text/javascript" src="path/to/crosstab/src/crosstab.js"></script>
<script type="text/javascript">
    window.addEventListener('beforeunload', function (e) {
        console.log('beforeunload - cancel refresh loop');
        var confirmationMessage = "Are you sure?";
        (e || window.event).returnValue = confirmationMessage;
        return confirmationMessage;
    }, false);
    console.log('events added');
</script>
</head>

<body>
    <script type="text/javascript" src="path/to/script/with/10/sec/sleep"></script>
</body>

When I tested it was on the browsers listed on the readme (desktop only). All mobile type browsers (tablets/phones/etc.) should currently have crosstab as not supported. If some browsers like safari iPad aren't caught in the isMobile check, that should be updatedable to . Let's open a separate issue to tackle that.
In version 1.0.0 the goal is to have a graceful fallback to local-tab-only broadcasted events when broadcasting to other tabs is unavailable, but broadcasts should work on mobile across iframes in the same tab.

@tejacques chrome on android is working though (at least it seems so).
In that case I'm going to update this PR to remove the console.log() and wait for you to bump the version. Thanks!

There's nothing inherent in any of the mobile browsers on a single page that make this not work -- it's the behavior when you have multiple tabs open on mobile browsers that break it, since JavaScript will only run on the active tab. Detecting those and setting frozenTabEnvironment to true is just a way to say it's not supported at the moment.

@tejacques can you add that diff here (or add the commit on the PR)? I'm not sure I understand what is the change. Thanks

@tejacques I'm having a bit of trouble stubbing some methods to do some automated testing on this PR.
I was thinking about stubbing unload and swapUnloadEvents so I could test the abort use case.
Since the setup will already fire a DOMContentLoaded, I won't be able to check that the swap was done by DOMContentLoaded event.
If you are ok on just checking that after DOMContentLoaded all is setup correctly and don't add unit tests for the cancel behavior, then I'll just add what I have to the current PR.
Thanks!

I'm fine with that. The only way you could test DOMContentLoaded things is by using iframes. I think it's possible but that's a rarer case so I'm not as worried about it for now.
I'm on my way home now, will point out what I changed to avoid the race condition for the double loop.

@tejacques cool in that case I just need to know how can I restore the loop so it doesn't blow the next tests.
I have the following test:
// first test
window.dispatchEvent(new Event('beforeunload'));
// test that nothing changed and crosstab.stopKeepalive is still false

// second test
// spy on `util.events.destructor`.
window.dispatchEvent(new Event('unload'));
// test that crosstab has stopped running.
// `util.events.destructor` was called.

if the tests are added in the bottom (and kept there) there is no problem (I think), but if we add more tests after these, crosstab broadcast messages will never run.
Are ok on keeping the bottom tests to be always tested after crosstab is destroyed? If not, can I make restoreLoop to be public (specially after your suggested change that will make sure that even if called multiple times it will always avoid N loops)?

Here's the commit: 03f7d0dcb8530e08ef5eedb51f29bb0599e3523b
Basically, if you call keepaliveLoop() now it will just do a keepalive, if crosstab.supported && !crosstab.stopKeepalive. It won't spin up a new loop - there's just one persistent loop.

Ideally all of the tests should be able to run in any order. There's two ways around it:

You can just set crosstab.stopKeepalive = false, because now with my other change, the loop doesn't actually stop, it just doesn't execute anything when it's false.
You could run these tests inside an iframe. You can view some of the other tests that do this to see how it's done: https://github.com/tejacques/crosstab/blob/master/test/test-crosstab.js#L198-L228

The second option is safer because the changes are sequestered in their own iframe, but if you do go for the first option, just make sure to set it back to true after the test whether or not it succeeds.

@tejacques I added the unit tests and with some console logs around the main functions that we want to track I got:
setup during load
unload
trying to restore - swaping events
running again
      ✓ should stop on beforeunload event and recover when canceled
trying to restore - swaping events
unload
      ✓ should stop on unload event after DOMContentLoaded event

which indicates that all is being tested as expected.
Let me know if you find anything that should be changed.
Thanks again for all the help on this!

Thanks for putting this together @alias-mac -- I will test tonight and merge if all looks well.

@tejacques, let me know when we can have this on the next release version, so we can use it.
Thanks.

@alias-mac: didn't merge yesterday since it was late, but passed all sauce tests and looks good :+1: -- will launch updated version today.

Thanks once again for all the help @tejacques.
Looking forward to discuss in another ticket and see the possible solution we talked above (https://github.com/tejacques/crosstab/pull/32#issuecomment-115966098) to avoid the frozen tab.

Thank you for the contributions. This is now live on npm.
I have something I'm putting together for better support/phasing out frozen tabs using PageVisibility on mobile browsers. For browsers that don't have it, they will treat each window/iframe as it's own isolated master.


Easier way to see preprocessing results

The log file is useful for people who can read it, but it would be useful to have the number of sequences matched and number thrown out readily available. That way users can see at a glance if the wrong barcodes were used or wrong barcode direction.

I think this is solved by the new artifact summaries, is that sufficient? If so, can you close this issue? If not, could you give suggestion of what's missing? Thanks.


Fix examples: comments start with #, not //

See https://github.com/prometheus/prometheus/issues/683

Thanks :+1:

@stapelberg Thanks and sorry for the breakage!


Fix the Add Expenses button.

On click, it should create a new group containing all the details of the expense.

Hey ,I would like to work on this issue.

@priyanshu68 Sure. I'll assign this to you.


Add gcm service

Have you checked if this is already in demo branch? The idea is that no commented code goes here, just the necessary (and all the necessary) to start. To see examples, and copy common code (but not so common to have it always), the demo branch was created for.

In my opinion it's not a demo feature, it is a project feature and it is common in all project with gcm. I think we can save it in this branch (delete the pull request) and if we need it we can pick the commit.Another option is delete the branch but gcm is a common feature in all android projects. As you wish @bryant1410!

We can have it in the demo for sure (don't remember if it is right now). This is not in 100% of the projects, so I prefer to leave it aside. It could be cherry-picked from demo project anyway.

:+1:


React.DOM.noscript Warning

First up, thanks for helping push this library forward!
Just wanted to make you aware of this new warning as I didn't see an open issue about it. Hopefully this will be of some help.
Summary:
As of React 15.6, there is a deprecation warning when accessing React.DOM factory helpers. Here's the warning in full:
Warning: Accessing factories like React.DOM.noscript has been deprecated and will be removed in v16.0+. Use the react-dom-factories package instead.  Version 1.0 provides a drop-in replacement.

The usage can be seen here: dist/react-modal.js line 173
Steps to reproduce:

Use the latest React version (15.6.0) with the latest React-Modal version (1.9.4).

Hi @andrewjmead, there is PR #410 (what you are looking for) and #395. Do mind review both PRs?

Yes. This is my fault. I looked though the issue list, but I failed to look though the PR list.

Awesome. I'll release a new version with #410.

Thank you so much @andrewjmead! Released v1.9.6.

Very cool. Thanks for your work. I've been using react-modal for years and would love to get a little more involved. See you around!

Awesome. Appreciate your help. We are close to get v2.0.0 merged, I'm trying to get the last PRs reviewed and merged to finally merge #412.


#! Add @Experimental for easier API evolution

Here you go :) Feel free to make changes to this branch before merging.


Cors proxy is running out of free quota on heroku

The cors proxy is currently running on the heroku free tier.  It's running out of monthly quota.  I didn't include a whitelist that prevents other domains from using it, so it might be spam or it might just be how heroku's usage works.  Apparently the free tier doesn't have any monitoring, so I can't determine if all the usage is legitimate.  And heroku's paid tier doesn't have any billing limits, so if I attach a credit card number I could suddenly get hit with a large bill.  It's not inspiring a whole lot of confidence in heroku.
Anyway the monthly quota is going to reset tomorrow, so a short term fix is not needed.
Google analytics does show that traffic to the site has grown this month.  So the increase in traffic could be organic, and heroku's free tier might just be severely limited.
I'm thinking that the long term solution is to write a simple cors proxy in python and host it on the GAE free tier.

Well this is embarrassing.  So today I built a working CORS proxy in python, and deployed it to GAE.  And then it turns out that NOAA fixed their CORS issue.  I searched through the code, and that was the only place that needed a CORS proxy.
fixed w/ commit: 36f3ea9e316ca2e4daa1275295c3547f14b8af53


yield is repeated two times and match whitespaces before yield

syn keyword pythonStatement     pass yield

syn match pythonStatement       '\s*\([.,]\)\@<!\<yield\>'

With current state it is matching whitespaces before yield. Do not recognizable if you have simple color theme, but if you have underline or bg(for pythonStatement) different from Normal - it will be noticeble.
And with new update we have
syn match pythonStetement '\s*[.,]\@<!\<yield\>'
Why do we even need this syn match beside syn keyword? Describe please.
If so i really think it should be something like this
syn match pythonStatement '\(\s*[.,]\)\@<!\<yield\>' But i'm still not sure why do we need this.

It was probably added because it was being highlighted for class methods.
It should be implemented for every keyword if we really want this feature.


Fix: getCollection() Collection can be stuck with an empty collection, if getCollection() is called too quickly

getCollection() has an unexpected behavior that appears when the collection in question hasn't yet been registered by the ddpClient. If that's the case, the getCollection() will fall back to an empty object. That empty object is then cached forever in the Collection result, and subsequent find() and findOne() requests will always fail. This causes the Core-Integration collection to behave in a different manner from a Meteor collection.
This changes that behavior in that collection.find() will always try to get the collection from ddpClient on each execution, only falling back to an empty object if not found.

Thanks @jstarpl, that must have been a tricky edge-case to find..
Your fix looks good, I'll get this published asap!


remove unnecessary Copy trait of Tz and EvalConfig

What have you changed? (mandatory)
Fix issue: https://github.com/tikv/tikv/issues/4341
plenty of functions read Tz and use it to construct a correct Time by copying them so does EvalConfig. No need to copy, just take ownership or use references. But using reference is hard now...
There are too many signatures to modify and it is likely to break lots of API.
What are the type of changes? (mandatory)

Improvement (a change which is an improvement to an existing feature)
reduce the number of Tz copy in the stack.

How has this PR been tested? (mandatory)
make test already.

/run-integration-tests


Create Hebrew translation

This plugin is no longer developed. You can help me with the translation of plugin.video.zattooHiQ.
Thank you


Davis, KIBA, DTC, Metz, and ToxCast

Regarding the Davis, KIBA, DTC, Metz, and ToxCast datasets, could you please guide me to where I can find the prediction results using AlphaFold? I have delved deeply into your work and understand its immense value for drug discovery. Compared to the current cutting-edge algorithms, yours stands out as the most significant. As a newcomer to the research field, I sincerely hope for your guidance and response to my queries.

You can find the Alphafold2 contact maps which we use for training the graph neural networks, by downloading the data as mentioned in the readme from  here and to download alphafold2 structures for datasets which we didn't use in our project, you can find them with a PDB_ID or UniprotID, you can download from here and use our code here to get contact maps from the Alphafold2 predicted structures in the PDB format.


TF operator UI not showing jobs

I am using kubeflow v0.3.0-rc3. I create a TF job but unable to see it in the UI (going through ambassador):

It seems that the namespace is set to test, and the tf job I created is in kubeflow, but I am unable to change the namespace in the UI.

Dashboard logs show the following error
ERROR: logging before flag.Parse: W1005 05:26:22.181074       1 api_handler.go:127] failed to list TFJobs under all namespace(s): tfjobs.kubeflow.org is forbidden: User "system:serviceaccount:kubeflow:tf-job-dashboard" cannot list tfjobs.kubeflow.org at the cluster scope: Unknown user "system:serviceaccount:kubeflow:tf-job-dashboard"

Looks like a bug in the clusterrolebinding for TFJob dashboard
kubectl get clusterrolebinding -o yaml tf-job-dashboard
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  annotations:
    ksonnet.io/managed: '{"pristine":"H4sIAAAAAAAA/3yOsU7DQBBEez5jascoHXIHFPRBokEUe+c12fhye9rbCxKW/x1FQAVJN9LT07wFVOSFrYpmDLBAsafmezX5JBfN/XxXe9Hb0zaw0xYdZskjBjymVp1tp4kfJI+S39HhyE4jOWFYkChwqudFpWCAT5uDhs1IdR+UbMTaIdORLyDTxDuevn15Mm3lWuC/Ybj6UFs4cPSK4XX5lZ/ZThL5PkZt2f/4WtjI1X5ALRTPdG6Bp6QfWN/Wmy8AAAD//wEAAP//lKVwVVMBAAA="}'
  creationTimestamp: 2018-10-04T05:18:39Z
  labels:
    app: tf-job-dashboard
    app.kubernetes.io/deploy-manager: ksonnet
  name: tf-job-dashboard
  resourceVersion: "2716"
  selfLink: /apis/rbac.authorization.k8s.io/v1/clusterrolebindings/tf-job-dashboard
  uid: f3fdf76e-c794-11e8-93e6-42010a8e0003
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: tf-job-dashboard
subjects:
- kind: ServiceAccount
  name: tf-job-operator
  namespace: kubeflow

We're binding the wrong service account.

i have the same problem,pls help ..


Feature: Accessible Error Messages

Prerequisites:

Is the functionality available in the GitHub UI? If so, please provide a link to information about the feature.

No, this is for users of this app and is not related to GitHub directly.
New Feature
When something goes wrong with applying the settings for any reason, it would be incredibly useful to be able to see what went wrong in an effort to diagnose the issue. I'm currently in a position where my settings are not being applied and I can't tell why they aren't working . I've applied all the fixes and workarounds I've been able to find in other open issues. I basically have no path forward right now beside trial and error. Being able to see what is going wrong would also likely reduce the number of issues reported here, or at least make them easier to triage.
If this does exist somewhere a quick line in the readme or some other doc describing how to view the diagnostics would be immensely helpful.

GitHub has a suboptimal logging experience, especially for background apps.  The Audit Log feature could be used i errors were produced to the audit log as audit events.  This might mean treating errors differently, but is one option with the limited functionality in GitHub.

I'd find this very useful too. Renovate posts some error into a github issue on the affected repos, I wonder if that could be a way forward?


EVAL not allowed by default

Template::Mojo can't be installed for now because it use EVAl without use MONKEY-SEE-NO-EVAL

Looks like it got fixed by #23, closing. Thanks for reporting though :)


Use ConfirmationDialogs instead of custom buttons

This changes the order to Cancel - Accept, which is more standard. The labels of the buttons and disabling them on invalid input is not changed.

The order Godot uses is OK - Cancel, so I'm sticking to that.

Well, the addon could set swap_ok_cancel in the ProjectSettings to true.

I don't think setting a user defined variable would be a good idea. It would be best if the plugin would read said variable and adjust accordingly.

I don't think setting a user defined variable would be a good idea. It would be best if the plugin would read said variable and adjust accordingly.

That is the case with this PR. If the user sets swap_ok_cancel to true, the Create button will be the first.

Oh I think I see the confusion!
Ok - Cancel is standard on Windows.
You're running Linux, are you not?

Oh I think I see the confusion!
Ok - Cancel is standard on Windows.
You're running Linux, are you not?

Yes. I think it is set automatically depending on the OS.

Thanks! I was already deep in redoing the system, so I was afraid of merging at this point.
I implemented the features you wished to add. :)


Add License?

Looks like kap is MIT, but didn't want to assume the same for this project? Thanks.

You're right, it's the same license as Kap. I've added the license now, thank you! https://github.com/wulkano/aperture.js/commit/0664ec466ebc055f7325fa0489b822d88246ea06


Stub for timePosition atoms

Avoid a warning in the LV2 log until we implement delay/time opcodes.

Sure, let's make it an issue as a reminder.


[Bug]: Sync on save triggering ‘Running in stage’ notification

What happened?
Exactly what the title says. Maybe disable the notification if it is caused by sync on save and only have it show if it’s a manual sync.
Everything else is working perfectly in the plugin as far as I can tell. Glad I switched to this one.
What OS are you using?
iOS (iPhone, iPad)
What remote cloud services are you using?
OneDrive for personal
Version of the plugin
0.4.11
Version of Obsidian
1.4.16
Using password or not

[X] Yes.

Ensure no sensitive information

[X] I ensure that no sensitive information is submitted in the issue.

Fixed in 0.4.12


Add columns to CSR

When we want to attach just a weight array to an already an existing array, there should perhaps be a new UDF to attach just a new array for the weights. Currently you would have to recreate the entire CSR

Closing this, recreating the CSR is quite easy an created on-the-fly anyway in the current implementation


Segmentation fault in ecma_builtin_number_prototype_object_to_fixed

Jerry version:
Checked revision: ce18704
Build command: ./tools/build.py --clean --debug

OS:
Ubuntu 16.04.3 LTS

Test case:
parseFloat(Number.MAX_VALUE).toFixed(5);

Backtrace:
Program received signal SIGSEGV, Segmentation fault.
0x0000000000447bc3 in ecma_builtin_number_prototype_object_to_fixed (this_arg=393, arg=80)
    at jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c:648
648 } /* ecma_builtin_number_prototype_object_to_fixed */
bt
#0  0x0000000000447bc3 in ecma_builtin_number_prototype_object_to_fixed (this_arg=393, arg=80) at jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c:648
#1  0x3834323134383136 in ?? ()
#2  0x0000003836333835 in ?? ()
#3  0x000000010096c0f0 in ?? ()
#4  0x00007fffffffcd2c in ?? ()
#5  0x0000003d00000189 in ?? ()
#6  0x00007fffffffcb20 in ?? ()
#7  0x000000000045e84e in ecma_builtin_dispatch_routine (builtin_object_id=<error reading variable: Cannot access memory at address 0x323034303430352e>, builtin_routine_id=<error reading variable: Cannot access memory at address 0x323034303430352a>, this_arg_value=<error reading variable: Cannot access memory at address 0x3230343034303526>, arguments_list=<error reading variable: Cannot access memory at address 0x323034303430351a>, arguments_number=<error reading variable: Cannot access memory at address 0x3230343034303522>) at jerryscript/jerry-core/ecma/builtin-objects/ecma-builtins.inc.h:91
Backtrace stopped: Cannot access memory at address 0x323034303430353a

Found by Fuzzinator

I'll check it.

Fixed by #1994


Unlike mp4decrypter and aria2c, there is no check for ffmpeg.

It throws the error when merging audio video but if there is an error it doesn't stop the execution it just ignores and starts downloading the next video

This is so we can continue to download the segments, we don't always know if the error is specific to a lecture or not. I don't feel that quitting the program is thing.

hmm. but the check_for_ffmpeg thing already exists. and if ffmpeg doesn't exists it just throws the ffmpeg not found error and removes the segments as part of cleanup. Actually this happened to me I missed the readme and i downloaded for like 10-15mins but nothing showed in the out_dir, after that when i saw the logs i came to know that ffmpeg was not found.

hmm. but the check_for_ffmpeg thing already exists. and if ffmpeg doesn't exists it just throws the ffmpeg not found error and removes the segments as part of cleanup. Actually this happened to me I missed the readme and i downloaded for like 10-15mins but nothing showed in the out_dir, after that when i saw the logs i came to know that ffmpeg was not found.

Ah, I misunderstood what you were saying, my bad.
Yeah, that's a bug, I'll fix that in the next commit.


Objectives and Key Results OKR

Begin with the end in mind - Steven Covey, The Seven Habits of Highly Successful People
Measure what Matters - John Doerr, Measure what Matters
OKRs are a refinement of a widely used practice of management by objectives (MBO). The difference is that OKRs are a more collaborative process as opposed to a top-down bureaucratic process. Peter Drucker – who first popularized MBO – suggested that a manager should review the organization's goals and then set the worker's objectives. In contrast, OKRs rely on the teams within the organization to take high-level objectives and refine them for each specific area. And if teams have to work with other partners in the organization to reach high-level objectives, those teams might collaborate and write OKRs together to ensure proper alignment. It’s a shift in mindset where the question changes from "were we busy doing the tasks?" to "did we move the needle for our organization to thrive?"
When you want to achieve something, anything, your desires are based on a preferred outcome. It’s a very simple, basic human concept developed at an early age. One way of putting it into a sentence is:
I will ________ as measured by ____________.
This is how John Doerr explained objectives and key results (OKR) in his book Measure what Matters. While it’s a simple concept, the business world is a complex place with many moving parts. Still, by adhering to simple principles, big results can manifest.
A common mistake with OKRs is confusing desired outcomes with actions used to reach objectives.
A popular management strategy that defines objectives and tracks results.
Helps create alignment and engagement around measurable goals.
"When employees perceive their jobs as high in task significance, they display higher job performance."  -- “The Significance of Task Significance: Job Performance Effects, Relational Mechanisms, and Boundary Conditions,” in the Journal of Applied Psychology.
More useful to think about the “OKR process” than it is to just consider the “objective” and the “key result”. Static goals that aren’t regularly reviewed and revised as the operating environment changes quickly become stale and meaningless. Combining clear objectives with a small set of specific, measurable results and a regular process of reviewing progress toward those measures is what makes OKRs truly useful.
Objective: Where do you want to go?
Key results: How do you know you're getting there? How do you measure that progress?

OKRs move teams away from an “output” mindset (“What projects or tasks did we do?”) to an “outcome” mindset (“What was the business result of the project or task?”). You can set OKRs at the beginning of a key time period for your business (like a quarter or a fiscal year) and then check in regularly with those OKRs to keep your team focused on the importance of their work rather than its volume.
"Objectives: are memorable, qualitative descriptions of what you want to achieve. Objectives should be short, inspirational, and engaging. An objective should motivate and challenge the team.
Key results: are a set of metrics that measure your progress towards the objective. For each objective, you should have a set of two to five key results. More than that and no one will remember them." -- Felipe Castro, an OKR coach, author, speaker, and evangelist.
Objective should be concise and engaging, so a team can easily remember it. Next, there should be a small number of metrics to track the key results. These metrics should be something you can measure on a timely basis. If you can only see the results after two years, it’s not possible to review your progress on a quarterly basis.
It’s important to find key results that are leading indicators of your objective, as opposed to lagging indicators. You want results that can be measured regularly and frequently, and lead to the overall objective.
Some high-level objectives are:
Improve customer satisfaction
Increase recurring revenue
Scale system performance
Increase the number of customers served
Reduce the number of data errors in the system
Objectives: Reduce the number of data errors in the system
Key results:
as measured by the number of data quality errors reported to the support desk
as measured by the number of orders that can’t be filled automatically
as measured by the order errors reported by customers
Measure OKRs and communicate progress.
OKRs and agile development
Agile development and OKRs go together perfectly. It's been said that agile development decreases the costs of changing your mind. That’s because agile planning calls for a regular, planned cadence of checking the progress of development, evaluating the context of the enterprise (the competition, customer requirements, regulatory requirements, market conditions), and making adjustments based on this information. Having clearly communicated objectives and key results provides transparency.
A quarterly review can shift from “did we deliver the things we said we’d deliver?” to “did we achieve the objectives we wanted?” Combining those two questions helps an organization decide whether to continue on its path or modify it.
Align top-line OKRs with organization’s mission, vision, and “north star” values. Where OKRs help define the "what" and the "how," vision should enforce the "why."

Objectives should support organizations mission and values, and they should be tightly aligned to long-term and short-term goals.
Principles
Three key principles to provide effective OKR management are:

Connect work and outcomes: Clearly connecting each team's daily work with business goals
Align individuals and impact: Creating a strong culture of employee engagement and growth
Orchestrate the OKR process: Setting up and running personalized OKR programs to meets each team's specific needs

How OKRs add value to an organization

Gives a strategic advantage to organization of any size and can be adopted by individuals in any role. OKRs add value to your organization in the following ways:
Helps organization navigate rapid change, reduce risk, and identify waste. The OKR framework gives a level of visibility into work done across your organization that allows you to proactively manage risk. It helps you identify themes, trends, and changes to diverse data sets that can go unnoticed without a unifying system. Your organization can shift focus from activity to outcomes, making the right changes at the right time to stay competitive.-
Motivates and fosters involvement. When done well and made the driving force behind your organization's strategic rhythm, OKRs can keep every employee connected to and invested in your broader mission.
Creates cross-functional cooperation that unifies initiatives and improves collaboration. When each individual, team, and department goal is guided by the organization's broader strategy, teams can clearly prioritize each project, task, and outcome.
Offers clear, contextual communication with continual progress reviews. The OKR framework doesn’t stop when your goals are written. Instead, it creates a strategic rhythm around the most important outcomes that your organization is pursuing. The OKR framework should influence every interaction and foster continuous improvement in every review process.
Creates clarity that is documented, measurable, and owned. The OKR framework provides accountability that is tracked and measured. This accountability works in both directions: each individual is responsible for their OKRs, and your organization's leadership is responsible for enabling their work.

Examples
Objective 1: Be the top US provider of learning platforms to schools.
Key results:
45 percent of K-12 schools using our platform

A 12 percent increase in student engagement, as measured through internal systems
A 95 percent satisfaction rate from quarterly parent surveys

Objective 2: Build a technology platform that supports every person in our business to innovate and create.
Key results:
Five new applications developed and adopted across the organization
At least two members that use the Microsoft Power Platform on each team
New cloud technologies like data analytics and machine learning introduced in all customer-facing applications

Objective 3: Transform our approach from sales-driven to data-driven.
Key results:
Increasing pipeline coverage from 50 percent to 200 percent
Increasing closing rates for sales engagements by 5 percent
Reducing the time to close deals by 8 percent

Conversations, Feedback and Recognition (CFR)
Use CFR to improve OKR implementation.

Conversation is ‘An authentic, richly textured exchange between a leader and contributor. This is done 1:1s and in Team meetings.'
Feedback is “Communication up, down, and across organizational lines that assess behaviours and outcomes, and guides improvement.”
Recognition is: “Acknowledgement of effort, attitude and achievement.”
-- John Doerr, Measure What Matters

It can be tempting to measure broadly, then cherry-pick the results that seem most compelling. Leaders need to be more specific and discerning when choosing what to measure to improve outcomes. All too often, teams have a long list of things they want to measure, without a clear rationale for why. If they don't decide ahead of time what metrics are most meaningful, everyone will wait for the often-conflicting and unclear results to come in, and then pick their favorite. Suddenly, the choice becomes political, and the loudest or the most senior people win. That’s why work needs to be done ahead of time on deciding how to measure business success. It’s more than just a wish list or defining outcomes; leaders need to know how to prioritize outcomes. Be contextual while choosing good outcome metrics (sometimes known as KPIs).

https://www.youtube.com/watch?v=HiQ3Ofcmo50 John Doerr on OKRs and Measuring What Matters
https://www.atlassian.com/agile/agile-at-scale/okr
https://docs.microsoft.com/en-us/azure/cloud-adoption-framework/strategy/business-outcomes/okr
https://www.forbes.com/sites/joelshapiro/2022/01/31/measure-what-matters-how-to-choose-the-right-metrics
https://www.whatmatters.com/get-examples#Company-Wide

#92


Redundant documentation with Static IP address doc page

IMHO, this page on Egress Traffic (https://docs.microsoft.com/en-us/azure/aks/egress) is 80% redundant with the page on static IP addresses (https://docs.microsoft.com/en-us/azure/aks/static-ip).  Could these pages be reconciled and combined in to one page for simplicity?

Document Details
⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

ID: 10de2de7-9d5a-b791-1e28-a399634993d6
Version Independent ID: a92015a1-4f3a-8b1b-1794-5566af729d16
Content: Static IP address for egress traffic in Azure Kubernetes Service (AKS)
Content Source: articles/aks/egress.md
Service: container-service
GitHub Login: @mlearned
Microsoft Alias: mlearned

@larryms Thanks for the feedback. I see that in the Egress document focuses on controlling the egress ip from the AKS cluster. If we have a load balancer with multiple ips, Then it uses the first ip for sending the egress traffic. So adding a static ip to the load balancer solves this problem.
Adding static ip is discussed in both the docs.
I will assign this issue to the author to investigate further and update the doc as required.

Thank you for the feedback @larryclaman
At this time, the two docs are going to remain separate since they serve different purposes.
#please-close


After rebooting K3s restarts many times before eventually running normally

Environmental Info:
K3s Version: k3s version v1.19.4+k3s1 (2532c10f)

Node(s) CPU architecture, OS, and Version:
master: Linux k8master1 5.4.79-v7+ #1373 SMP Mon Nov 23 13:22:33 GMT 2020 armv7l GNU/Linux
node: Linux knode1 5.4.79-v7+ #1373 SMP Mon Nov 23 13:22:33 GMT 2020 armv7l GNU/Linux

Cluster Configuration:

1 Master 1 worker
Describe the bug:
Installing k3s with curl -sfL https://get.k3s.io | sh - on the master and curl -sfL https://get.k3s.io | sh - on the work with K3S_URL and K3S_TOKEN set on the worker brings the system up fine and I can deploy pods.
After restarting and monitoring systemctl status k3s and systemctl status k3s-agent I noticed the service being restarted over and over. After a period of about 20 minutes the cluster does eventually come up. This behaviour is also true for a single master however it takes less time for the cluster to stabalise
Steps To Reproduce:

Installed K3s:

Expected behavior:
After rebooting the cluster comes up in a timely manner
Actual behavior:
After rebooting the k3s service on both master and worker constantly restarts until eventually the cluster comes up
Additional context / logs:
k3smasterlog.txt
k3sworkerlog.txt

What sort of system is this running on? There are a lot of odd errors about missing system interfaces, and the logs seems to be indicating a slower than usual startup speed.

W1204 15:48:18.746569    1028 nvidia.go:83] Error reading "/sys/bus/pci/devices/": open /sys/bus/pci/devices/: no such file or directory
W1204 15:48:18.746666    1028 nvidia.go:61] NVIDIA GPU metrics will not be available: no NVIDIA devices found
W1204 15:48:18.751520    1028 sysinfo.go:203] Nodes topology is not available, providing CPU topology
W1204 15:48:18.752333    1028 sysfs.go:348] unable to read /sys/devices/system/cpu/cpu0/online: open /sys/devices/system/cpu/cpu0/online: no such file or directory
W1204 15:48:18.752488    1028 sysfs.go:348] unable to read /sys/devices/system/cpu/cpu1/online: open /sys/devices/system/cpu/cpu1/online: no such file or directory
W1204 15:48:18.752594    1028 sysfs.go:348] unable to read /sys/devices/system/cpu/cpu2/online: open /sys/devices/system/cpu/cpu2/online: no such file or directory
W1204 15:48:18.752696    1028 sysfs.go:348] unable to read /sys/devices/system/cpu/cpu3/online: open /sys/devices/system/cpu/cpu3/online: no such file or directory
W1204 15:48:18.753540    1028 machine.go:253] Cannot determine CPU /sys/bus/cpu/devices/cpu0 online state, skipping
W1204 15:48:18.753643    1028 machine.go:253] Cannot determine CPU /sys/bus/cpu/devices/cpu1 online state, skipping
W1204 15:48:18.753716    1028 machine.go:253] Cannot determine CPU /sys/bus/cpu/devices/cpu2 online state, skipping
W1204 15:48:18.753784    1028 machine.go:253] Cannot determine CPU /sys/bus/cpu/devices/cpu3 online state, skipping
E1204 15:48:18.753815    1028 machine.go:72] Cannot read number of physical cores correctly, number of cores set to 0

Both master and worker are raspberry pi 3s

What class SD card - IO performance is very important especially at startup when k3s is pulling images and starting pods. How much memory? Do you have swap disabled?

Class 10 sandisk ultra sd card
each Pi has 1g RAM
Swap was enabled I have disabled using the following https://www.paulcourt.co.uk/article/pi-swap
Can you show me where you have determined that the pi is very busy from the logs?

Why would a slow machine also cause the service to constantly restart? Are there some timeouts somewhere?
pi@k8master1:~ $ sudo systemctl status k3s
â k3s.service - Lightweight Kubernetes
   Loaded: loaded (/etc/systemd/system/k3s.service; enabled; vendor preset: enabled)
   Active: activating (start) since Fri 2020-12-04 19:01:06 GMT; 21s ago
     Docs: https://k3s.io
  Process: 938 ExecStartPre=/sbin/modprobe br_netfilter (code=exited, status=0/SUCCESS)
  Process: 939 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
 Main PID: 940 (k3s-server)
    Tasks: 11
   Memory: 215.9M
   CGroup: /system.slice/k3s.service
           ââ940 /usr/local/bin/k3s server
           ââ982 containerd

Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.851191     940 apiapproval_controller.go:186] Starting KubernetesAPIApprovalPolicyConformantConditionController
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.851655     940 crd_finalizer.go:266] Starting CRDFinalizer
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.853291     940 cluster_authentication_trust_controller.go:440] Starting cluster_authentication_trust_controller controller
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.853366     940 shared_informer.go:240] Waiting for caches to sync for cluster_authentication_trust_controller
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.855722     940 apiservice_controller.go:97] Starting APIServiceRegistrationController
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.855794     940 cache.go:32] Waiting for caches to sync for APIServiceRegistrationController controller
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.855876     940 available_controller.go:457] Starting AvailableConditionController
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.855905     940 cache.go:32] Waiting for caches to sync for AvailableConditionController controller
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.891549     940 dynamic_cafile_content.go:167] Starting client-ca-bundle::/var/lib/rancher/k3s/server/tls/client-ca.crt
Dec 04 19:01:27 k8master1 k3s[940]: I1204 19:01:27.891746     940 dynamic_cafile_content.go:167] Starting request-header::/var/lib/rancher/k3s/server/tls/request-header-ca.crt
pi@k8master1:~ $ ^C
pi@k8master1:~ $ sudo systemctl status k3s
â k3s.service - Lightweight Kubernetes
   Loaded: loaded (/etc/systemd/system/k3s.service; enabled; vendor preset: enabled)
   Active: activating (auto-restart) (Result: exit-code) since Fri 2020-12-04 19:01:28 GMT; 1s ago
     Docs: https://k3s.io
  Process: 938 ExecStartPre=/sbin/modprobe br_netfilter (code=exited, status=0/SUCCESS)
  Process: 939 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
  Process: 940 ExecStart=/usr/local/bin/k3s server (code=exited, status=1/FAILURE)
 Main PID: 940 (code=exited, status=1/FAILURE)

The logs contain a bunch of messages regarding timeouts waiting for things to sync, followed by a fatal error for RBAC that is usually created very early on in the startup process. Additionally, the time between startup log messages is longer than I would normally expect to see (I look at a fair bit of logs). I don't see any errors from the etcd layer, which are usually good indicators that the disk is overloaded - so I suspect it's just CPU/memory/swap related.

Do you think a couple of pi4s (4gb) on SD cards will help solve this issue? I don't have a use case for something I want running all the time rather I want something mostly reliable to play with
I do find it a bit frustrating that the cluster comes fine when I install it from scratch. yet it gets itself upset for quite a period of time on a reboot.

The first time it comes up, it has to wait while pulling all the images from the network. On subsequent starts it already has all the images available and can start everything running at once - which puts a lot of load on the CPU and memory.
I personally have a couple Pi4Bs in the basement that run k3s quite capably. SD cards work fine for basic testing, but if you're going to do anything IO intensive I would recommend using a USB SDD.

I'll take that into consideration thanks for your help

This is a shame... I was running a master on 1.18 with no issues on a Rpi2. Upgraded to 1.19 and started having these issues (btw the node is tainted, so doesn't even have load from pods).
A Rpi2 should be good enough to run just a master... would it be possible to override the startup timeout?

This is a shame... I was running a master on 1.18 with no issues on a Rpi2. Upgraded to 1.19 and started having these issues (btw the node is tainted, so doesn't even have load from pods).
A Rpi2 should be good enough to run just a master... would it be possible to override the startup timeout?

Yes agreed the whole reason I started using k3s was that I was told it would work run on this architecture.

It did used to work on RPi3 very well, just on SD cards. Perhaps try going back to 1.17?
@ibuildthecloud is there anything that can be tweaked for RPi3 as a server like tainting it? Adding an SSD will increase the cost 2-5x that of an RPi4.
This problem seems to be very apparent with 1.19, and made much worse with embedded etcd. There is an open issue here that I raised for the TuringPi. Many people bought those boards just because k3s ran on them at the time.

Confirmed v1.17.14-rc1+k3s3 with 1pi 3 as master + 1 pi3 and 1 pi2 as slaves and the system is up in a timely fashion after a reboot

I had similiar error:
Dec 04 15:51:00 k8master1 k3s[1429]: time="2020-12-04T15:51:00.827349132Z" level=fatal msg="networkpolicies.networking.k8s.io is forbidden: User \"system:k3s-controller\" cannot list resource \"networkpolicies\" in API group \"networking.k8s.io\" at the cluster scope"
while trying to run k3s on gcp virtual machines.

Kubernetes is a growing changing piece of software; as new features and new checks on existing features are added it is probably going to take more hardware to run, not less. Especially with the added overhead of a resource-hungry component like etcd. Kine makes it much easier to get Kubernetes to work on low-end hardware, but there will probably always come a point where old hardware can no longer keep up with newer versions of the stack. The CM3+ hardware is basically the same as the original CM3 that came out in 2017, around the time of Kubernetes 1.6!

Kubernetes is a growing changing piece of software; as new features and new checks on existing features are added it is probably going to take more hardware to run, not less. Especially with the added overhead of a resource-hungry component like etcd. Kine makes it much easier to get Kubernetes to work on low-end hardware, but there will probably always come a point where old hardware can no longer keep up with newer versions of the stack. The CM3+ hardware is basically the same as the original CM3 that came out in 2017, around the time of Kubernetes 1.6!

I can confirm that v1.18.15+k3s1 is working. I use a very fast USB3 stick to boot my Raspi3 but with the latest version of k3s I have no luck. After install everything is fine (I use docker as container engine) but after reboot the k3s service restarts after 18s or so and no container is spinning up.
I am not sure but I guess it is not only a matter of I / O because my USB stick should be fast enough. Ok it is not SSD but the Raspi3 has only USB2, so SSD on the Raspi3 makes no sense at all but for the Raspi4 it is another story ;-)

Anyone currently running into this problem - can you install the agnostics package (via apt on raspbian, or using the deb at https://archive.raspberrypi.org/debian/pool/main/a/agnostics/agnostics_0.6_armhf.deb on ubuntu), run /usr/share/agnostics/sdtest.sh and post the results?

SDCard 16GB Scandisk Ultra
Run 1
prepare-file;0;0;7534;14
seq-write;0;0;6345;12
rand-4k-write;0;0;2382;595
rand-4k-read;7268;1817;0;0
Sequential write speed 6345 KB/sec (target 10000) - FAIL
Note that sequential write speed declines over time as a card is used - your card may require reformatting
Random write speed 595 IOPS (target 500) - PASS
Random read speed 1817 IOPS (target 1500) - PASS
Run 2
prepare-file;0;0;4327;8
seq-write;0;0;2911;5
rand-4k-write;0;0;32;8
rand-4k-read;6650;1662;0;0
Sequential write speed 2911 KB/sec (target 10000) - FAIL
Note that sequential write speed declines over time as a card is used - your card may require reformatting
Random write speed 8 IOPS (target 500) - FAIL
Random read speed 1662 IOPS (target 1500) - PASS
Run 3
prepare-file;0;0;2785;5
seq-write;0;0;3178;6
rand-4k-write;0;0;2410;602
rand-4k-read;7297;1824;0;0
Sequential write speed 3178 KB/sec (target 10000) - FAIL
Note that sequential write speed declines over time as a card is used - your card may require reformatting
Random write speed 602 IOPS (target 500) - PASS
Random read speed 1824 IOPS (target 1500) - PASS

Hmm those are pretty marginal results. See the results at https://github.com/k3s-io/k3s/issues/2903#issuecomment-776422348 which are more in line with what I would be looking for from a SD card.

I missed your comment,
yes this card is a little bit old so I tested it on a new card and got the following results
Run 1
prepare-file;0;0;16453;32
seq-write;0;0;16181;31
rand-4k-write;0;0;2592;648
rand-4k-read;7634;1908;0;0
Sequential write speed 16181 KB/sec (target 10000) - PASS
Random write speed 648 IOPS (target 500) - PASS
Random read speed 1908 IOPS (target 1500) - PASS

I installed the latest k3s version on that card but no luck after reboot the k3s service restarts after 18s and no container is spinning up.


Performance reference unit

At the Performance reference section, please clarify the unit, does it mean Megabits per second or MegaBytes per second? I believe it is the later, but these acronyms have been used ambiguously everywhere.

Document Details
⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

ID: 0bbd66af-d49f-e595-a7bc-c48cd3675ddc
Version Independent ID: d3e43062-2f4e-a7a9-17f0-9c3e05d36f27
Content: Copy Activity performance and tuning guide in Azure Data Factory
Content Source: articles/data-factory/copy-activity-performance.md
Service: data-factory
GitHub Login: @linda33wj
Microsoft Alias: jingwang

@leopasta
Thanks for the feedback! We are currently investigating and will update you shortly.

@leopasta Thanks for the feedback. it says unit of measure is MBps. Usually in computer notation,  B refers to Bytes and b refers to bits . Therefore MBps refers to Mega Bytes per seconds.  We will now proceed to close this thread. If there are further questions regarding this matter, please reopen it and we will gladly continue the discussion.


Spoiler function.

Pretty simple and useful, a spoiler field that warns the user that it contains spoilers, and they must confirm they want to see it. Would be good for secrets, or even putting some of the features of the V3 spec into a "hidden" field.

Do you mean something like: "Click to reveal the text"?

Exactly that. Just to make a little barrier to revealing something important.
Currently I just make an entry called "SPOILER - DO NOT OPEN" in the lorebook, but it'd be nice to have a real spoiler function.

{{reverse:A}} is added for the spoilers. This will not serve as a spoiler warning, but it will still help prevent spoilers.

Cool.


Repair Rubocop violations

@irvingpop Can you review, so I can get Travis green again in preparation for a release?

:+1: both of those changes look good and don't appear to change any behavior.